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 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 _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()
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)
def audit_post_data(**kw):
audit = db_utils.get_test_audit(**kw)
internal = audit_ctrl.AuditPatchType.internal_attrs()
return remove_internal(audit, internal)
