def setup_manager(self):
self.store = mock.Mock()
self.store.build_key.side_effect = lambda t, i: '%s%s' % (t, i)
self.buffer = StateSaveBuffer(1)
self.manager = PersistentStateManager(self.store, self.buffer)
class PersistentStateManagerTestCase(TestCase):
@setup
def setup_manager(self):
self.store = mock.Mock()
self.store.build_key.side_effect = lambda t, i: '%s%s' % (t, i)
self.buffer = StateSaveBuffer(1)
self.manager = PersistentStateManager(self.store, self.buffer)
def test__init__(self):
assert_equal(self.manager._impl, self.store)
def test_keys_for_items(self):
names = ['namea', 'nameb']
key_to_item_map = self.manager._keys_for_items('type', names)
keys = ['type%s' % name for name in names]
assert_equal(key_to_item_map, dict(zip(keys, names)))
def test_restore_dicts(self):
names = ['namea', 'nameb']
autospec_method(self.manager._keys_for_items)
self.manager._keys_for_items.return_value = dict(enumerate(names))
self.store.restore.return_value = {
0: {
'state': 'data'
},
1: {
'state': '2data'
},
}
state_data = self.manager._restore_dicts('type', names)
expected = {
names[0]: {
'state': 'data'
},
names[1]: {
'state': '2data'
},
}
assert_equal(expected, state_data)
def test_save(self):
name, state_data = 'name', mock.Mock()
self.manager.save(runstate.JOB_STATE, name, state_data)
key = '%s%s' % (runstate.JOB_STATE, name)
self.store.save.assert_called_with([(key, state_data)])
def test_save_failed(self):
self.store.save.side_effect = PersistenceStoreError("blah")
assert_raises(
PersistenceStoreError,
self.manager.save,
None,
None,
None,
)
def test_save_while_disabled(self):
with self.manager.disabled():
self.manager.save("something", 'name', mock.Mock())
assert not self.store.save.mock_calls
def test_cleanup(self):
self.manager.cleanup()
self.store.cleanup.assert_called_with()
def test_disabled(self):
with self.manager.disabled():
assert not self.manager.enabled
assert self.manager.enabled
def test_disabled_with_exception(self):
def testfunc():
with self.manager.disabled():
raise ValueError()
assert_raises(ValueError, testfunc)
assert self.manager.enabled
def test_disabled_nested(self):
self.manager.enabled = False
with self.manager.disabled():
pass
assert not self.manager.enabled
def setup_manager(self):
self.store = mock.Mock()
self.store.build_key.side_effect = lambda t, i: '%s%s' % (t, i)
self.buffer = StateSaveBuffer(1)
self.manager = PersistentStateManager(self.store, self.buffer)
class TestPersistentStateManager(TestCase):
@setup
def setup_manager(self):
self.store = mock.Mock()
self.store.build_key.side_effect = lambda t, i: '%s%s' % (t, i)
self.buffer = StateSaveBuffer(1)
self.manager = PersistentStateManager(self.store, self.buffer)
def test__init__(self):
assert_equal(self.manager._impl, self.store)
def test_keys_for_items(self):
names = ['namea', 'nameb']
key_to_item_map = self.manager._keys_for_items('type', names)
keys = ['type%s' % name for name in names]
assert_equal(key_to_item_map, dict(zip(keys, names)))
def test_restore_dicts(self):
names = ['namea', 'nameb']
autospec_method(self.manager._keys_for_items)
self.manager._keys_for_items.return_value = dict(enumerate(names))
self.store.restore.return_value = {
0: {
'state': 'data',
},
1: {
'state': '2data',
},
}
state_data = self.manager._restore_dicts('type', names)
expected = {
names[0]: {
'state': 'data',
},
names[1]: {
'state': '2data',
},
}
assert_equal(expected, state_data)
def test_save(self):
name, state_data = 'name', mock.Mock()
self.manager.save(runstate.JOB_STATE, name, state_data)
key = '%s%s' % (runstate.JOB_STATE, name)
self.store.save.assert_called_with([(key, state_data)])
def test_save_failed(self):
self.store.save.side_effect = PersistenceStoreError("blah")
assert_raises(
PersistenceStoreError,
self.manager.save,
None,
None,
None,
)
def test_save_while_disabled(self):
with self.manager.disabled():
self.manager.save("something", 'name', mock.Mock())
assert not self.store.save.mock_calls
def test_check_consistency(self):
state_data = mock.Mock()
state = {runstate.JOB_STATE: {'name': state_data}}
key = f"{runstate.JOB_STATE}name"
self.manager._check_consistency(state)
assert self.store.save.call_count == 1
assert self.store.save.call_args == mock.call([(key, state_data)])
def test_check_consistency_failed(self):
state = {runstate.JOB_STATE: {'name': mock.Mock()}}
with mock.patch.object(
self.store,
'save',
side_effect=PersistenceStoreError,
autospec=None,
):
assert_raises(
PersistenceStoreError,
self.manager._check_consistency,
state
)
def test_cleanup(self):
self.manager.cleanup()
self.store.cleanup.assert_called_with()
def test_disabled(self):
with self.manager.disabled():
assert not self.manager.enabled
assert self.manager.enabled
def test_disabled_with_exception(self):
def testfunc():
with self.manager.disabled():
raise ValueError()
assert_raises(ValueError, testfunc)
assert self.manager.enabled
def test_disabled_nested(self):
self.manager.enabled = False
with self.manager.disabled():
pass
assert not self.manager.enabled
def setup_manager(self):
self.store = Turtle(build_key=lambda t, i: '%s%s' % (t, i))
self.buffer = StateSaveBuffer(1)
self.manager = PersistentStateManager(self.store, self.buffer)
class PersistentStateManagerTestCase(TestCase):
@setup
def setup_manager(self):
self.store = Turtle(build_key=lambda t, i: '%s%s' % (t, i))
self.buffer = StateSaveBuffer(1)
self.manager = PersistentStateManager(self.store, self.buffer)
def test__init__(self):
assert_equal(self.manager._impl, self.store)
def test_keys_for_items(self):
items = [Turtle(), Turtle()]
key_to_item_map = self.manager._keys_for_items('type', items)
# Skip first return, its from the constructor
keys = ['type%s' % item.name for item in items]
assert_equal(key_to_item_map, dict(zip(keys, items)))
def test_restore_dicts(self):
items = [Turtle(), Turtle()]
self.manager._keys_for_items = lambda t, i: {'1': items[0], '2': items[1]}
self.store.restore = lambda keys: {
'1': {'state': 'data'}, '2': {'state': '2data'}
}
state_data = self.manager._restore_dicts('type', items)
expected = {
items[0].name: {'state': 'data'},
items[1].name: {'state': '2data'}
}
assert_equal(expected, state_data)
def test_save_job(self):
job = Turtle()
self.manager.save_job(job)
key = '%s%s' % (runstate.JOB_STATE, job.name)
assert_call(self.store.save, 0, [(key, job.state_data)])
def test_save_service(self):
service = Turtle()
self.manager.save_service(service)
key = '%s%s' % (runstate.SERVICE_STATE, service.name)
assert_call(self.store.save, 0, [(key, service.state_data)])
def test_save_metadata(self):
self.manager.save_metadata()
key, state_data = self.store.save.calls[0][0][0][0]
assert_equal(key, '%s%s' % (runstate.MCP_STATE, StateMetadata.name))
assert_equal(state_data['version'], tron.__version_info__)
def test_save_failed(self):
def err(_ks):
raise PersistenceStoreError("blah")
self.store.save = err
assert_raises(PersistenceStoreError, self.manager._save, None, Turtle())
def test_save_while_disabled(self):
with self.manager.disabled():
self.manager._save("something", StateMetadata())
assert_length(self.store.save.calls, 0)
def test_cleanup(self):
self.manager.cleanup()
assert_call(self.store.cleanup, 0)
def test_disabled(self):
with self.manager.disabled():
assert not self.manager.enabled
assert self.manager.enabled
def test_disabled_with_exception(self):
def testfunc():
with self.manager.disabled():
raise ValueError()
assert_raises(ValueError, testfunc)
assert self.manager.enabled
def test_disabled_nested(self):
self.manager.enabled = False
with self.manager.disabled():
pass
assert not self.manager.enabled
