def test_it_creates_delete_action_for_forced_delete_if_externally_mappable(
self, DeleteModelAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(delete=True, force=True), ['field'],
'external_key', {'field': 'value'})
DeleteModelAction.assert_called_with(model_mock, ['field'],
{'field': 'value'})
self.assertIn(DeleteModelAction.return_value, result)
def test_it_builds_an_update_with_external_action_if_externally_mappable(
self, builtAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(update=True), ['field'], 'external_key',
{'field': 'value'})
builtAction.assert_called_with(
external_system_mock, model_mock,
'external_key', ['field'], {'field': 'value'}, False)
self.assertIn(builtAction.return_value, result)
def setUp(self):
self.model = MagicMock()
self.sut = ActionFactory(self.model)
class TestActionFactory(TestCase):
def setUp(self):
self.model = MagicMock()
self.sut = ActionFactory(self.model)
@patch('nsync.actions.ModelAction')
def test_it_creates_a_base_model_action_if_no_action_flags_are_included(
self, ModelAction):
result = self.sut.build(SyncActions(), ['field'], None, {'field': ''})
ModelAction.assert_called_with(self.model, ['field'], {'field': ''})
self.assertIn(ModelAction.return_value, result)
@patch('nsync.actions.CreateModelAction')
def test_it_calls_create_action_with_correct_parameters(self,
TargetActionClass):
result = self.sut.build(SyncActions(create=True), ['field'], ANY,
{'field': ''})
TargetActionClass.assert_called_with(self.model, ['field'],
{'field': ''})
self.assertIn(TargetActionClass.return_value, result)
@patch('nsync.actions.UpdateModelAction')
def test_it_calls_update_action_with_correct_parameters(self,
TargetActionClass):
for actions in [SyncActions(update=True, force=False),
SyncActions(update=True, force=True)]:
result = self.sut.build(actions, ['field'], ANY, {'field': ''})
TargetActionClass.assert_called_with(self.model, ['field'],
{'field': ''}, actions.force)
self.assertIn(TargetActionClass.return_value, result)
@patch('nsync.actions.DeleteModelAction')
def test_it_calls_delete_action_with_correct_parameters(self,
TargetActionClass):
result = self.sut.build(SyncActions(delete=True, force=True), ['field'],
ANY, {'field': ''})
TargetActionClass.assert_called_with(self.model, ['field'],
{'field': ''})
self.assertIn(TargetActionClass.return_value, result)
def test_delete_action_not_built_if_unforced_and_not_externally_mappable(
self):
"""
If there is no external mapping AND the delete is not forced,
then the usual 'DeleteIfOnlyReferenceModelAction' will not actually
do anything anyway, so test that no actions are built.
"""
result = self.sut.build(SyncActions(delete=True), ['field'], ANY,
{'field': ''})
self.assertEqual([], result)
def test_it_creates_two_actions_if_create_and_update_flags_are_included(
self):
result = self.sut.build(SyncActions(create=True, update=True), ['field'],
ANY, {'field': ''})
self.assertEqual(2, len(result))
def test_it_considers_nothing_externally_mappable_without_external_system(
self):
self.assertIs(False, self.sut.is_externally_mappable(''))
self.assertIs(False, self.sut.is_externally_mappable("a mappable key"))
def test_it_considers_non_strings_as_not_externally_mappable(self):
self.assertFalse(ActionFactory(ANY, ANY).is_externally_mappable(None))
self.assertFalse(ActionFactory(ANY, ANY).is_externally_mappable(0))
self.assertFalse(ActionFactory(ANY, ANY).is_externally_mappable(1))
self.assertFalse(ActionFactory(ANY, ANY).is_externally_mappable(ANY))
def test_it_considers_non_blank_strings_as_externally_mappable(self):
self.assertTrue(
ActionFactory(ANY, ANY).is_externally_mappable('a mappable key'))
@patch('nsync.actions.CreateModelWithReferenceAction')
def test_it_builds_a_create_with_external_action_if_externally_mappable(
self, builtAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(create=True), ['field'], 'external_key',
{'field': 'value'})
builtAction.assert_called_with(
external_system_mock, model_mock,
'external_key', ['field'], {'field': 'value'})
self.assertIn(builtAction.return_value, result)
@patch('nsync.actions.UpdateModelWithReferenceAction')
def test_it_builds_an_update_with_external_action_if_externally_mappable(
self, builtAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(update=True), ['field'], 'external_key',
{'field': 'value'})
builtAction.assert_called_with(
external_system_mock, model_mock,
'external_key', ['field'], {'field': 'value'}, False)
self.assertIn(builtAction.return_value, result)
@patch('nsync.actions.DeleteExternalReferenceAction')
def test_it_creates_delete_external_reference_if_externally_mappable(
self, DeleteExternalReferenceAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(delete=True), ['field'], 'external_key',
{'field': 'value'})
DeleteExternalReferenceAction.assert_called_with(
external_system_mock, 'external_key')
self.assertIn(DeleteExternalReferenceAction.return_value, result)
@patch('nsync.actions.DeleteModelAction')
def test_it_creates_delete_action_for_forced_delete_if_externally_mappable(
self, DeleteModelAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(delete=True, force=True), ['field'],
'external_key', {'field': 'value'})
DeleteModelAction.assert_called_with(model_mock, ['field'],
{'field': 'value'})
self.assertIn(DeleteModelAction.return_value, result)
@patch('nsync.actions.DeleteIfOnlyReferenceModelAction')
@patch('nsync.actions.DeleteModelAction')
def test_it_wraps_delete_action_if_externally_mappable(
self, DeleteModelAction, DeleteIfOnlyReferenceModelAction):
external_system_mock = MagicMock()
model_mock = MagicMock()
sut = ActionFactory(model_mock, external_system_mock)
result = sut.build(SyncActions(delete=True), ['field'], 'external_key',
{'field': 'value'})
DeleteModelAction.assert_called_with(model_mock, ['field'],
{'field': 'value'})
DeleteIfOnlyReferenceModelAction.assert_called_with(
external_system_mock,
'external_key',
DeleteModelAction.return_value)
self.assertIn(DeleteIfOnlyReferenceModelAction.return_value, result)
