def test_acquire_retry_not_lock_error(self):
"""If an error occurs that is not lock related, it is propagated."""
lock_uuid = uuid.uuid1()
clock = task.Clock()
lock = BasicLock(self.client,
self.table_name,
lock_uuid,
max_retry=1,
reactor=clock)
responses = [
defer.fail(
NameError('Keep your foot off the blasted samoflange.')),
]
def _new_verify_lock(response):
return responses.pop(0)
lock._verify_lock = _new_verify_lock
def _side_effect(*args, **kwargs):
return defer.succeed([])
self.client.execute.side_effect = _side_effect
d = lock.acquire()
result = self.failureResultOf(d)
self.assertTrue(result.check(NameError))
def test_acquire_retry_never_acquired(self):
"""BasicLock.acquire will retry max_retry times and then give up."""
lock_uuid = uuid.uuid1()
clock = task.Clock()
lock = BasicLock(self.client, self.table_name, lock_uuid, max_retry=1, reactor=clock)
responses = [
defer.fail(BusyLockError('', '')),
defer.fail(BusyLockError('', ''))
]
def _new_verify_lock(response):
return responses.pop(0)
lock._verify_lock = _new_verify_lock
def _side_effect(*args, **kwargs):
return defer.succeed([])
self.client.execute.side_effect = _side_effect
d = lock.acquire()
clock.advance(20)
result = self.failureResultOf(d)
self.assertTrue(result.check(BusyLockError))
self.assertEqual(self.client.execute.call_count, 4)
def test_acquire_retry_never_acquired(self):
"""BasicLock.acquire will retry max_retry times and then give up."""
lock_uuid = uuid.uuid1()
clock = task.Clock()
lock = BasicLock(self.client,
self.table_name,
lock_uuid,
max_retry=1,
reactor=clock)
responses = [
defer.fail(BusyLockError('', '')),
defer.fail(BusyLockError('', ''))
]
def _new_verify_lock(response):
return responses.pop(0)
lock._verify_lock = _new_verify_lock
def _side_effect(*args, **kwargs):
return defer.succeed([])
self.client.execute.side_effect = _side_effect
d = lock.acquire()
clock.advance(20)
result = self.failureResultOf(d)
self.assertTrue(result.check(BusyLockError))
self.assertEqual(self.client.execute.call_count, 4)
def test_acquire_retries_on_NoLockClaimsError(self):
"""
acquire retries when _verify_lock fails with a NoLockClaimsError.
"""
lock_uuid = uuid.uuid1()
clock = task.Clock()
lock = BasicLock(self.client,
self.table_name,
lock_uuid,
max_retry=1,
reactor=clock)
responses = [
defer.fail(NoLockClaimsError('', '')),
defer.succeed(True)
]
def _new_verify_lock(response):
return responses.pop(0)
lock._verify_lock = _new_verify_lock
def _side_effect(*args, **kwargs):
return defer.succeed([])
self.client.execute.side_effect = _side_effect
d = lock.acquire()
clock.advance(20)
self.assertEqual(self.assertFired(d), True)
self.assertEqual(self.client.execute.call_count, 4)
def test_acquire_retries_on_NoLockClaimsError(self):
"""
acquire retries when _verify_lock fails with a NoLockClaimsError.
"""
lock_uuid = uuid.uuid1()
clock = task.Clock()
lock = BasicLock(self.client, self.table_name, lock_uuid, max_retry=1, reactor=clock)
responses = [
defer.fail(NoLockClaimsError('', '')),
defer.succeed(True)
]
def _new_verify_lock(response):
return responses.pop(0)
lock._verify_lock = _new_verify_lock
def _side_effect(*args, **kwargs):
return defer.succeed([])
self.client.execute.side_effect = _side_effect
d = lock.acquire()
clock.advance(20)
self.assertEqual(self.assertFired(d), True)
self.assertEqual(self.client.execute.call_count, 4)
def test__verify_lock(self):
lock_uuid = uuid.uuid1()
lock = BasicLock(self.client, self.table_name, lock_uuid)
d = lock._verify_lock([{'lockId': lock._lock_id, 'claimId': lock._claim_id}])
result = self.assertFired(d)
self.assertEqual(result, True)
def test__verify_lock_no_rows(self):
"""
_verify_lock fails with an error when response contains no rows.
"""
lock_uuid = uuid.uuid1()
lock = BasicLock(self.client, self.table_name, lock_uuid)
d = lock._verify_lock([])
result = self.failureResultOf(d)
self.assertTrue(result.check(NoLockClaimsError))
def test__verify_lock_no_rows(self):
"""
_verify_lock fails with an error when response contains no rows.
"""
lock_uuid = uuid.uuid1()
lock = BasicLock(self.client, self.table_name, lock_uuid)
d = lock._verify_lock([])
result = self.failureResultOf(d)
self.assertTrue(result.check(NoLockClaimsError))
def test__verify_lock(self):
lock_uuid = uuid.uuid1()
lock = BasicLock(self.client, self.table_name, lock_uuid)
d = lock._verify_lock([{
'lockId': lock._lock_id,
'claimId': lock._claim_id
}])
result = self.assertFired(d)
self.assertEqual(result, True)
def test__verify_lock_release(self):
lock_uuid = uuid.uuid1()
def _side_effect(*args, **kwargs):
return defer.succeed(None)
self.client.execute.side_effect = _side_effect
lock = BasicLock(self.client, self.table_name, lock_uuid)
expected = [
'DELETE FROM lock WHERE "lockId"=:lockId AND "claimId"=:claimId;',
{'lockId': lock_uuid, 'claimId': lock._claim_id}, 2]
d = lock._verify_lock([{'lockId': lock._lock_id, 'claimId': ''}])
result = self.failureResultOf(d)
self.assertTrue(result.check(BusyLockError))
self.client.execute.assert_called_once_with(*expected)
def test__verify_lock_release(self):
lock_uuid = uuid.uuid1()
def _side_effect(*args, **kwargs):
return defer.succeed(None)
self.client.execute.side_effect = _side_effect
lock = BasicLock(self.client, self.table_name, lock_uuid)
expected = [
'DELETE FROM lock WHERE "lockId"=:lockId AND "claimId"=:claimId;',
{
'lockId': lock_uuid,
'claimId': lock._claim_id
}, 2
]
d = lock._verify_lock([{'lockId': lock._lock_id, 'claimId': ''}])
result = self.failureResultOf(d)
self.assertTrue(result.check(BusyLockError))
self.client.execute.assert_called_once_with(*expected)
def test_acquire_retry_not_lock_error(self):
"""If an error occurs that is not lock related, it is propagated."""
lock_uuid = uuid.uuid1()
clock = task.Clock()
lock = BasicLock(self.client, self.table_name, lock_uuid, max_retry=1, reactor=clock)
responses = [
defer.fail(NameError('Keep your foot off the blasted samoflange.')),
]
def _new_verify_lock(response):
return responses.pop(0)
lock._verify_lock = _new_verify_lock
def _side_effect(*args, **kwargs):
return defer.succeed([])
self.client.execute.side_effect = _side_effect
d = lock.acquire()
result = self.failureResultOf(d)
self.assertTrue(result.check(NameError))
