diff --git a/watcher/db/sqlalchemy/api.py b/watcher/db/sqlalchemy/api.py index 4807ae1ab..48f7ff9c2 100644 --- a/watcher/db/sqlalchemy/api.py +++ b/watcher/db/sqlalchemy/api.py @@ -291,11 +291,13 @@ class Connection(api.BaseConnection): query = model_query(model, session=session) query = add_identity_filter(query, id_) try: - query.one() + row = query.one() except exc.NoResultFound: raise exception.ResourceNotFound(name=model.__name__, id=id_) - query.soft_delete() + row.soft_delete(session) + + return row @staticmethod def _destroy(model, id_): @@ -484,7 +486,7 @@ class Connection(api.BaseConnection): def soft_delete_goal(self, goal_id): try: - self._soft_delete(models.Goal, goal_id) + return self._soft_delete(models.Goal, goal_id) except exception.ResourceNotFound: raise exception.GoalNotFound(goal=goal_id) @@ -550,7 +552,7 @@ class Connection(api.BaseConnection): def soft_delete_strategy(self, strategy_id): try: - self._soft_delete(models.Strategy, strategy_id) + return self._soft_delete(models.Strategy, strategy_id) except exception.ResourceNotFound: raise exception.StrategyNotFound(strategy=strategy_id) @@ -632,7 +634,7 @@ class Connection(api.BaseConnection): def soft_delete_audit_template(self, audit_template_id): try: - self._soft_delete(models.AuditTemplate, audit_template_id) + return self._soft_delete(models.AuditTemplate, audit_template_id) except exception.ResourceNotFound: raise exception.AuditTemplateNotFound( audit_template=audit_template_id) @@ -717,7 +719,7 @@ class Connection(api.BaseConnection): def soft_delete_audit(self, audit_id): try: - self._soft_delete(models.Audit, audit_id) + return self._soft_delete(models.Audit, audit_id) except exception.ResourceNotFound: raise exception.AuditNotFound(audit=audit_id) @@ -793,17 +795,10 @@ class Connection(api.BaseConnection): return ref def soft_delete_action(self, action_id): - session = get_session() - with session.begin(): - query = model_query(models.Action, session=session) - query = add_identity_filter(query, action_id) - - try: - query.one() - except exc.NoResultFound: - raise exception.ActionNotFound(action=action_id) - - query.soft_delete() + try: + return self._soft_delete(models.Action, action_id) + except exception.ResourceNotFound: + raise exception.ActionNotFound(action=action_id) # ### ACTION PLANS ### # @@ -895,17 +890,10 @@ class Connection(api.BaseConnection): return ref def soft_delete_action_plan(self, action_plan_id): - session = get_session() - with session.begin(): - query = model_query(models.ActionPlan, session=session) - query = add_identity_filter(query, action_plan_id) - - try: - query.one() - except exc.NoResultFound: - raise exception.ActionPlanNotFound(action_plan=action_plan_id) - - query.soft_delete() + try: + return self._soft_delete(models.ActionPlan, action_plan_id) + except exception.ResourceNotFound: + raise exception.ActionPlanNotFound(action_plan=action_plan_id) # ### EFFICACY INDICATORS ### # @@ -973,7 +961,8 @@ class Connection(api.BaseConnection): def soft_delete_efficacy_indicator(self, efficacy_indicator_id): try: - self._soft_delete(models.EfficacyIndicator, efficacy_indicator_id) + return self._soft_delete( + models.EfficacyIndicator, efficacy_indicator_id) except exception.ResourceNotFound: raise exception.EfficacyIndicatorNotFound( efficacy_indicator=efficacy_indicator_id) @@ -1066,7 +1055,8 @@ class Connection(api.BaseConnection): def soft_delete_scoring_engine(self, scoring_engine_id): try: - return self._soft_delete(models.ScoringEngine, scoring_engine_id) + return self._soft_delete( + models.ScoringEngine, scoring_engine_id) except exception.ResourceNotFound: raise exception.ScoringEngineNotFound( scoring_engine=scoring_engine_id) @@ -1131,6 +1121,6 @@ class Connection(api.BaseConnection): def soft_delete_service(self, service_id): try: - self._soft_delete(models.Service, service_id) + return self._soft_delete(models.Service, service_id) except exception.ResourceNotFound: raise exception.ServiceNotFound(service=service_id) diff --git a/watcher/objects/action.py b/watcher/objects/action.py index d922d56d1..44c008755 100644 --- a/watcher/objects/action.py +++ b/watcher/objects/action.py @@ -146,8 +146,9 @@ class Action(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_action(self.uuid, updates) - + db_obj = self.dbapi.update_action(self.uuid, updates) + obj = self._from_db_object(self, db_obj, eager=False) + self.obj_refresh(obj) self.obj_reset_changes() @base.remotable @@ -165,6 +166,9 @@ class Action(base.WatcherPersistentObject, base.WatcherObject, @base.remotable def soft_delete(self): """Soft Delete the Audit from the DB""" - self.dbapi.soft_delete_action(self.uuid) self.state = State.DELETED self.save() + db_obj = self.dbapi.soft_delete_action(self.uuid) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) diff --git a/watcher/objects/action_plan.py b/watcher/objects/action_plan.py index 32ab254ae..c2c803dae 100644 --- a/watcher/objects/action_plan.py +++ b/watcher/objects/action_plan.py @@ -218,8 +218,9 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_action_plan(self.uuid, updates) - + db_obj = self.dbapi.update_action_plan(self.uuid, updates) + obj = self._from_db_object(self, db_obj, eager=False) + self.obj_refresh(obj) self.obj_reset_changes() @base.remotable @@ -253,6 +254,9 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject, for related_efficacy_indicator in related_efficacy_indicators: related_efficacy_indicator.soft_delete() - self.dbapi.soft_delete_action_plan(self.uuid) self.state = State.DELETED self.save() + db_obj = self.dbapi.soft_delete_action_plan(self.uuid) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) diff --git a/watcher/objects/audit.py b/watcher/objects/audit.py index 7a73f5f92..a5bd15216 100644 --- a/watcher/objects/audit.py +++ b/watcher/objects/audit.py @@ -255,7 +255,10 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_audit(self.uuid, updates) + db_obj = self.dbapi.update_audit(self.uuid, updates) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) def _notify(): notifications.audit.send_update( @@ -280,9 +283,12 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject, @base.remotable def soft_delete(self): """Soft Delete the Audit from the DB.""" - self.dbapi.soft_delete_audit(self.uuid) self.state = State.DELETED self.save() + db_obj = self.dbapi.soft_delete_audit(self.uuid) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) def _notify(): notifications.audit.send_delete(self._context, self) diff --git a/watcher/objects/audit_template.py b/watcher/objects/audit_template.py index edb753104..11a0c2d25 100644 --- a/watcher/objects/audit_template.py +++ b/watcher/objects/audit_template.py @@ -215,8 +215,9 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_audit_template(self.uuid, updates) - + db_obj = self.dbapi.update_audit_template(self.uuid, updates) + obj = self._from_db_object(self, db_obj, eager=False) + self.obj_refresh(obj) self.obj_reset_changes() @base.remotable @@ -234,4 +235,7 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject, @base.remotable def soft_delete(self): """Soft Delete the :class:`AuditTemplate` from the DB""" - self.dbapi.soft_delete_audit_template(self.uuid) + db_obj = self.dbapi.soft_delete_audit_template(self.uuid) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) diff --git a/watcher/objects/base.py b/watcher/objects/base.py index eac07bb1c..fc74d26cc 100644 --- a/watcher/objects/base.py +++ b/watcher/objects/base.py @@ -123,7 +123,9 @@ class WatcherPersistentObject(object): the loaded object column by column in comparison with the current object. """ - for field in self.fields: + fields = (field for field in self.fields + if field not in self.object_fields) + for field in fields: if (self.obj_attr_is_set(field) and self[field] != loaded_object[field]): self[field] = loaded_object[field] diff --git a/watcher/objects/goal.py b/watcher/objects/goal.py index b089ab281..e947ff635 100644 --- a/watcher/objects/goal.py +++ b/watcher/objects/goal.py @@ -151,8 +151,9 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_goal(self.id, updates) - + db_obj = self.dbapi.update_goal(self.uuid, updates) + obj = self._from_db_object(self, db_obj, eager=False) + self.obj_refresh(obj) self.obj_reset_changes() @base.remotable @@ -169,4 +170,7 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject, @base.remotable def soft_delete(self): """Soft Delete the :class:`Goal` from the DB""" - self.dbapi.soft_delete_goal(self.uuid) + db_obj = self.dbapi.soft_delete_goal(self.uuid) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) diff --git a/watcher/objects/scoring_engine.py b/watcher/objects/scoring_engine.py index dbf0484aa..0c95e724b 100644 --- a/watcher/objects/scoring_engine.py +++ b/watcher/objects/scoring_engine.py @@ -175,8 +175,9 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_scoring_engine(self.id, updates) - + db_obj = self.dbapi.update_scoring_engine(self.uuid, updates) + obj = self._from_db_object(self, db_obj, eager=False) + self.obj_refresh(obj) self.obj_reset_changes() def refresh(self): @@ -191,4 +192,7 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject, def soft_delete(self): """Soft Delete the :class:`ScoringEngine` from the DB""" - self.dbapi.soft_delete_scoring_engine(self.id) + db_obj = self.dbapi.soft_delete_scoring_engine(self.id) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) diff --git a/watcher/objects/service.py b/watcher/objects/service.py index c215a114f..0b261b85e 100644 --- a/watcher/objects/service.py +++ b/watcher/objects/service.py @@ -119,8 +119,9 @@ class Service(base.WatcherPersistentObject, base.WatcherObject, of self.what_changed(). """ updates = self.obj_get_changes() - self.dbapi.update_service(self.id, updates) - + db_obj = self.dbapi.update_service(self.id, updates) + obj = self._from_db_object(self, db_obj, eager=False) + self.obj_refresh(obj) self.obj_reset_changes() def refresh(self): @@ -138,4 +139,7 @@ class Service(base.WatcherPersistentObject, base.WatcherObject, def soft_delete(self): """Soft Delete the :class:`Service` from the DB.""" - self.dbapi.soft_delete_service(self.id) + db_obj = self.dbapi.soft_delete_service(self.id) + obj = self._from_db_object( + self.__class__(self._context), db_obj, eager=False) + self.obj_refresh(obj) diff --git a/watcher/tests/objects/test_action.py b/watcher/tests/objects/test_action.py index 1b3157e67..a580c8d34 100644 --- a/watcher/tests/objects/test_action.py +++ b/watcher/tests/objects/test_action.py @@ -13,6 +13,9 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock from watcher.common import exception @@ -100,17 +103,24 @@ class TestActionObject(base.DbTestCase): @mock.patch.object(db_api.Connection, 'get_action_by_uuid') def test_save(self, mock_get_action, mock_update_action): mock_get_action.return_value = self.fake_action + fake_saved_action = self.fake_action.copy() + fake_saved_action['updated_at'] = datetime.datetime.utcnow() + mock_update_action.return_value = fake_saved_action uuid = self.fake_action['uuid'] action = objects.Action.get_by_uuid( self.context, uuid, eager=self.eager) action.state = objects.action.State.SUCCEEDED action.save() + expected_update_at = fake_saved_action['updated_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + mock_get_action.assert_called_once_with( self.context, uuid, eager=self.eager) mock_update_action.assert_called_once_with( uuid, {'state': objects.action.State.SUCCEEDED}) self.assertEqual(self.context, action._context) + self.assertEqual(expected_update_at, action.updated_at) @mock.patch.object(db_api.Connection, 'get_action_by_uuid') def test_refresh(self, mock_get_action): @@ -136,15 +146,18 @@ class TestCreateDeleteActionObject(base.DbTestCase): self.fake_strategy = utils.create_test_strategy(name="DUMMY") self.fake_audit = utils.create_test_audit() self.fake_action_plan = utils.create_test_action_plan() - self.fake_action = utils.get_test_action() + self.fake_action = utils.get_test_action( + created_at=datetime.datetime.utcnow()) @mock.patch.object(db_api.Connection, 'create_action') def test_create(self, mock_create_action): mock_create_action.return_value = self.fake_action action = objects.Action(self.context, **self.fake_action) action.create() - - mock_create_action.assert_called_once_with(self.fake_action) + expected_action = self.fake_action.copy() + expected_action['created_at'] = expected_action['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + mock_create_action.assert_called_once_with(expected_action) self.assertEqual(self.context, action._context) @mock.patch.object(db_api.Connection, 'update_action') @@ -153,6 +166,18 @@ class TestCreateDeleteActionObject(base.DbTestCase): def test_soft_delete(self, mock_get_action, mock_soft_delete_action, mock_update_action): mock_get_action.return_value = self.fake_action + fake_deleted_action = self.fake_action.copy() + fake_deleted_action['deleted_at'] = datetime.datetime.utcnow() + mock_soft_delete_action.return_value = fake_deleted_action + mock_update_action.return_value = fake_deleted_action + + expected_action = fake_deleted_action.copy() + expected_action['created_at'] = expected_action['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + expected_action['deleted_at'] = expected_action['deleted_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + del expected_action['action_plan'] + uuid = self.fake_action['uuid'] action = objects.Action.get_by_uuid(self.context, uuid) action.soft_delete() @@ -162,6 +187,7 @@ class TestCreateDeleteActionObject(base.DbTestCase): mock_update_action.assert_called_once_with( uuid, {'state': objects.action.State.DELETED}) self.assertEqual(self.context, action._context) + self.assertEqual(expected_action, action.as_dict()) @mock.patch.object(db_api.Connection, 'destroy_action') @mock.patch.object(db_api.Connection, 'get_action_by_uuid') diff --git a/watcher/tests/objects/test_action_plan.py b/watcher/tests/objects/test_action_plan.py index f1916c733..d6b26494d 100644 --- a/watcher/tests/objects/test_action_plan.py +++ b/watcher/tests/objects/test_action_plan.py @@ -13,6 +13,9 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock from watcher.common import exception @@ -109,6 +112,9 @@ class TestActionPlanObject(base.DbTestCase): @mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid') def test_save(self, mock_get_action_plan, mock_update_action_plan): mock_get_action_plan.return_value = self.fake_action_plan + fake_saved_action_plan = self.fake_action_plan.copy() + fake_saved_action_plan['deleted_at'] = datetime.datetime.utcnow() + mock_update_action_plan.return_value = fake_saved_action_plan uuid = self.fake_action_plan['uuid'] action_plan = objects.ActionPlan.get_by_uuid( self.context, uuid, eager=self.eager) @@ -146,7 +152,8 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase): super(TestCreateDeleteActionPlanObject, self).setUp() self.fake_strategy = utils.create_test_strategy(name="DUMMY") self.fake_audit = utils.create_test_audit() - self.fake_action_plan = utils.get_test_action_plan() + self.fake_action_plan = utils.get_test_action_plan( + created_at=datetime.datetime.utcnow()) @mock.patch.object(db_api.Connection, 'create_action_plan') def test_create(self, mock_create_action_plan): @@ -154,8 +161,10 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase): action_plan = objects.ActionPlan( self.context, **self.fake_action_plan) action_plan.create() - mock_create_action_plan.assert_called_once_with( - self.fake_action_plan) + expected_action_plan = self.fake_action_plan.copy() + expected_action_plan['created_at'] = expected_action_plan[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) + mock_create_action_plan.assert_called_once_with(expected_action_plan) self.assertEqual(self.context, action_plan._context) @mock.patch.multiple( @@ -178,7 +187,20 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase): m_get_efficacy_indicator_list = get_efficacy_indicator_list m_soft_delete_efficacy_indicator = soft_delete_efficacy_indicator m_update_action_plan = update_action_plan + m_get_action_plan.return_value = self.fake_action_plan + fake_deleted_action_plan = self.fake_action_plan.copy() + fake_deleted_action_plan['deleted_at'] = datetime.datetime.utcnow() + m_update_action_plan.return_value = fake_deleted_action_plan + m_soft_delete_action_plan.return_value = fake_deleted_action_plan + expected_action_plan = fake_deleted_action_plan.copy() + expected_action_plan['created_at'] = expected_action_plan[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) + expected_action_plan['deleted_at'] = expected_action_plan[ + 'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc()) + del expected_action_plan['audit'] + del expected_action_plan['strategy'] + m_get_efficacy_indicator_list.return_value = [efficacy_indicator] action_plan = objects.ActionPlan.get_by_uuid(self.context, uuid) action_plan.soft_delete() @@ -193,7 +215,9 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase): efficacy_indicator['uuid']) m_update_action_plan.assert_called_once_with( uuid, {'state': objects.action_plan.State.DELETED}) + self.assertEqual(self.context, action_plan._context) + self.assertEqual(expected_action_plan, action_plan.as_dict()) @mock.patch.multiple( db_api.Connection, diff --git a/watcher/tests/objects/test_audit.py b/watcher/tests/objects/test_audit.py index 2cfc75b5c..179969978 100644 --- a/watcher/tests/objects/test_audit.py +++ b/watcher/tests/objects/test_audit.py @@ -13,6 +13,9 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock from watcher.common import exception @@ -37,14 +40,18 @@ class TestAuditObject(base.DbTestCase): ('non_eager', dict( eager=False, fake_audit=utils.get_test_audit( + created_at=datetime.datetime.utcnow(), goal_id=goal_id))), ('eager_with_non_eager_load', dict( eager=True, fake_audit=utils.get_test_audit( + created_at=datetime.datetime.utcnow(), goal_id=goal_id))), ('eager_with_eager_load', dict( eager=True, - fake_audit=utils.get_test_audit(goal_id=goal_id, goal=goal_data))), + fake_audit=utils.get_test_audit( + created_at=datetime.datetime.utcnow(), + goal_id=goal_id, goal=goal_data))), ] def setUp(self): @@ -116,6 +123,17 @@ class TestAuditObject(base.DbTestCase): @mock.patch.object(db_api.Connection, 'get_audit_by_uuid') def test_save(self, mock_get_audit, mock_update_audit): mock_get_audit.return_value = self.fake_audit + fake_saved_audit = self.fake_audit.copy() + fake_saved_audit['state'] = objects.audit.State.SUCCEEDED + fake_saved_audit['updated_at'] = datetime.datetime.utcnow() + mock_update_audit.return_value = fake_saved_audit + + expected_audit = fake_saved_audit.copy() + expected_audit['created_at'] = expected_audit['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + expected_audit['updated_at'] = expected_audit['updated_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + uuid = self.fake_audit['uuid'] audit = objects.Audit.get_by_uuid(self.context, uuid, eager=self.eager) audit.state = objects.audit.State.SUCCEEDED @@ -129,6 +147,11 @@ class TestAuditObject(base.DbTestCase): self.eager_load_audit_assert(audit, self.fake_goal) self.m_send_update.assert_called_once_with( self.context, audit, old_state=self.fake_audit['state']) + self.assertEqual( + {k: v for k, v in expected_audit.items() + if k not in audit.object_fields}, + {k: v for k, v in audit.as_dict().items() + if k not in audit.object_fields}) @mock.patch.object(db_api.Connection, 'get_audit_by_uuid') def test_refresh(self, mock_get_audit): @@ -160,14 +183,18 @@ class TestCreateDeleteAuditObject(base.DbTestCase): self.goal_id = 1 self.goal = utils.create_test_goal(id=self.goal_id, name="DUMMY") - self.fake_audit = utils.get_test_audit(goal_id=self.goal_id) + self.fake_audit = utils.get_test_audit( + goal_id=self.goal_id, created_at=datetime.datetime.utcnow()) @mock.patch.object(db_api.Connection, 'create_audit') def test_create(self, mock_create_audit): mock_create_audit.return_value = self.fake_audit audit = objects.Audit(self.context, **self.fake_audit) audit.create() - mock_create_audit.assert_called_once_with(self.fake_audit) + expected_audit = self.fake_audit.copy() + expected_audit['created_at'] = expected_audit['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + mock_create_audit.assert_called_once_with(expected_audit) self.assertEqual(self.context, audit._context) @mock.patch.object(db_api.Connection, 'update_audit') @@ -176,13 +203,27 @@ class TestCreateDeleteAuditObject(base.DbTestCase): def test_soft_delete(self, mock_get_audit, mock_soft_delete_audit, mock_update_audit): mock_get_audit.return_value = self.fake_audit + fake_deleted_audit = self.fake_audit.copy() + fake_deleted_audit['deleted_at'] = datetime.datetime.utcnow() + mock_soft_delete_audit.return_value = fake_deleted_audit + mock_update_audit.return_value = fake_deleted_audit + + expected_audit = fake_deleted_audit.copy() + expected_audit['created_at'] = expected_audit['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + expected_audit['deleted_at'] = expected_audit['deleted_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + del expected_audit['goal'] + del expected_audit['strategy'] + uuid = self.fake_audit['uuid'] - audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True) + audit = objects.Audit.get_by_uuid(self.context, uuid, eager=False) audit.soft_delete() - mock_get_audit.assert_called_once_with(self.context, uuid, eager=True) + mock_get_audit.assert_called_once_with(self.context, uuid, eager=False) mock_soft_delete_audit.assert_called_once_with(uuid) mock_update_audit.assert_called_once_with(uuid, {'state': 'DELETED'}) self.assertEqual(self.context, audit._context) + self.assertEqual(expected_audit, audit.as_dict()) @mock.patch.object(db_api.Connection, 'destroy_audit') @mock.patch.object(db_api.Connection, 'get_audit_by_uuid') @@ -216,14 +257,17 @@ class TestAuditObjectSendNotifications(base.DbTestCase): self.m_notifier = self.m_get_notifier.return_value self.addCleanup(p_get_notifier.stop) - @mock.patch.object(db_api.Connection, 'update_audit', mock.Mock()) + @mock.patch.object(db_api.Connection, 'update_audit') @mock.patch.object(db_api.Connection, 'get_audit_by_uuid') - def test_send_update_notification(self, m_get_audit): + def test_send_update_notification(self, m_get_audit, m_update_audit): fake_audit = utils.get_test_audit( goal=self.fake_goal.as_dict(), strategy_id=self.fake_strategy.id, strategy=self.fake_strategy.as_dict()) m_get_audit.return_value = fake_audit + fake_saved_audit = self.fake_audit.copy() + fake_saved_audit['state'] = objects.audit.State.SUCCEEDED + m_update_audit.return_value = fake_saved_audit uuid = fake_audit['uuid'] audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True) @@ -249,17 +293,25 @@ class TestAuditObjectSendNotifications(base.DbTestCase): self.assertEqual('audit.create', self.m_notifier.info.call_args[1]['event_type']) - @mock.patch.object(db_api.Connection, 'soft_delete_audit', mock.Mock()) - @mock.patch.object(db_api.Connection, 'update_audit', mock.Mock()) + @mock.patch.object(db_api.Connection, 'update_audit') + @mock.patch.object(db_api.Connection, 'soft_delete_audit') @mock.patch.object(db_api.Connection, 'get_audit_by_uuid') - def test_send_delete_notification(self, m_get_audit): + def test_send_delete_notification( + self, m_get_audit, m_soft_delete_audit, m_update_audit): fake_audit = utils.get_test_audit( goal=self.fake_goal.as_dict(), strategy_id=self.fake_strategy.id, strategy=self.fake_strategy.as_dict()) m_get_audit.return_value = fake_audit - uuid = fake_audit['uuid'] + fake_deleted_audit = self.fake_audit.copy() + fake_deleted_audit['deleted_at'] = datetime.datetime.utcnow() + expected_audit = fake_deleted_audit.copy() + expected_audit['deleted_at'] = expected_audit['deleted_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + m_soft_delete_audit.return_value = fake_deleted_audit + m_update_audit.return_value = fake_deleted_audit + uuid = fake_audit['uuid'] audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True) audit.soft_delete() diff --git a/watcher/tests/objects/test_audit_template.py b/watcher/tests/objects/test_audit_template.py index 8f353db70..14da9f026 100644 --- a/watcher/tests/objects/test_audit_template.py +++ b/watcher/tests/objects/test_audit_template.py @@ -13,6 +13,9 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock from watcher.common import exception @@ -34,14 +37,17 @@ class TestAuditTemplateObject(base.DbTestCase): ('non_eager', dict( eager=False, fake_audit_template=utils.get_test_audit_template( + created_at=datetime.datetime.utcnow(), goal_id=goal_id))), ('eager_with_non_eager_load', dict( eager=True, fake_audit_template=utils.get_test_audit_template( + created_at=datetime.datetime.utcnow(), goal_id=goal_id))), ('eager_with_eager_load', dict( eager=True, fake_audit_template=utils.get_test_audit_template( + created_at=datetime.datetime.utcnow(), goal_id=goal_id, goal=goal_data))), ] @@ -120,6 +126,9 @@ class TestAuditTemplateObject(base.DbTestCase): @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid') def test_save(self, mock_get_audit_template, mock_update_audit_template): mock_get_audit_template.return_value = self.fake_audit_template + fake_saved_audit_template = self.fake_audit_template.copy() + fake_saved_audit_template['updated_at'] = datetime.datetime.utcnow() + mock_update_audit_template.return_value = fake_saved_audit_template uuid = self.fake_audit_template['uuid'] audit_template = objects.AuditTemplate.get_by_uuid( self.context, uuid, eager=self.eager) @@ -155,7 +164,8 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase): def setUp(self): super(TestCreateDeleteAuditTemplateObject, self).setUp() - self.fake_audit_template = utils.get_test_audit_template() + self.fake_audit_template = utils.get_test_audit_template( + created_at=datetime.datetime.utcnow()) @mock.patch.object(db_api.Connection, 'create_audit_template') def test_create(self, mock_create_audit_template): @@ -165,22 +175,38 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase): audit_template = objects.AuditTemplate( self.context, **self.fake_audit_template) audit_template.create() + expected_audit_template = self.fake_audit_template.copy() + expected_audit_template['created_at'] = expected_audit_template[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) mock_create_audit_template.assert_called_once_with( - self.fake_audit_template) + expected_audit_template) self.assertEqual(self.context, audit_template._context) @mock.patch.object(db_api.Connection, 'soft_delete_audit_template') @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid') - def test_soft_delete(self, mock_get_audit_template, - mock_soft_delete_audit_template): - mock_get_audit_template.return_value = self.fake_audit_template + def test_soft_delete(self, m_get_audit_template, + m_soft_delete_audit_template): + m_get_audit_template.return_value = self.fake_audit_template + fake_deleted_audit_template = self.fake_audit_template.copy() + fake_deleted_audit_template['deleted_at'] = datetime.datetime.utcnow() + m_soft_delete_audit_template.return_value = fake_deleted_audit_template + + expected_audit_template = fake_deleted_audit_template.copy() + expected_audit_template['created_at'] = expected_audit_template[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) + expected_audit_template['deleted_at'] = expected_audit_template[ + 'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc()) + del expected_audit_template['goal'] + del expected_audit_template['strategy'] + uuid = self.fake_audit_template['uuid'] audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid) audit_template.soft_delete() - mock_get_audit_template.assert_called_once_with( + m_get_audit_template.assert_called_once_with( self.context, uuid, eager=False) - mock_soft_delete_audit_template.assert_called_once_with(uuid) + m_soft_delete_audit_template.assert_called_once_with(uuid) self.assertEqual(self.context, audit_template._context) + self.assertEqual(expected_audit_template, audit_template.as_dict()) @mock.patch.object(db_api.Connection, 'destroy_audit_template') @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid') diff --git a/watcher/tests/objects/test_goal.py b/watcher/tests/objects/test_goal.py index 01334871c..26c69515c 100644 --- a/watcher/tests/objects/test_goal.py +++ b/watcher/tests/objects/test_goal.py @@ -13,8 +13,12 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock +from watcher.db.sqlalchemy import api as db_api from watcher import objects from watcher.tests.db import base from watcher.tests.db import utils @@ -24,115 +28,116 @@ class TestGoalObject(base.DbTestCase): def setUp(self): super(TestGoalObject, self).setUp() - self.fake_goal = utils.get_test_goal() + self.fake_goal = utils.get_test_goal( + created_at=datetime.datetime.utcnow()) - def test_get_by_id(self): + @mock.patch.object(db_api.Connection, 'get_goal_by_id') + def test_get_by_id(self, mock_get_goal): goal_id = self.fake_goal['id'] - with mock.patch.object(self.dbapi, 'get_goal_by_id', - autospec=True) as mock_get_goal: - mock_get_goal.return_value = self.fake_goal - goal = objects.Goal.get(self.context, goal_id) - mock_get_goal.assert_called_once_with(self.context, goal_id) - self.assertEqual(self.context, goal._context) + mock_get_goal.return_value = self.fake_goal + goal = objects.Goal.get(self.context, goal_id) + mock_get_goal.assert_called_once_with(self.context, goal_id) + self.assertEqual(self.context, goal._context) - def test_get_by_uuid(self): + @mock.patch.object(db_api.Connection, 'get_goal_by_uuid') + def test_get_by_uuid(self, mock_get_goal): uuid = self.fake_goal['uuid'] - with mock.patch.object(self.dbapi, 'get_goal_by_uuid', - autospec=True) as mock_get_goal: - mock_get_goal.return_value = self.fake_goal - goal = objects.Goal.get(self.context, uuid) - mock_get_goal.assert_called_once_with(self.context, uuid) - self.assertEqual(self.context, goal._context) + mock_get_goal.return_value = self.fake_goal + goal = objects.Goal.get(self.context, uuid) + mock_get_goal.assert_called_once_with(self.context, uuid) + self.assertEqual(self.context, goal._context) - def test_get_by_name(self): + @mock.patch.object(db_api.Connection, 'get_goal_by_name') + def test_get_by_name(self, mock_get_goal): name = self.fake_goal['name'] - with mock.patch.object(self.dbapi, 'get_goal_by_name', - autospec=True) as mock_get_goal: - mock_get_goal.return_value = self.fake_goal - goal = objects.Goal.get_by_name( - self.context, - name) - mock_get_goal.assert_called_once_with(self.context, name) - self.assertEqual(self.context, goal._context) + mock_get_goal.return_value = self.fake_goal + goal = objects.Goal.get_by_name(self.context, name) + mock_get_goal.assert_called_once_with(self.context, name) + self.assertEqual(self.context, goal._context) - def test_list(self): - with mock.patch.object(self.dbapi, 'get_goal_list', - autospec=True) as mock_get_list: - mock_get_list.return_value = [self.fake_goal] - goals = objects.Goal.list(self.context) - self.assertEqual(1, mock_get_list.call_count) - self.assertEqual(1, len(goals)) - self.assertIsInstance(goals[0], objects.Goal) - self.assertEqual(self.context, goals[0]._context) + @mock.patch.object(db_api.Connection, 'get_goal_list') + def test_list(self, mock_get_list): + mock_get_list.return_value = [self.fake_goal] + goals = objects.Goal.list(self.context) + self.assertEqual(1, mock_get_list.call_count) + self.assertEqual(1, len(goals)) + self.assertIsInstance(goals[0], objects.Goal) + self.assertEqual(self.context, goals[0]._context) - def test_create(self): - with mock.patch.object(self.dbapi, 'create_goal', - autospec=True) as mock_create_goal: - mock_create_goal.return_value = self.fake_goal - goal = objects.Goal(self.context, **self.fake_goal) - goal.create() - mock_create_goal.assert_called_once_with(self.fake_goal) - self.assertEqual(self.context, goal._context) + @mock.patch.object(db_api.Connection, 'create_goal') + def test_create(self, mock_create_goal): + mock_create_goal.return_value = self.fake_goal + goal = objects.Goal(self.context, **self.fake_goal) + goal.create() + expected_goal = self.fake_goal.copy() + expected_goal['created_at'] = expected_goal['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + mock_create_goal.assert_called_once_with(expected_goal) + self.assertEqual(self.context, goal._context) - def test_destroy(self): + @mock.patch.object(db_api.Connection, 'destroy_goal') + @mock.patch.object(db_api.Connection, 'get_goal_by_id') + def test_destroy(self, mock_get_goal, mock_destroy_goal): goal_id = self.fake_goal['id'] - with mock.patch.object(self.dbapi, 'get_goal_by_id', - autospec=True) as mock_get_goal: - mock_get_goal.return_value = self.fake_goal - with mock.patch.object(self.dbapi, 'destroy_goal', - autospec=True) \ - as mock_destroy_goal: - goal = objects.Goal.get_by_id(self.context, goal_id) - goal.destroy() - mock_get_goal.assert_called_once_with( - self.context, goal_id) - mock_destroy_goal.assert_called_once_with(goal_id) - self.assertEqual(self.context, goal._context) + mock_get_goal.return_value = self.fake_goal + goal = objects.Goal.get_by_id(self.context, goal_id) + goal.destroy() + mock_get_goal.assert_called_once_with( + self.context, goal_id) + mock_destroy_goal.assert_called_once_with(goal_id) + self.assertEqual(self.context, goal._context) - def test_save(self): - goal_id = self.fake_goal['id'] - with mock.patch.object(self.dbapi, 'get_goal_by_id', - autospec=True) as mock_get_goal: - mock_get_goal.return_value = self.fake_goal - with mock.patch.object(self.dbapi, 'update_goal', - autospec=True) as mock_update_goal: - goal = objects.Goal.get_by_id(self.context, goal_id) - goal.display_name = 'DUMMY' - goal.save() + @mock.patch.object(db_api.Connection, 'update_goal') + @mock.patch.object(db_api.Connection, 'get_goal_by_uuid') + def test_save(self, mock_get_goal, mock_update_goal): + mock_get_goal.return_value = self.fake_goal + goal_uuid = self.fake_goal['uuid'] + fake_saved_goal = self.fake_goal.copy() + fake_saved_goal['updated_at'] = datetime.datetime.utcnow() + mock_update_goal.return_value = fake_saved_goal - mock_get_goal.assert_called_once_with(self.context, goal_id) - mock_update_goal.assert_called_once_with( - goal_id, {'display_name': 'DUMMY'}) - self.assertEqual(self.context, goal._context) + goal = objects.Goal.get_by_uuid(self.context, goal_uuid) + goal.display_name = 'DUMMY' + goal.save() - def test_refresh(self): - uuid = self.fake_goal['uuid'] + mock_get_goal.assert_called_once_with(self.context, goal_uuid) + mock_update_goal.assert_called_once_with( + goal_uuid, {'display_name': 'DUMMY'}) + self.assertEqual(self.context, goal._context) + + @mock.patch.object(db_api.Connection, 'get_goal_by_uuid') + def test_refresh(self, mock_get_goal): fake_goal2 = utils.get_test_goal(name="BALANCE_LOAD") returns = [self.fake_goal, fake_goal2] + mock_get_goal.side_effect = returns + uuid = self.fake_goal['uuid'] expected = [mock.call(self.context, uuid), mock.call(self.context, uuid)] - with mock.patch.object(self.dbapi, 'get_goal_by_uuid', - side_effect=returns, - autospec=True) as mock_get_goal: - goal = objects.Goal.get(self.context, uuid) - self.assertEqual("TEST", goal.name) - goal.refresh() - self.assertEqual("BALANCE_LOAD", goal.name) - self.assertEqual(expected, mock_get_goal.call_args_list) - self.assertEqual(self.context, goal._context) + goal = objects.Goal.get(self.context, uuid) + self.assertEqual("TEST", goal.name) + goal.refresh() + self.assertEqual("BALANCE_LOAD", goal.name) + self.assertEqual(expected, mock_get_goal.call_args_list) + self.assertEqual(self.context, goal._context) + + @mock.patch.object(db_api.Connection, 'soft_delete_goal') + @mock.patch.object(db_api.Connection, 'get_goal_by_uuid') + def test_soft_delete(self, mock_get_goal, mock_soft_delete_goal): + mock_get_goal.return_value = self.fake_goal + fake_deleted_goal = self.fake_goal.copy() + fake_deleted_goal['deleted_at'] = datetime.datetime.utcnow() + mock_soft_delete_goal.return_value = fake_deleted_goal + + expected_goal = fake_deleted_goal.copy() + expected_goal['created_at'] = expected_goal['created_at'].replace( + tzinfo=iso8601.iso8601.Utc()) + expected_goal['deleted_at'] = expected_goal['deleted_at'].replace( + tzinfo=iso8601.iso8601.Utc()) - def test_soft_delete(self): uuid = self.fake_goal['uuid'] - with mock.patch.object(self.dbapi, 'get_goal_by_uuid', - autospec=True) as mock_get_goal: - mock_get_goal.return_value = self.fake_goal - with mock.patch.object(self.dbapi, 'soft_delete_goal', - autospec=True) \ - as mock_soft_delete_goal: - goal = objects.Goal.get_by_uuid( - self.context, uuid) - goal.soft_delete() - mock_get_goal.assert_called_once_with( - self.context, uuid) - mock_soft_delete_goal.assert_called_once_with(uuid) - self.assertEqual(self.context, goal._context) + goal = objects.Goal.get_by_uuid(self.context, uuid) + goal.soft_delete() + mock_get_goal.assert_called_once_with(self.context, uuid) + mock_soft_delete_goal.assert_called_once_with(uuid) + self.assertEqual(self.context, goal._context) + self.assertEqual(expected_goal, goal.as_dict()) diff --git a/watcher/tests/objects/test_scoring_engine.py b/watcher/tests/objects/test_scoring_engine.py index 4dbc41ba8..e27fbcffd 100644 --- a/watcher/tests/objects/test_scoring_engine.py +++ b/watcher/tests/objects/test_scoring_engine.py @@ -13,7 +13,12 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock + +from watcher.db.sqlalchemy import api as db_api from watcher import objects from watcher.tests.db import base from watcher.tests.db import utils @@ -23,126 +28,125 @@ class TestScoringEngineObject(base.DbTestCase): def setUp(self): super(TestScoringEngineObject, self).setUp() - self.fake_scoring_engine = utils.get_test_scoring_engine() + self.fake_scoring_engine = utils.get_test_scoring_engine( + created_at=datetime.datetime.utcnow()) - def test_get_by_id(self): + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id') + def test_get_by_id(self, mock_get_scoring_engine): scoring_engine_id = self.fake_scoring_engine['id'] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id', - autospec=True) as mock_get_scoring_engine: - mock_get_scoring_engine.return_value = self.fake_scoring_engine - scoring_engine = objects.ScoringEngine.get_by_id( - self.context, scoring_engine_id) - mock_get_scoring_engine.assert_called_once_with(self.context, - scoring_engine_id) - self.assertEqual(self.context, scoring_engine._context) + mock_get_scoring_engine.return_value = self.fake_scoring_engine + scoring_engine = objects.ScoringEngine.get_by_id( + self.context, scoring_engine_id) + mock_get_scoring_engine.assert_called_once_with( + self.context, scoring_engine_id) + self.assertEqual(self.context, scoring_engine._context) - def test_get_by_uuid(self): + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid') + def test_get_by_uuid(self, mock_get_scoring_engine): se_uuid = self.fake_scoring_engine['uuid'] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_uuid', - autospec=True) as mock_get_scoring_engine: - mock_get_scoring_engine.return_value = self.fake_scoring_engine - scoring_engine = objects.ScoringEngine.get_by_uuid( - self.context, se_uuid) - mock_get_scoring_engine.assert_called_once_with(self.context, - se_uuid) - self.assertEqual(self.context, scoring_engine._context) + mock_get_scoring_engine.return_value = self.fake_scoring_engine + scoring_engine = objects.ScoringEngine.get_by_uuid( + self.context, se_uuid) + mock_get_scoring_engine.assert_called_once_with( + self.context, se_uuid) + self.assertEqual(self.context, scoring_engine._context) - def test_get_by_name(self): + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid') + def test_get_by_name(self, mock_get_scoring_engine): scoring_engine_uuid = self.fake_scoring_engine['uuid'] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_uuid', - autospec=True) as mock_get_scoring_engine: - mock_get_scoring_engine.return_value = self.fake_scoring_engine - scoring_engine = objects.ScoringEngine.get( - self.context, scoring_engine_uuid) - mock_get_scoring_engine.assert_called_once_with( - self.context, scoring_engine_uuid) - self.assertEqual(self.context, scoring_engine._context) + mock_get_scoring_engine.return_value = self.fake_scoring_engine + scoring_engine = objects.ScoringEngine.get( + self.context, scoring_engine_uuid) + mock_get_scoring_engine.assert_called_once_with( + self.context, scoring_engine_uuid) + self.assertEqual(self.context, scoring_engine._context) - def test_list(self): - with mock.patch.object(self.dbapi, 'get_scoring_engine_list', - autospec=True) as mock_get_list: - mock_get_list.return_value = [self.fake_scoring_engine] - scoring_engines = objects.ScoringEngine.list(self.context) - self.assertEqual(1, mock_get_list.call_count, 1) - self.assertEqual(1, len(scoring_engines)) - self.assertIsInstance(scoring_engines[0], objects.ScoringEngine) - self.assertEqual(self.context, scoring_engines[0]._context) + @mock.patch.object(db_api.Connection, 'get_scoring_engine_list') + def test_list(self, mock_get_list): + mock_get_list.return_value = [self.fake_scoring_engine] + scoring_engines = objects.ScoringEngine.list(self.context) + self.assertEqual(1, mock_get_list.call_count, 1) + self.assertEqual(1, len(scoring_engines)) + self.assertIsInstance(scoring_engines[0], objects.ScoringEngine) + self.assertEqual(self.context, scoring_engines[0]._context) - def test_create(self): - with mock.patch.object(self.dbapi, 'create_scoring_engine', - autospec=True) as mock_create_scoring_engine: - mock_create_scoring_engine.return_value = self.fake_scoring_engine - scoring_engine = objects.ScoringEngine( - self.context, **self.fake_scoring_engine) + @mock.patch.object(db_api.Connection, 'create_scoring_engine') + def test_create(self, mock_create_scoring_engine): + mock_create_scoring_engine.return_value = self.fake_scoring_engine + scoring_engine = objects.ScoringEngine( + self.context, **self.fake_scoring_engine) + scoring_engine.create() + expected_scoring_engine = self.fake_scoring_engine.copy() + expected_scoring_engine['created_at'] = expected_scoring_engine[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) + mock_create_scoring_engine.assert_called_once_with( + expected_scoring_engine) + self.assertEqual(self.context, scoring_engine._context) - scoring_engine.create() - mock_create_scoring_engine.assert_called_once_with( - self.fake_scoring_engine) - self.assertEqual(self.context, scoring_engine._context) - - def test_destroy(self): + @mock.patch.object(db_api.Connection, 'destroy_scoring_engine') + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id') + def test_destroy(self, mock_get_scoring_engine, + mock_destroy_scoring_engine): + mock_get_scoring_engine.return_value = self.fake_scoring_engine _id = self.fake_scoring_engine['id'] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id', - autospec=True) as mock_get_scoring_engine: - mock_get_scoring_engine.return_value = self.fake_scoring_engine - with mock.patch.object( - self.dbapi, 'destroy_scoring_engine', - autospec=True) as mock_destroy_scoring_engine: - scoring_engine = objects.ScoringEngine.get_by_id( - self.context, _id) - scoring_engine.destroy() - mock_get_scoring_engine.assert_called_once_with( - self.context, _id) - mock_destroy_scoring_engine.assert_called_once_with(_id) - self.assertEqual(self.context, scoring_engine._context) + scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id) + scoring_engine.destroy() + mock_get_scoring_engine.assert_called_once_with(self.context, _id) + mock_destroy_scoring_engine.assert_called_once_with(_id) + self.assertEqual(self.context, scoring_engine._context) - def test_save(self): - _id = self.fake_scoring_engine['id'] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id', - autospec=True) as mock_get_scoring_engine: - mock_get_scoring_engine.return_value = self.fake_scoring_engine - with mock.patch.object( - self.dbapi, 'update_scoring_engine', - autospec=True) as mock_update_scoring_engine: - scoring_engine = objects.ScoringEngine.get_by_id( - self.context, _id) - scoring_engine.description = 'UPDATED DESCRIPTION' - scoring_engine.save() + @mock.patch.object(db_api.Connection, 'update_scoring_engine') + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid') + def test_save(self, mock_get_scoring_engine, mock_update_scoring_engine): + mock_get_scoring_engine.return_value = self.fake_scoring_engine + fake_saved_scoring_engine = self.fake_scoring_engine.copy() + fake_saved_scoring_engine['updated_at'] = datetime.datetime.utcnow() + mock_update_scoring_engine.return_value = fake_saved_scoring_engine - mock_get_scoring_engine.assert_called_once_with( - self.context, _id) - mock_update_scoring_engine.assert_called_once_with( - _id, {'description': 'UPDATED DESCRIPTION'}) - self.assertEqual(self.context, scoring_engine._context) + uuid = self.fake_scoring_engine['uuid'] + scoring_engine = objects.ScoringEngine.get_by_uuid(self.context, uuid) + scoring_engine.description = 'UPDATED DESCRIPTION' + scoring_engine.save() - def test_refresh(self): - _id = self.fake_scoring_engine['id'] + mock_get_scoring_engine.assert_called_once_with(self.context, uuid) + mock_update_scoring_engine.assert_called_once_with( + uuid, {'description': 'UPDATED DESCRIPTION'}) + self.assertEqual(self.context, scoring_engine._context) + + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id') + def test_refresh(self, mock_get_scoring_engine): returns = [ dict(self.fake_scoring_engine, description="first description"), dict(self.fake_scoring_engine, description="second description")] + mock_get_scoring_engine.side_effect = returns + _id = self.fake_scoring_engine['id'] expected = [mock.call(self.context, _id), mock.call(self.context, _id)] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id', - side_effect=returns, - autospec=True) as mock_get_scoring_engine: - scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id) - self.assertEqual("first description", scoring_engine.description) - scoring_engine.refresh() - self.assertEqual("second description", scoring_engine.description) - self.assertEqual(expected, mock_get_scoring_engine.call_args_list) - self.assertEqual(self.context, scoring_engine._context) + scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id) + self.assertEqual("first description", scoring_engine.description) + scoring_engine.refresh() + self.assertEqual("second description", scoring_engine.description) + self.assertEqual(expected, mock_get_scoring_engine.call_args_list) + self.assertEqual(self.context, scoring_engine._context) + + @mock.patch.object(db_api.Connection, 'soft_delete_scoring_engine') + @mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id') + def test_soft_delete(self, mock_get_scoring_engine, mock_soft_delete): + mock_get_scoring_engine.return_value = self.fake_scoring_engine + fake_deleted_scoring_engine = self.fake_scoring_engine.copy() + fake_deleted_scoring_engine['deleted_at'] = datetime.datetime.utcnow() + mock_soft_delete.return_value = fake_deleted_scoring_engine + + expected_scoring_engine = fake_deleted_scoring_engine.copy() + expected_scoring_engine['created_at'] = expected_scoring_engine[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) + expected_scoring_engine['deleted_at'] = expected_scoring_engine[ + 'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc()) - def test_soft_delete(self): _id = self.fake_scoring_engine['id'] - with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id', - autospec=True) as mock_get_scoring_engine: - mock_get_scoring_engine.return_value = self.fake_scoring_engine - with mock.patch.object(self.dbapi, 'soft_delete_scoring_engine', - autospec=True) as mock_soft_delete: - scoring_engine = objects.ScoringEngine.get_by_id( - self.context, _id) - scoring_engine.soft_delete() - mock_get_scoring_engine.assert_called_once_with( - self.context, _id) - mock_soft_delete.assert_called_once_with(_id) - self.assertEqual(self.context, scoring_engine._context) + scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id) + scoring_engine.soft_delete() + mock_get_scoring_engine.assert_called_once_with(self.context, _id) + mock_soft_delete.assert_called_once_with(_id) + self.assertEqual(self.context, scoring_engine._context) + self.assertEqual(expected_scoring_engine, scoring_engine.as_dict()) diff --git a/watcher/tests/objects/test_service.py b/watcher/tests/objects/test_service.py index 2832fceb2..0dcef21fb 100644 --- a/watcher/tests/objects/test_service.py +++ b/watcher/tests/objects/test_service.py @@ -13,8 +13,12 @@ # License for the specific language governing permissions and limitations # under the License. +import datetime + +import iso8601 import mock +from watcher.db.sqlalchemy import api as db_api from watcher import objects from watcher.tests.db import base from watcher.tests.db import utils @@ -24,81 +28,89 @@ class TestServiceObject(base.DbTestCase): def setUp(self): super(TestServiceObject, self).setUp() - self.fake_service = utils.get_test_service() + self.fake_service = utils.get_test_service( + created_at=datetime.datetime.utcnow()) - def test_get_by_id(self): + @mock.patch.object(db_api.Connection, 'get_service_by_id') + def test_get_by_id(self, mock_get_service): service_id = self.fake_service['id'] - with mock.patch.object(self.dbapi, 'get_service_by_id', - autospec=True) as mock_get_service: - mock_get_service.return_value = self.fake_service - service = objects.Service.get(self.context, service_id) - mock_get_service.assert_called_once_with(self.context, - service_id) - self.assertEqual(self.context, service._context) + mock_get_service.return_value = self.fake_service + service = objects.Service.get(self.context, service_id) + mock_get_service.assert_called_once_with(self.context, service_id) + self.assertEqual(self.context, service._context) - def test_list(self): - with mock.patch.object(self.dbapi, 'get_service_list', - autospec=True) as mock_get_list: - mock_get_list.return_value = [self.fake_service] - services = objects.Service.list(self.context) - self.assertEqual(1, mock_get_list.call_count, 1) - self.assertEqual(1, len(services)) - self.assertIsInstance(services[0], objects.Service) - self.assertEqual(self.context, services[0]._context) + @mock.patch.object(db_api.Connection, 'get_service_list') + def test_list(self, mock_get_list): + mock_get_list.return_value = [self.fake_service] + services = objects.Service.list(self.context) + self.assertEqual(1, mock_get_list.call_count, 1) + self.assertEqual(1, len(services)) + self.assertIsInstance(services[0], objects.Service) + self.assertEqual(self.context, services[0]._context) - def test_create(self): - with mock.patch.object(self.dbapi, 'create_service', - autospec=True) as mock_create_service: - mock_create_service.return_value = self.fake_service - service = objects.Service(self.context, **self.fake_service) + @mock.patch.object(db_api.Connection, 'create_service') + def test_create(self, mock_create_service): + mock_create_service.return_value = self.fake_service + service = objects.Service(self.context, **self.fake_service) - fake_service = utils.get_test_service() + service.create() + expected_service = self.fake_service.copy() + expected_service['created_at'] = expected_service[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) - service.create() - mock_create_service.assert_called_once_with(fake_service) - self.assertEqual(self.context, service._context) + mock_create_service.assert_called_once_with(expected_service) + self.assertEqual(self.context, service._context) - def test_save(self): + @mock.patch.object(db_api.Connection, 'update_service') + @mock.patch.object(db_api.Connection, 'get_service_by_id') + def test_save(self, mock_get_service, mock_update_service): + mock_get_service.return_value = self.fake_service + fake_saved_service = self.fake_service.copy() + fake_saved_service['updated_at'] = datetime.datetime.utcnow() + mock_update_service.return_value = fake_saved_service _id = self.fake_service['id'] - with mock.patch.object(self.dbapi, 'get_service_by_id', - autospec=True) as mock_get_service: - mock_get_service.return_value = self.fake_service - with mock.patch.object(self.dbapi, 'update_service', - autospec=True) as mock_update_service: - service = objects.Service.get(self.context, _id) - service.name = 'UPDATED NAME' - service.save() + service = objects.Service.get(self.context, _id) + service.name = 'UPDATED NAME' + service.save() - mock_get_service.assert_called_once_with(self.context, _id) - mock_update_service.assert_called_once_with( - _id, {'name': 'UPDATED NAME'}) - self.assertEqual(self.context, service._context) + mock_get_service.assert_called_once_with(self.context, _id) + mock_update_service.assert_called_once_with( + _id, {'name': 'UPDATED NAME'}) + self.assertEqual(self.context, service._context) - def test_refresh(self): - _id = self.fake_service['id'] + @mock.patch.object(db_api.Connection, 'get_service_by_id') + def test_refresh(self, mock_get_service): returns = [dict(self.fake_service, name="first name"), dict(self.fake_service, name="second name")] + mock_get_service.side_effect = returns + _id = self.fake_service['id'] expected = [mock.call(self.context, _id), mock.call(self.context, _id)] - with mock.patch.object(self.dbapi, 'get_service_by_id', - side_effect=returns, - autospec=True) as mock_get_service: - service = objects.Service.get(self.context, _id) - self.assertEqual("first name", service.name) - service.refresh() - self.assertEqual("second name", service.name) - self.assertEqual(expected, mock_get_service.call_args_list) - self.assertEqual(self.context, service._context) + service = objects.Service.get(self.context, _id) + self.assertEqual("first name", service.name) + service.refresh() + self.assertEqual("second name", service.name) + self.assertEqual(expected, mock_get_service.call_args_list) + self.assertEqual(self.context, service._context) + + @mock.patch.object(db_api.Connection, 'soft_delete_service') + @mock.patch.object(db_api.Connection, 'get_service_by_id') + def test_soft_delete(self, mock_get_service, mock_soft_delete): + mock_get_service.return_value = self.fake_service + fake_deleted_service = self.fake_service.copy() + fake_deleted_service['deleted_at'] = datetime.datetime.utcnow() + mock_soft_delete.return_value = fake_deleted_service + + expected_service = fake_deleted_service.copy() + expected_service['created_at'] = expected_service[ + 'created_at'].replace(tzinfo=iso8601.iso8601.Utc()) + expected_service['deleted_at'] = expected_service[ + 'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc()) - def test_soft_delete(self): _id = self.fake_service['id'] - with mock.patch.object(self.dbapi, 'get_service_by_id', - autospec=True) as mock_get_service: - mock_get_service.return_value = self.fake_service - with mock.patch.object(self.dbapi, 'soft_delete_service', - autospec=True) as mock_soft_delete: - service = objects.Service.get(self.context, _id) - service.soft_delete() - mock_get_service.assert_called_once_with(self.context, _id) - mock_soft_delete.assert_called_once_with(_id) - self.assertEqual(self.context, service._context) + service = objects.Service.get(self.context, _id) + service.soft_delete() + mock_get_service.assert_called_once_with(self.context, _id) + mock_soft_delete.assert_called_once_with(_id) + self.assertEqual(self.context, service._context) + self.assertEqual(expected_service, service.as_dict())