Exemple #1
0
    def test_method_failure(self):
        """
        If method fails, lock is released and failure is propogated
        Acquisition and release is logged with time taken
        """
        self.method.return_value = fail(ValueError('a'))

        d = with_lock(self.reactor, self.lock, self.method, self.log)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with(
            'Starting lock acquisition', lock_status='Acquiring',
            **self.log_fields)

        self.reactor.advance(10)
        self.acquire_d.callback(None)
        self.assertEqual(
            self.log.msg.mock_calls[-2:],
            [mock.call('Lock acquisition in 10.0 seconds',
                       acquire_time=10.0, lock_status='Acquired',
                       **self.log_fields),
             mock.call('Starting lock release', lock_status='Releasing',
                       **self.log_fields)])
        self.method.assert_called_once_with()

        self.reactor.advance(3)
        self.release_d.callback(None)
        self.log.msg.assert_called_with('Lock release in 3.0 seconds',
                                        release_time=3.0,
                                        lock_status='Released',
                                        **self.log_fields)

        self.failureResultOf(d, ValueError)
Exemple #2
0
    def test_methods_failure(self):
        """
        If method fails, lock is released and failure is propogated
        Acquisition and release is logged with time taken
        """
        acquire_d, release_d = Deferred(), Deferred()
        self.lock.acquire.side_effect = lambda: acquire_d
        self.lock.release.side_effect = lambda: release_d
        self.method.return_value = fail(ValueError('a'))

        d = with_lock(self.reactor, self.lock, self.log, self.method, 2, a=3)
        self.assertNoResult(d)

        self.reactor.advance(10)
        acquire_d.callback(None)
        self.log.msg.assert_called_once_with('Lock acquisition in 10.0 seconds',
                                             acquire_time=10.0)
        self.method.assert_called_once_with(2, a=3)

        self.reactor.advance(3)
        release_d.callback(None)
        self.log.msg.assert_called_with('Lock release in 3.0 seconds',
                                        release_time=3.0)
        self.assertEqual(self.log.msg.call_count, 2)

        self.failureResultOf(d, ValueError)
Exemple #3
0
    def test_acquire_release(self):
        """
        Acquires, calls method, releases and returns method's result. Logs time taken
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with(
            'Starting lock acquisition', lock_status='Acquiring',
            **self.log_fields)
        self.reactor.advance(10)
        self.acquire_d.callback(None)
        self.log.msg.assert_called_with(
            'Lock acquisition in 10.0 seconds',
            lock_status='Acquired', acquire_time=10.0, **self.log_fields)
        self.method.assert_called_once_with()
        self.method_d.callback('result')

        self.log.msg.assert_called_with(
            'Starting lock release', lock_status='Releasing',
            **self.log_fields)
        self.reactor.advance(3)
        self.release_d.callback(None)
        self.log.msg.assert_called_with(
            'Lock release in 3.0 seconds',
            release_time=3.0, lock_status='Released', **self.log_fields)

        self.assertEqual(self.successResultOf(d), 'result')

        # And since the release successfully happened, the "held too long" log
        # message will _not_ be emitted
        self.reactor.advance(120)
        self.assertNotIn(
            self.too_long_message,
            (call[1][0] for call in self.log.msg.mock_calls))
Exemple #4
0
    def test_acquire_timeout(self):
        """
        acquire is timed out if it does not succeed in a given time
        """
        d = with_lock(self.reactor,
                      self.lock,
                      self.method,
                      self.log,
                      acquire_timeout=9)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with('Starting lock acquisition',
                                             lock_status='Acquiring',
                                             **self.log_fields)

        self.reactor.advance(10)
        f = self.failureResultOf(d, TimedOutError)
        self.assertEqual(f.value.message,
                         'Lock acquisition timed out after 9 seconds.')
        self.log.msg.assert_called_with(
            'Lock acquisition failed in 10.0 seconds',
            lock_status='Failed',
            **self.log_fields)

        self.assertFalse(self.method.called)
        self.assertFalse(self.lock.release.called)
Exemple #5
0
 def test_held_too_long(self):
     """When the lock is held for some time, a log message is emitted."""
     d = with_lock(self.reactor, self.lock, self.method, self.log)
     self.assertNoResult(d)
     self.acquire_d.callback(None)
     self.method.assert_called_once_with()
     self.reactor.advance(120)
     self.log.msg.assert_called_with(
         self.too_long_message,
         isError=True, lock_status='Acquired', **self.log_fields)
Exemple #6
0
    def test_acquire_failed(self):
        """
        If acquire fails, method and release is not called. Acquisition failed is logged
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with('Starting lock acquisition')

        self.reactor.advance(10)
        self.acquire_d.errback(ValueError(None))
        self.log.msg.assert_called_with('Lock acquisition failed in 10.0 seconds')
        self.assertFalse(self.method.called)
        self.failureResultOf(d, ValueError)
Exemple #7
0
    def test_release_timeout(self):
        """
        release is timed out if it does not succeed in a given time
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log,
                      release_timeout=9)
        self.acquire_d.callback(None)

        self.method.assert_called_once_with()
        self.method_d.callback('result')
        self.lock.release.assert_called_once_with()

        self.reactor.advance(10)
        f = self.failureResultOf(d, TimedOutError)
        self.assertEqual(f.value.message, 'Lock release timed out after 9 seconds.')
Exemple #8
0
    def test_acquire_failed(self):
        """
        If acquire fails, method and release is not called. Acquisition failed is logged
        """
        acquire_d = Deferred()
        self.lock.acquire.side_effect = lambda: acquire_d

        d = with_lock(self.reactor, self.lock, self.log, self.method, 2, a=3)
        self.assertNoResult(d)

        self.reactor.advance(10)
        acquire_d.errback(ValueError(None))
        self.log.msg.assert_called_once_with('Lock acquisition failed in 10.0 seconds')
        self.assertFalse(self.method.called)
        self.failureResultOf(d, ValueError)
Exemple #9
0
    def test_release_timeout(self):
        """
        release is timed out if it does not succeed in a given time
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log,
                      release_timeout=9)
        self.acquire_d.callback(None)

        self.method.assert_called_once_with()
        self.method_d.callback('result')
        self.lock.release.assert_called_once_with()

        self.reactor.advance(10)
        f = self.failureResultOf(d, TimedOutError)
        self.assertEqual(f.value.message,
                         'Lock release timed out after 9 seconds.')
Exemple #10
0
    def test_acquire_release_no_log(self):
        """
        Acquires, calls method and releases even if log is None
        """
        d = with_lock(self.reactor, self.lock, self.method)
        self.assertNoResult(d)

        self.reactor.advance(10)
        self.acquire_d.callback(None)
        self.method.assert_called_once_with()
        self.method_d.callback('result')

        self.reactor.advance(3)
        self.release_d.callback(None)

        self.assertEqual(self.successResultOf(d), 'result')
Exemple #11
0
    def test_acquire_timeout(self):
        """
        acquire is timed out if it does not succeed in a given time
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log,
                      acquire_timeout=9)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with('Starting lock acquisition')

        self.reactor.advance(10)
        f = self.failureResultOf(d, TimedOutError)
        self.assertEqual(f.value.message, 'Lock acquisition timed out after 9 seconds.')
        self.log.msg.assert_called_with('Lock acquisition failed in 10.0 seconds')

        self.assertFalse(self.method.called)
        self.assertFalse(self.lock.release.called)
Exemple #12
0
    def test_acquire_failed(self):
        """
        If acquire fails, method and release is not called. Acquisition failed is logged
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with(
            'Starting lock acquisition', lock_status='Acquiring',
            **self.log_fields)

        self.reactor.advance(10)
        self.acquire_d.errback(ValueError(None))
        self.log.msg.assert_called_with(
            'Lock acquisition failed in 10.0 seconds', lock_status='Failed',
            **self.log_fields)
        self.assertFalse(self.method.called)
        self.failureResultOf(d, ValueError)
Exemple #13
0
    def test_acquire_release(self):
        """
        Acquires, calls method, releases and returns method's result. Logs time taken
        """
        d = with_lock(self.reactor, self.lock, self.method, self.log)
        self.assertNoResult(d)
        self.log.msg.assert_called_once_with('Starting lock acquisition')

        self.reactor.advance(10)
        self.acquire_d.callback(None)
        self.log.msg.assert_called_with('Lock acquisition in 10.0 seconds',
                                        acquire_time=10.0)
        self.method.assert_called_once_with()
        self.method_d.callback('result')

        self.log.msg.assert_called_with('Starting lock release')
        self.reactor.advance(3)
        self.release_d.callback(None)
        self.log.msg.assert_called_with('Lock release in 3.0 seconds',
                                        release_time=3.0)

        self.assertEqual(self.successResultOf(d), 'result')
Exemple #14
0
    def test_acquire_release(self):
        """
        Acquires, calls method, releases and returns method's result. Logs time taken
        """
        acquire_d, release_d = Deferred(), Deferred()
        self.lock.acquire.side_effect = lambda: acquire_d
        self.lock.release.side_effect = lambda: release_d

        d = with_lock(self.reactor, self.lock, self.log, self.method, 2, a=3)
        self.assertNoResult(d)

        self.reactor.advance(10)
        acquire_d.callback(None)
        self.log.msg.assert_called_once_with('Lock acquisition in 10.0 seconds',
                                             acquire_time=10.0)
        self.method.assert_called_once_with(2, a=3)

        self.reactor.advance(3)
        release_d.callback(None)
        self.log.msg.assert_called_with('Lock release in 3.0 seconds',
                                        release_time=3.0)
        self.assertEqual(self.log.msg.call_count, 2)

        self.assertEqual(self.successResultOf(d), 'result')