Changeset d42236e


Ignore:
Timestamp:
Jan 21, 2012, 11:14:07 PM (12 years ago)
Author:
Jessica B. Hamrick <jhamrick@…>
Branches:
no-cups
Children:
75928fe
Parents:
3cb6c7b
git-author:
Jessica B. Hamrick <jhamrick@…> (01/21/12 23:12:03)
git-committer:
Jessica B. Hamrick <jhamrick@…> (01/21/12 23:14:07)
Message:

Fix a few more bugs in printer.py and update test cases for printer.py

Location:
server
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • server/lib/gutenbach/server/player.py

    rbd5bffc rd42236e  
    133133                else:
    134134                    self._dryrun_time = 0.0
     135                self._paused = False
    135136                logger.info("stopped")
    136137            else:
  • server/lib/gutenbach/server/printer.py

    r7e29e6a rd42236e  
    66import time
    77import threading
    8 import heapq
    98import traceback
    109import sys
     
    102101        self._running = True
    103102        while self._running:
    104             try:
    105                 with self.lock:
     103            with self.lock:
     104                try:
    106105                    if self.current_job is None:
    107106                        self.start_job()
    108107                    elif self.current_job.is_done:
    109108                        self.complete_job()
    110             except:
    111                 logger.fatal(traceback.format_exc())
    112                 sys.exit(1)
     109                except:
     110                    self._running = False
     111                    logger.fatal(traceback.format_exc())
     112                    break
    113113            time.sleep(0.1)
    114114
    115115    def stop(self):
    116116        with self.lock:
     117            for job in self.jobs.keys():
     118                try:
     119                    self.jobs[job].abort()
     120                    del self.jobs[job]
     121                except InvalidJobStateException:
     122                    pass
     123               
    117124            self._running = False
    118125        if self.ident is not None and self.isAlive():
     
    159166    @sync
    160167    def state(self):
    161         if self.is_running and self.current_job is not None:
    162             state = States.PROCESSING
    163         elif self.is_running and len(self.pending_jobs) == 0:
    164             state = States.IDLE
     168        if self.is_running and not self.paused:
     169            if len(self.active_jobs) > 0:
     170                state = States.PROCESSING
     171            else:
     172                state = States.IDLE
    165173        else:
    166174            state = States.STOPPED
     175
    167176        return state
    168177
     
    194203        if not self.paused and self.current_job is None:
    195204            try:
    196                 job_id = heapq.heappop(self.pending_jobs)
     205                job_id = self.pending_jobs.pop(0)
    197206                self.current_job = self.get_job(job_id)
    198207                self.current_job.play()
    199208            except IndexError:
    200                 self.current_job = None
    201             except InvalidJobStateException:
    202                 heapq.heappush(self.pending_jobs, self.current_job.id)
    203209                self.current_job = None
    204210                   
     
    530536
    531537    @sync
    532     def create_job(self, requesting_user_name=None, job_name=None,
    533                    job_k_octets=None):
     538    def create_job(self, requesting_user_name=None,
     539                   job_name=None, job_k_octets=None):
    534540
    535541        self.assert_running()
     
    544550
    545551        self.jobs[job_id] = job
    546         self.pending_jobs.append(job_id)
    547        
    548552        return job_id
    549553
     
    617621        job = self.get_job(job_id)
    618622        job.spool(document)
    619 
     623        if 'dryrun' in self.config and self.config['dryrun']:
     624            job.player._dryrun = True
     625        self.pending_jobs.append(job_id)
     626       
    620627    @sync
    621628    def send_uri(self, job_id, document_uri, document_name=None,
     
    628635        # XXX: need to validate URI
    629636        # XXX: need to deal with the URI stream?
     637
    630638        #job.spool_uri(document_uri)
    631 
     639        #if 'dryrun' in self.config and self.config['dryrun']:
     640        #    job.player._dryrun = True
     641        #self.pending_jobs.append(job_id)
     642       
    632643    @sync
    633644    def get_job_attributes(self, job_id, requested_attributes=None):
  • server/test/server/printer.py

    rd518298 rd42236e  
    33from gutenbach.server import errors
    44
    5 from gutenbach.ipp import JobStates as States
     5from gutenbach.ipp import PrinterStates as States
    66import unittest
    77import tempfile
    88import time
     9import logging
     10import threading
    911
    1012def make_tempfile():
     
    1416    return fh
    1517
    16 class TestGutenbachPrinter(unittest.TestCase):
     18class TestEmptyGutenbachPrinter(unittest.TestCase):
    1719
    1820    testJobName = "unique_test_job"
    1921    testJobRequestingUserName = "unique_test_username"
     22    testPrinterConfig = {
     23        'ipp-versions': ["1.0", "1.1"]
     24        }
    2025
    2126    def setUp(self):
    22         self.printer = GutenbachPrinter("test")
     27        self.printer = GutenbachPrinter("test", self.testPrinterConfig)
     28
     29    def testName(self):
     30        self.assertEqual(self.printer.name, "test")
     31    def testConfig(self):
     32        self.assertEqual(self.printer.config, self.testPrinterConfig)
     33    def testTimeCreated(self):
     34        self.assertTrue(self.printer.time_created is not None)
     35    def testFinishedJobs(self):
     36        self.assertEqual(self.printer.finished_jobs, [])
     37    def testPendingJobs(self):
     38        self.assertEqual(self.printer.pending_jobs, [])
     39    def testCurrentJob(self):
     40        self.assertEqual(self.printer.current_job, None)
     41    def testJobs(self):
     42        self.assertEqual(self.printer.jobs, {})
     43    def testActiveJobs(self):
     44        self.assertEqual(self.printer.active_jobs, [])
     45    def testRunning(self):
     46        self.assertEqual(self.printer.is_running, False)
     47    def testPaused(self):
     48        self.assertEqual(self.printer.paused, False)
     49    def testNextJobId(self):
     50        self.assertEqual(self.printer._next_job_id, 1)
     51    def testState(self):
     52        self.assertEqual(self.printer.state, States.STOPPED)
     53
     54    def testStartJob(self):
     55        self.assertRaises(RuntimeError, self.printer.start_job)
     56    def testCompleteJob(self):
     57        self.assertRaises(RuntimeError, self.printer.complete_job)
     58    def testGetJob(self):
     59        self.assertRaises(RuntimeError, self.printer.get_job, 0)
     60
     61    def testIPPAttributes(self):
     62        for attribute in self.printer.printer_attributes:
     63            attr = attribute.replace("-", "_")
     64            self.assertRaises(RuntimeError, getattr, self.printer, attr)
     65            self.assertRaises(RuntimeError, setattr, self.printer, attr, None)
     66        for attribute in self.printer.job_attributes:
     67            attr = getattr(self.printer, attribute.replace("-", "_"))
     68            self.assertRaises(RuntimeError, attr, 0)
     69
     70    def testIPPOperations(self):
     71        self.assertRaises(RuntimeError, self.printer.print_job, None)
     72        self.assertRaises(RuntimeError, self.printer.validate_job)
     73        self.assertRaises(RuntimeError, self.printer.get_jobs)
     74        self.assertRaises(RuntimeError, self.printer.print_uri)
     75        self.assertRaises(RuntimeError, self.printer.create_job)
     76        self.assertRaises(RuntimeError, self.printer.pause_printer)
     77        self.assertRaises(RuntimeError, self.printer.resume_printer)
     78        self.assertRaises(RuntimeError, self.printer.get_printer_attributes)
     79        self.assertRaises(RuntimeError, self.printer.set_printer_attributes, {})
     80        self.assertRaises(RuntimeError, self.printer.cancel_job, 0)
     81        self.assertRaises(RuntimeError, self.printer.send_document, 0, None)
     82        self.assertRaises(RuntimeError, self.printer.send_uri, 0, "")
     83        self.assertRaises(RuntimeError, self.printer.get_job_attributes, 0)
     84        self.assertRaises(RuntimeError, self.printer.set_job_attributes, 0, {})
     85        self.assertRaises(RuntimeError, self.printer.restart_job, 0)
     86        self.assertRaises(RuntimeError, self.printer.promote_job, 0)
     87
     88class TestBadEmptyGutenbachPrinter(unittest.TestCase):
     89
     90    testJobName = "unique_test_job"
     91    testJobRequestingUserName = "unique_test_username"
     92    testPrinterConfig = {
     93        'ipp-versions': ["1.0", "1.1"]
     94        }
     95
     96    def testBadPrinterName(self):
     97        printer = GutenbachPrinter(None, self.testPrinterConfig)
     98        self.assertEqual(printer.name, "None")
     99        printer.name = "foo"
     100        self.assertEqual(printer.name, "foo")
     101        printer.name = 1234
     102        self.assertEqual(printer.name, "1234")
     103        printer.name = []
     104        self.assertEqual(printer.name, "[]")
     105
     106    def testBadConfig(self):
     107        self.assertRaises(ValueError, GutenbachPrinter, "test", {})
     108        self.assertRaises(ValueError, GutenbachPrinter, "test", {"hello": 1234})
     109        self.assertRaises(ValueError, GutenbachPrinter, "test", [])
     110        self.assertRaises(ValueError, GutenbachPrinter, "test", 1234)
     111        self.assertRaises(ValueError, GutenbachPrinter, "test", "hello")
     112        conf = self.testPrinterConfig.copy()
     113        printer = GutenbachPrinter("test", conf)
     114        printer.config = conf.items()
     115        self.assertEqual(printer.config, conf)
     116        conf["hello"] = "goodbye"
     117        self.assertNotEqual(printer.config, conf)
     118        printer.config = conf
     119        self.assertEqual(printer.config, conf)
     120
     121class TestGutenbachPrinter(unittest.TestCase):
     122
     123    testJobName = "unique_test_job"
     124    testJobRequestingUserName = "unique_test_username"
     125    testPrinterConfig = {
     126        'ipp-versions': ["1.0", "1.1"],
     127        'dryrun': True
     128        }
     129
     130    def setUp(self):
     131        self.printer = GutenbachPrinter("test", self.testPrinterConfig)
    23132        self.printer.start()
     133        while not self.printer.is_running:
     134            time.sleep(0.01)
    24135
    25136    def tearDown(self):
    26         self.printer.running = False
    27         self.printer.join()
    28 
    29     # nb: this test assumes that pause_printer will block until it has paused.
     137        self.printer.stop()
     138
     139    def createTestJob(self):
     140        job_id = self.printer.create_job(
     141            self.testJobRequestingUserName,
     142            self.testJobName)
     143        return job_id
     144
     145    def testPrintJob(self):
     146        pass
     147
     148    def testValidateJob(self):
     149        pass
     150
     151    def testGetJobs(self):
     152        pass
     153
     154    def testPrintUri(self):
     155        pass
     156
     157    def testCreateJob(self):
     158        for i in xrange(2):
     159            countBeforeAdded = len(self.printer.jobs)
     160            job = self.createTestJob()
     161            self.assertEqual(len(self.printer.jobs) - 1, countBeforeAdded)
     162            self.printer.send_document(job, make_tempfile())
     163            self.assertTrue(job in self.printer.pending_jobs)
     164            self.assertFalse(job in self.printer.finished_jobs)
     165            self.assertEqual(self.printer.state, States.PROCESSING)
     166
     167        while len(self.printer.active_jobs) > 0:
     168            time.sleep(0.01)
     169        self.assertEqual(self.printer.state, States.IDLE)
     170
    30171    def testPausePrinter(self):
     172        job = self.createTestJob()
     173        self.printer.send_document(job, make_tempfile())
     174        job = self.createTestJob()
     175        self.printer.send_document(job, make_tempfile())
     176        self.assertTrue(self.printer.is_running)
     177        self.assertEqual(self.printer.state, States.PROCESSING)
     178        self.assertFalse(self.printer.paused)
     179
     180        while self.printer.current_job is None:
     181            time.sleep(0.01)
     182
    31183        self.printer.pause_printer()
    32         self.assertEqual(self.printer.paused, True)
     184        self.assertTrue(self.printer.paused)
     185        time.sleep(0.6)
     186        self.assertTrue(self.printer.current_job is not None)
     187        self.assertEqual(self.printer.state, States.STOPPED)
    33188
    34189        # check that no jobs are playing
    35190        for job_id, job in self.printer.jobs.items():
    36             self.assertEqual(job.is_playing(), False)
    37 
    38     def createTestJob(self):
    39         return self.printer.create_job(self.testJobRequestingUserName, self.testJobName)
    40  
    41     def testCreateJob(self):
    42         countBeforeAdded = len(self.printer.jobs)
    43         job_id = self.createTestJob()
    44         self.assertEqual(len(self.printer.jobs) - 1, countBeforeAdded)
    45 
    46         queued_job = self.printer.get_job(job_id)
    47         b = queued_job is not None
    48         self.assertTrue(b)
    49         self.assertEqual(queued_job.name, self.testJobName)
    50         self.assertEqual(queued_job.creator, self.testJobRequestingUserName)
    51         self.assertEqual(queued_job.state, States.HELD)
     191            self.assertEqual(job.is_paused, job.is_playing)
    52192
    53193    def testResumePrinter(self):
     194        job = self.createTestJob()
     195        self.printer.send_document(job, make_tempfile())
     196        job = self.createTestJob()
     197        self.printer.send_document(job, make_tempfile())
     198        self.assertTrue(self.printer.is_running)
     199        self.assertEqual(self.printer.state, States.PROCESSING)
     200        self.assertFalse(self.printer.paused)
     201
     202        while self.printer.current_job is None:
     203            time.sleep(0.01)
     204
     205        self.printer.pause_printer()
     206        self.assertTrue(self.printer.paused)
     207        time.sleep(0.6)
     208        self.assertTrue(self.printer.current_job is not None)
     209        self.assertEqual(self.printer.state, States.STOPPED)
     210
     211        # check that no jobs are playing
     212        for job_id, job in self.printer.jobs.items():
     213            self.assertEqual(job.is_paused, job.is_playing)
     214
    54215        self.printer.resume_printer()
    55         self.assertEqual(self.printer.paused, False)
    56 
    57     def testJobPlays(self):
    58         job_id = self.createTestJob()
    59         fh = make_tempfile()
    60         self.printer.get_job(job_id).spool(fh)
    61         self.assertTrue(job_id in self.printer.pending_jobs)
    62         self.assertFalse(job_id in self.printer.finished_jobs)
    63         self.printer.complete_job()
    64         while (self.printer.get_job(job_id).state == States.PENDING):
    65             time.sleep(0.1)
    66             continue
    67        
    68         non_pending_job = self.printer.get_job(job_id)
    69         self.assertTrue(non_pending_job.state == States.COMPLETE)
    70 
    71         self.assertFalse(job_id in self.printer.pending_jobs)
    72         self.assertTrue(job_id in self.printer.finished_jobs)
     216        self.assertFalse(self.printer.paused)
     217        self.assertEqual(self.printer.state, States.PROCESSING)
     218
     219        while len(self.printer.active_jobs) > 0:
     220            time.sleep(0.01)
     221        self.assertEqual(self.printer.state, States.IDLE)
     222
     223    def testGetPrinterAttributes(self):
     224        pass
     225
     226    def testSetPrinterAttributes(self):
     227        pass
     228
     229    def testCancelJob(self):
     230        pass
     231
     232    def testSendDocument(self):
     233        pass
     234
     235    def testSendUri(self):
     236        pass
     237
     238    def testGetJobAttributes(self):
     239        pass
     240
     241    def testSetJobAttributes(self):
     242        pass
     243
     244    def testRestartJob(self):
     245        pass
     246
     247    def testPromoteJob(self):
     248        pass
    73249
    74250if __name__ == "__main__":
     251    logging.basicConfig(loglevel=logging.DEBUG)
    75252    unittest.main()
Note: See TracChangeset for help on using the changeset viewer.