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 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.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() self.assertEqual(2, self.m_notifier.info.call_count) self.assertEqual( 'audit.update', self.m_notifier.info.call_args_list[0][1]['event_type']) self.assertEqual( 'audit.delete', self.m_notifier.info.call_args_list[1][1]['event_type'])
def get_test_audit(context, **kw): """Return a Audit object with appropriate attributes. NOTE: The object leaves the attributes marked as changed, such that a create() could be used to commit it to the DB. """ obj_cls = objects.Audit db_data = db_utils.get_test_audit(**kw) obj_data = _load_related_objects(context, obj_cls, db_data) return _load_test_obj(context, obj_cls, obj_data, **kw)
def setUp(self): super(TestCreateDeleteAuditObject, self).setUp() p_audit_notifications = mock.patch.object( notifications, 'audit', autospec=True) self.m_audit_notifications = p_audit_notifications.start() self.addCleanup(p_audit_notifications.stop) self.m_send_update = self.m_audit_notifications.send_update 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, created_at=datetime.datetime.utcnow())
def get_test_audit(context, **kw): """Return a Audit object with appropriate attributes. NOTE: The object leaves the attributes marked as changed, such that a create() could be used to commit it to the DB. """ db_audit = db_utils.get_test_audit(**kw) # Let DB generate ID if it isn't specified explicitly if 'id' not in kw: del db_audit['id'] audit = objects.Audit(context) for key in db_audit: setattr(audit, key, db_audit[key]) return audit
def setUp(self): super(TestAuditObjectSendNotifications, self).setUp() goal_id = 1 self.fake_goal = utils.create_test_goal(id=goal_id, name="DUMMY") self.fake_strategy = utils.create_test_strategy( id=goal_id, name="DUMMY") self.fake_audit = utils.get_test_audit( goal_id=goal_id, goal=utils.get_test_goal(id=goal_id), strategy_id=self.fake_strategy.id, strategy=self.fake_strategy) p_get_notifier = mock.patch.object(rpc, 'get_notifier') self.m_get_notifier = p_get_notifier.start() self.m_get_notifier.return_value = mock.Mock(name='m_notifier') self.m_notifier = self.m_get_notifier.return_value self.addCleanup(p_get_notifier.stop)
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) audit.state = objects.audit.State.ONGOING audit.save() self.assertEqual(1, self.m_notifier.info.call_count) self.assertEqual('audit.update', self.m_notifier.info.call_args[1]['event_type'])
def test_get_action_plan_list_eager(self): _strategy = utils.get_test_strategy() strategy = self.dbapi.create_strategy(_strategy) _audit = utils.get_test_audit() audit = self.dbapi.create_audit(_audit) uuids = [] for _ in range(1, 4): action_plan = utils.create_test_action_plan( uuid=w_utils.generate_uuid()) uuids.append(six.text_type(action_plan['uuid'])) action_plans = self.dbapi.get_action_plan_list(self.context, eager=True) action_plan_map = {a.uuid: a for a in action_plans} self.assertEqual(sorted(uuids), sorted(action_plan_map.keys())) eager_action_plan = action_plan_map[action_plan.uuid] self.assertEqual(strategy.as_dict(), eager_action_plan.strategy.as_dict()) self.assertEqual(audit.as_dict(), eager_action_plan.audit.as_dict())
def _create_test_audit(self, **kwargs): audit = utils.get_test_audit(**kwargs) self.dbapi.create_audit(audit) return audit
def audit_post_data(**kw): audit = db_utils.get_test_audit(**kw) internal = audit_ctrl.AuditPatchType.internal_attrs() return remove_internal(audit, internal)
def setUp(self): super(TestAuditObject, self).setUp() self.fake_audit = utils.get_test_audit()
class TestActionPlanObject(base.DbTestCase): audit_id = 2 strategy_id = 2 scenarios = [ ('non_eager', dict( eager=False, fake_action_plan=utils.get_test_action_plan( created_at=datetime.datetime.utcnow(), audit_id=audit_id, strategy_id=strategy_id))), ('eager_with_non_eager_load', dict( eager=True, fake_action_plan=utils.get_test_action_plan( created_at=datetime.datetime.utcnow(), audit_id=audit_id, strategy_id=strategy_id))), ('eager_with_eager_load', dict( eager=True, fake_action_plan=utils.get_test_action_plan( created_at=datetime.datetime.utcnow(), strategy_id=strategy_id, strategy=utils.get_test_strategy(id=strategy_id), audit_id=audit_id, audit=utils.get_test_audit(id=audit_id)))), ] def setUp(self): super(TestActionPlanObject, self).setUp() p_action_plan_notifications = mock.patch.object( notifications, 'action_plan', autospec=True) self.m_action_plan_notifications = p_action_plan_notifications.start() self.addCleanup(p_action_plan_notifications.stop) self.m_send_update = self.m_action_plan_notifications.send_update self.fake_audit = utils.create_test_audit(id=self.audit_id) self.fake_strategy = utils.create_test_strategy( id=self.strategy_id, name="DUMMY") def eager_load_action_plan_assert(self, action_plan): if self.eager: self.assertIsNotNone(action_plan.audit) fields_to_check = set( super(objects.Audit, objects.Audit).fields ).symmetric_difference(objects.Audit.fields) db_data = { k: v for k, v in self.fake_audit.as_dict().items() if k in fields_to_check} object_data = { k: v for k, v in action_plan.audit.as_dict().items() if k in fields_to_check} self.assertEqual(db_data, object_data) @mock.patch.object(db_api.Connection, 'get_action_plan_by_id') def test_get_by_id(self, mock_get_action_plan): mock_get_action_plan.return_value = self.fake_action_plan action_plan_id = self.fake_action_plan['id'] action_plan = objects.ActionPlan.get( self.context, action_plan_id, eager=self.eager) mock_get_action_plan.assert_called_once_with( self.context, action_plan_id, eager=self.eager) self.assertEqual(self.context, action_plan._context) self.eager_load_action_plan_assert(action_plan) self.assertEqual(0, self.m_send_update.call_count) @mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid') def test_get_by_uuid(self, mock_get_action_plan): mock_get_action_plan.return_value = self.fake_action_plan uuid = self.fake_action_plan['uuid'] action_plan = objects.ActionPlan.get( self.context, uuid, eager=self.eager) mock_get_action_plan.assert_called_once_with( self.context, uuid, eager=self.eager) self.assertEqual(self.context, action_plan._context) self.eager_load_action_plan_assert(action_plan) self.assertEqual(0, self.m_send_update.call_count) def test_get_bad_id_and_uuid(self): self.assertRaises(exception.InvalidIdentity, objects.ActionPlan.get, self.context, 'not-a-uuid', eager=self.eager) @mock.patch.object(db_api.Connection, 'get_action_plan_list') def test_list(self, mock_get_list): mock_get_list.return_value = [self.fake_action_plan] action_plans = objects.ActionPlan.list(self.context, eager=self.eager) self.assertEqual(1, mock_get_list.call_count) self.assertEqual(1, len(action_plans)) self.assertIsInstance(action_plans[0], objects.ActionPlan) self.assertEqual(self.context, action_plans[0]._context) for action_plan in action_plans: self.eager_load_action_plan_assert(action_plan) self.assertEqual(0, self.m_send_update.call_count) @mock.patch.object(db_api.Connection, 'update_action_plan') @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['state'] = objects.action_plan.State.SUCCEEDED fake_saved_action_plan['updated_at'] = datetime.datetime.utcnow() mock_update_action_plan.return_value = fake_saved_action_plan expected_action_plan = fake_saved_action_plan.copy() expected_action_plan[ 'created_at'] = expected_action_plan['created_at'].replace( tzinfo=iso8601.UTC) expected_action_plan[ 'updated_at'] = expected_action_plan['updated_at'].replace( tzinfo=iso8601.UTC) uuid = self.fake_action_plan['uuid'] action_plan = objects.ActionPlan.get_by_uuid( self.context, uuid, eager=self.eager) action_plan.state = objects.action_plan.State.SUCCEEDED action_plan.save() mock_get_action_plan.assert_called_once_with( self.context, uuid, eager=self.eager) mock_update_action_plan.assert_called_once_with( uuid, {'state': objects.action_plan.State.SUCCEEDED}) self.assertEqual(self.context, action_plan._context) self.eager_load_action_plan_assert(action_plan) self.m_send_update.assert_called_once_with( self.context, action_plan, old_state=self.fake_action_plan['state']) self.assertEqual( {k: v for k, v in expected_action_plan.items() if k not in action_plan.object_fields}, {k: v for k, v in action_plan.as_dict().items() if k not in action_plan.object_fields}) @mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid') def test_refresh(self, mock_get_action_plan): returns = [dict(self.fake_action_plan, state="first state"), dict(self.fake_action_plan, state="second state")] mock_get_action_plan.side_effect = returns uuid = self.fake_action_plan['uuid'] expected = [mock.call(self.context, uuid, eager=self.eager), mock.call(self.context, uuid, eager=self.eager)] action_plan = objects.ActionPlan.get( self.context, uuid, eager=self.eager) self.assertEqual("first state", action_plan.state) action_plan.refresh(eager=self.eager) self.assertEqual("second state", action_plan.state) self.assertEqual(expected, mock_get_action_plan.call_args_list) self.assertEqual(self.context, action_plan._context) self.eager_load_action_plan_assert(action_plan)
class TestAuditObject(base.DbTestCase): goal_id = 2 goal_data = utils.get_test_goal( id=goal_id, uuid=w_utils.generate_uuid(), name="DUMMY") scenarios = [ ('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( created_at=datetime.datetime.utcnow(), goal_id=goal_id, goal=goal_data))), ] def setUp(self): super(TestAuditObject, self).setUp() p_audit_notifications = mock.patch.object( notifications, 'audit', autospec=True) self.m_audit_notifications = p_audit_notifications.start() self.addCleanup(p_audit_notifications.stop) self.m_send_update = self.m_audit_notifications.send_update self.fake_goal = utils.create_test_goal(**self.goal_data) def eager_load_audit_assert(self, audit, goal): if self.eager: self.assertIsNotNone(audit.goal) fields_to_check = set( super(objects.Goal, objects.Goal).fields ).symmetric_difference(objects.Goal.fields) db_data = { k: v for k, v in goal.as_dict().items() if k in fields_to_check} object_data = { k: v for k, v in audit.goal.as_dict().items() if k in fields_to_check} self.assertEqual(db_data, object_data) @mock.patch.object(db_api.Connection, 'get_audit_by_id') def test_get_by_id(self, mock_get_audit): mock_get_audit.return_value = self.fake_audit audit_id = self.fake_audit['id'] audit = objects.Audit.get(self.context, audit_id, eager=self.eager) mock_get_audit.assert_called_once_with( self.context, audit_id, eager=self.eager) self.assertEqual(self.context, audit._context) self.eager_load_audit_assert(audit, self.fake_goal) self.assertEqual(0, self.m_send_update.call_count) @mock.patch.object(db_api.Connection, 'get_audit_by_uuid') def test_get_by_uuid(self, mock_get_audit): mock_get_audit.return_value = self.fake_audit uuid = self.fake_audit['uuid'] audit = objects.Audit.get(self.context, uuid, eager=self.eager) mock_get_audit.assert_called_once_with( self.context, uuid, eager=self.eager) self.assertEqual(self.context, audit._context) self.eager_load_audit_assert(audit, self.fake_goal) self.assertEqual(0, self.m_send_update.call_count) def test_get_bad_id_and_uuid(self): self.assertRaises(exception.InvalidIdentity, objects.Audit.get, self.context, 'not-a-uuid', eager=self.eager) @mock.patch.object(db_api.Connection, 'get_audit_list') def test_list(self, mock_get_list): mock_get_list.return_value = [self.fake_audit] audits = objects.Audit.list(self.context, eager=self.eager) mock_get_list.assert_called_once_with( self.context, eager=self.eager, filters=None, limit=None, marker=None, sort_dir=None, sort_key=None) self.assertEqual(1, len(audits)) self.assertIsInstance(audits[0], objects.Audit) self.assertEqual(self.context, audits[0]._context) for audit in audits: self.eager_load_audit_assert(audit, self.fake_goal) self.assertEqual(0, self.m_send_update.call_count) @mock.patch.object(db_api.Connection, 'update_audit') @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.UTC) expected_audit['updated_at'] = expected_audit['updated_at'].replace( tzinfo=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 audit.save() mock_get_audit.assert_called_once_with( self.context, uuid, eager=self.eager) mock_update_audit.assert_called_once_with( uuid, {'state': objects.audit.State.SUCCEEDED}) self.assertEqual(self.context, audit._context) 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): returns = [dict(self.fake_audit, state="first state"), dict(self.fake_audit, state="second state")] mock_get_audit.side_effect = returns uuid = self.fake_audit['uuid'] expected = [ mock.call(self.context, uuid, eager=self.eager), mock.call(self.context, uuid, eager=self.eager)] audit = objects.Audit.get(self.context, uuid, eager=self.eager) self.assertEqual("first state", audit.state) audit.refresh(eager=self.eager) self.assertEqual("second state", audit.state) self.assertEqual(expected, mock_get_audit.call_args_list) self.assertEqual(self.context, audit._context) self.eager_load_audit_assert(audit, self.fake_goal)