Changeset 2620618


Ignore:
Timestamp:
Jan 12, 2012, 12:58:40 AM (12 years ago)
Author:
Jessica B. Hamrick <jhamrick@…>
Branches:
no-cups
Children:
609a9b0
Parents:
190bfb4
git-author:
Jessica B. Hamrick <jhamrick@…> (01/12/12 00:58:40)
git-committer:
Jessica B. Hamrick <jhamrick@…> (01/12/12 00:58:40)
Message:

Test cases for playing/pausing/stopping jobs

Location:
server
Files:
3 edited

Legend:

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

    r951ab1b r2620618  
    44import logging
    55import os
     6import time
    67
    78# initialize logger
     
    2324        self.name = name
    2425        self.priority = priority
     26        self._why_done = None
    2527
    2628        if document is not None:
    2729            self.spool(document)
    28 
    29         self._why_done = None
    3030
    3131    def __repr__(self):
     
    183183    @property
    184184    def state(self):
    185         """
     185        """State status codes; equivalent to the IPP job-state status
     186        codes.
     187       
    186188        State transitions are as follows:
    187 HELD ---> PENDING ---> PROCESSING <--> STOPPED (aka paused)
    188              ^              |---> CANCELLED
    189              |              |---> ABORTED
    190              |              |---> COMPLETE ---|
    191              |--------------------------------|
     189        HELD ---> PENDING ---> PROCESSING <--> STOPPED (aka paused)
     190                     ^              |---> CANCELLED
     191                     |              |---> ABORTED
     192                     |              |---> COMPLETE ---|
     193                     |--------------------------------|
     194                     
    192195        """
    193196        if self.is_ready:
  • server/lib/gutenbach/server/player.py

    r345c476 r2620618  
    1818            self._callback = None
    1919            self._paused = False
     20            self._done = False
     21            self._dryrun = False
     22            self._dryrun_time = 0.5
    2023
    2124    @property
    2225    def is_playing(self):
    2326        with self.lock:
    24             playing = self.player and self.player.poll() is None
     27            if self._dryrun:
     28                playing = self.isAlive() and not self.is_done
     29            else:
     30                playing = self.isAlive() and \
     31                          not self.is_done and \
     32                          self.player is not None and \
     33                          self.player.poll() is None
    2534        return playing
    2635
     
    3342    @property
    3443    def is_done(self):
    35         with self.lock:
    36             done = self.player and self.player.poll() is not None
    37         return done
     44        return self._done
    3845
    3946    @property
     
    5057       
    5158        self.mplayer_play()
     59        self._done = True
    5260        with self.lock:
    5361            if self.callback:
     
    6068        logger.info("playing file '%s'" % self.fh.name)
    6169        self._paused = False
     70
     71        if self._dryrun:
     72            step = 0.01
     73            while self._dryrun_time > 0:
     74                time.sleep(step)
     75                self._dryrun_time -= step
     76                while self.is_paused:
     77                    time.sleep(0.01)
     78            return
    6279       
    6380        # open mplayer
     
    7996
    8097        logger.info("mplayer finished with code %d" % self.player.returncode)
    81 
     98       
    8299        # get output from mplayer and log it
    83100        with self.lock:
     
    91108
    92109    def mplayer_pause(self):
    93         if not self.isAlive():
    94             return
    95        
    96110        with self.lock:
    97111            if self.is_playing:
    98                 self.player.stdin.write("pause\n")
     112                if not self._dryrun:
     113                    self.player.stdin.write("pause\n")
    99114                self._paused = not(self._paused)
     115                logger.info("paused: %s", self.is_paused)
     116            else:
     117                logger.warning("trying to pause non-playing job")
    100118               
    101119    def mplayer_stop(self):
    102         if not self.isAlive():
    103             return
    104        
    105120        with self.lock:
    106121            if self.is_playing:
    107                 self.player.stdin.write("quit\n")
     122                if not self._dryrun:
     123                    self.player.stdin.write("quit\n")
     124                else:
     125                    self._dryrun_time = 0.0
     126                logger.info("stopped")
     127            else:
     128                logger.warning("trying to stop non-playing job")
  • server/test/server/job.py

    r951ab1b r2620618  
    55import tempfile
    66import sys
     7import time
    78
    89def make_tempfile():
     
    113114            priority=1)
    114115        self.assertRaises(errors.InvalidDocument, job.spool, "hello")
     116        self.assertRaises(errors.InvalidDocument, job.spool, [])
     117        self.assertRaises(errors.InvalidDocument, job.spool, 12345)
     118
     119        fh = make_tempfile()
     120        job = GutenbachJob(
     121            job_id=1,
     122            creator="foo",
     123            name="test",
     124            priority=1,
     125            document=fh)
     126        self.assertRaises(errors.InvalidJobStateException, job.spool, "hello")
     127        self.assertRaises(errors.InvalidJobStateException, job.spool, [])
     128        self.assertRaises(errors.InvalidJobStateException, job.spool, 12345)
     129
     130class TestOperations(unittest.TestCase):
     131
     132    def setUp(self):
     133        fh = make_tempfile()
     134        self.job = GutenbachJob(
     135            job_id=1,
     136            creator="foo",
     137            name="test",
     138            priority=1,
     139            document=fh)
     140        self.job.player._dryrun = True
     141
     142    def testPlay(self):
     143        self.job.play()
     144        time.sleep(0.01)
     145        self.assertTrue(self.job.is_playing)
     146
     147        while self.job.is_playing:
     148            time.sleep(0.1)
     149
     150        self.assertTrue(self.job.is_done)
     151        self.assertTrue(self.job.is_completed)
     152        self.assertFalse(self.job.is_aborted)
     153        self.assertFalse(self.job.is_cancelled)
     154
     155    def testPause(self):
     156        self.job.play()
     157        time.sleep(0.01)
     158        self.assertTrue(self.job.is_playing)
     159        self.assertFalse(self.job.is_paused)
     160
     161        self.job.pause()
     162        self.assertTrue(self.job.is_playing)
     163        self.assertTrue(self.job.is_paused)
     164
     165        time.sleep(0.6)
     166        self.assertTrue(self.job.is_playing)
     167        self.assertTrue(self.job.is_paused)
     168
     169        self.job.pause()
     170        self.assertTrue(self.job.is_playing)
     171        self.assertFalse(self.job.is_paused)
    115172       
    116 class TestGoodGutenbachJob(unittest.TestCase):
    117 
    118     def setUp(self):
    119         self.job = GutenbachJob(job_id=1, creator="foo", name="test")
    120 
    121     def testSpool(self):
    122         fh = make_tempfile()
    123         self.assertTrue(self.job.is_valid)
    124         self.assertFalse(self.job.is_ready)
    125         self.job.spool(fh)
    126         self.assertTrue(self.job.is_ready)
    127        
    128         # Verify various properties
    129         self.assertEqual(self.job.document, fh.name)
    130         self.assertNotEqual(self.job.player, None)
    131         self.assertEqual(self.job.state, States.PENDING)
     173        while self.job.is_playing:
     174            time.sleep(0.1)
     175           
     176        self.assertTrue(self.job.is_done)
     177        self.assertTrue(self.job.is_completed)
     178        self.assertFalse(self.job.is_aborted)
     179        self.assertFalse(self.job.is_cancelled)
     180
     181    def testCancel(self):
     182        self.job.play()
     183        time.sleep(0.01)
     184        self.assertTrue(self.job.is_playing)
     185        self.assertFalse(self.job.is_cancelled)
     186
     187        self.job.cancel()
     188        time.sleep(0.01)
     189        self.assertFalse(self.job.is_playing)
     190        self.assertTrue(self.job.is_done)
     191        self.assertTrue(self.job.is_cancelled)
     192        self.assertFalse(self.job.is_aborted)
     193
     194    def testAbort(self):
     195        self.job.play()
     196        time.sleep(0.01)
     197        self.assertTrue(self.job.is_playing)
     198        self.assertFalse(self.job.is_aborted)
    132199
    133200        self.job.abort()
    134 
     201        time.sleep(0.01)
     202        self.assertFalse(self.job.is_playing)
     203        self.assertTrue(self.job.is_done)
     204        self.assertFalse(self.job.is_cancelled)
     205        self.assertTrue(self.job.is_aborted)
    135206
    136207if __name__ == "__main__":
Note: See TracChangeset for help on using the changeset viewer.