def setUp(self): super(TestMultiLock, self).setUp() self.lock_one = defer.DeferredLock() self.lock_two = defer.DeferredLock() self.multi_lock = MultiLock(self.lock_one, self.lock_two) self.count = 0
class TestMultiLock(TestCase): def setUp(self): super(TestMultiLock, self).setUp() self.lock_one = defer.DeferredLock() self.lock_two = defer.DeferredLock() self.multi_lock = MultiLock(self.lock_one, self.lock_two) self.count = 0 def callback(self): self.count += 1 def test_run_does_not_wait_when_there_is_no_need_to(self): """Multilock.run will run any given task if it's not locked and there's no task currently running. """ self.multi_lock.run(self.callback) self.assertEquals(self.count, 1, "self.callback should have run.") self.multi_lock.run(self.callback) self.assertEquals(self.count, 2, "self.callback should have run twice.") def test_run_waits_for_first_lock(self): """MultiLock.run acquires the first lock before running a function.""" # Keep lock_one busy. deferred = defer.Deferred() self.lock_one.run(lambda: deferred) # Run self.callback when self.multi_lock is acquired. self.multi_lock.run(self.callback) self.assertEquals(self.count, 0, "self.callback should not have run yet.") # Release lock_one. deferred.callback(None) # multi_lock will now have been able to acquire both semaphores, and # so it will have run its task. self.assertEquals(self.count, 1, "self.callback should have run.") def test_run_waits_for_second_lock(self): """MultiLock.run acquires the second lock before running functions.""" # Keep lock_two busy. deferred = defer.Deferred() self.lock_two.run(lambda: deferred) # Run self.callback when self.multi_lock is acquired. self.multi_lock.run(self.callback) self.assertEquals(self.count, 0, "self.callback should not have run yet.") # Release lock_two. deferred.callback(None) # multi_lock will now have been able to acquire both semaphores, and # so it will have run its task. self.assertEquals(self.count, 1, "self.callback should have run.") def test_run_waits_for_current_task(self): """MultiLock.run waits the end of the current task before running the next. """ # Keep multi_lock busy. deferred = defer.Deferred() self.multi_lock.run(lambda: deferred) # Run self.callback when self.multi_lock is acquired. self.multi_lock.run(self.callback) self.assertEquals(self.count, 0, "self.callback should not have run yet.") # Release lock_one. deferred.callback(None) # multi_lock will now have been able to acquire both semaphores, and # so it will have run its task. self.assertEquals(self.count, 1, "self.callback should have run.")
class TestMultiLock(TestCase): def setUp(self): super(TestMultiLock, self).setUp() self.lock_one = defer.DeferredLock() self.lock_two = defer.DeferredLock() self.multi_lock = MultiLock(self.lock_one, self.lock_two) self.count = 0 def callback(self): self.count += 1 def test_run_does_not_wait_when_there_is_no_need_to(self): """Multilock.run will run any given task if it's not locked and there's no task currently running. """ self.multi_lock.run(self.callback) self.assertEquals(self.count, 1, "self.callback should have run.") self.multi_lock.run(self.callback) self.assertEquals( self.count, 2, "self.callback should have run twice.") def test_run_waits_for_first_lock(self): """MultiLock.run acquires the first lock before running a function.""" # Keep lock_one busy. deferred = defer.Deferred() self.lock_one.run(lambda: deferred) # Run self.callback when self.multi_lock is acquired. self.multi_lock.run(self.callback) self.assertEquals( self.count, 0, "self.callback should not have run yet.") # Release lock_one. deferred.callback(None) # multi_lock will now have been able to acquire both semaphores, and # so it will have run its task. self.assertEquals(self.count, 1, "self.callback should have run.") def test_run_waits_for_second_lock(self): """MultiLock.run acquires the second lock before running functions.""" # Keep lock_two busy. deferred = defer.Deferred() self.lock_two.run(lambda: deferred) # Run self.callback when self.multi_lock is acquired. self.multi_lock.run(self.callback) self.assertEquals( self.count, 0, "self.callback should not have run yet.") # Release lock_two. deferred.callback(None) # multi_lock will now have been able to acquire both semaphores, and # so it will have run its task. self.assertEquals(self.count, 1, "self.callback should have run.") def test_run_waits_for_current_task(self): """MultiLock.run waits the end of the current task before running the next. """ # Keep multi_lock busy. deferred = defer.Deferred() self.multi_lock.run(lambda: deferred) # Run self.callback when self.multi_lock is acquired. self.multi_lock.run(self.callback) self.assertEquals( self.count, 0, "self.callback should not have run yet.") # Release lock_one. deferred.callback(None) # multi_lock will now have been able to acquire both semaphores, and # so it will have run its task. self.assertEquals(self.count, 1, "self.callback should have run.")