def post_get_test_audit_template(**kw):
goal = db_utils.get_test_goal()
strategy = db_utils.get_test_strategy(goal_id=goal['id'])
kw['goal'] = kw.get('goal', goal['uuid'])
kw['strategy'] = kw.get('strategy', strategy['uuid'])
kw['scope'] = kw.get('scope', [])
audit_template = api_utils.audit_template_post_data(**kw)
return audit_template
def post_get_test_audit_template(**kw):
audit_template = api_utils.audit_template_post_data(**kw)
goal = db_utils.get_test_goal()
strategy = db_utils.get_test_strategy(goal_id=goal['id'])
del audit_template['uuid']
del audit_template['goal_id']
del audit_template['strategy_id']
audit_template['goal'] = kw.get('goal', goal['uuid'])
audit_template['strategy'] = kw.get('strategy', strategy['uuid'])
return audit_template
def post_get_test_audit_template(**kw):
audit_template = api_utils.audit_template_post_data(**kw)
goal = db_utils.get_test_goal()
strategy = db_utils.get_test_strategy(goal_id=goal['id'])
del audit_template['uuid']
del audit_template['goal_id']
del audit_template['strategy_id']
audit_template['goal'] = kw.get('goal', goal['uuid'])
audit_template['strategy'] = kw.get('strategy', strategy['uuid'])
return audit_template
def get_test_goal(context, **kw):
"""Return a Goal 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.Goal
db_data = db_utils.get_test_goal(**kw)
obj_data = _load_related_objects(context, obj_cls, db_data)
return _load_test_obj(context, obj_cls, obj_data, **kw)
def post_get_test_audit(**kw):
audit = api_utils.audit_post_data(**kw)
audit_template = db_utils.get_test_audit_template()
goal = db_utils.get_test_goal()
del_keys = ['goal_id', 'strategy_id']
add_keys = {'audit_template_uuid': audit_template['uuid'],
'goal': goal['uuid'],
}
for k in del_keys:
del audit[k]
for k in add_keys:
audit[k] = kw.get(k, add_keys[k])
return audit
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)]
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)
def get_test_goal(context, **kw):
"""Return a Goal 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_goal = db_utils.get_test_goal(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del db_goal['id']
goal = objects.Goal(context)
for key in db_goal:
setattr(goal, key, db_goal[key])
return goal
def get_test_goal(context, **kw):
"""Return a Goal 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_goal = db_utils.get_test_goal(**kw)
# Let DB generate ID if it isn't specified explicitly
if 'id' not in kw:
del db_goal['id']
goal = objects.Goal(context)
for key in db_goal:
setattr(goal, key, db_goal[key])
return goal
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_refresh(self):
uuid = self.fake_goal['uuid']
fake_goal2 = utils.get_test_goal(name="BALANCE_LOAD")
returns = [self.fake_goal, fake_goal2]
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)
def post_get_test_audit(**kw):
audit = api_utils.audit_post_data(**kw)
audit_template = db_utils.get_test_audit_template()
goal = db_utils.get_test_goal()
del_keys = ['goal_id', 'strategy_id']
del_keys.extend(kw.get('params_to_exclude', []))
add_keys = {'audit_template_uuid': audit_template['uuid'],
'goal': goal['uuid'],
}
if kw.get('use_named_goal'):
add_keys['goal'] = 'TEST'
for k in add_keys:
audit[k] = kw.get(k, add_keys[k])
for k in del_keys:
del audit[k]
return audit
def test_get_strategy_list_eager(self):
_goal = utils.get_test_goal()
goal = self.dbapi.create_goal(_goal)
uuids = []
for i in range(1, 4):
strategy = utils.create_test_strategy(
id=i,
uuid=w_utils.generate_uuid(),
name="STRATEGY_ID_%s" % i,
display_name='My Strategy {0}'.format(i),
goal_id=goal.id)
uuids.append(six.text_type(strategy['uuid']))
strategys = self.dbapi.get_strategy_list(self.context, eager=True)
strategy_map = {a.uuid: a for a in strategys}
self.assertEqual(sorted(uuids), sorted(strategy_map.keys()))
eager_strategy = strategy_map[strategy.uuid]
self.assertEqual(goal.as_dict(), eager_strategy.goal.as_dict())
def test_get_audit_list_eager(self):
_goal = utils.get_test_goal()
goal = self.dbapi.create_goal(_goal)
_strategy = utils.get_test_strategy()
strategy = self.dbapi.create_strategy(_strategy)
uuids = []
for i in range(1, 4):
audit = utils.create_test_audit(id=i,
uuid=w_utils.generate_uuid(),
goal_id=goal.id,
strategy_id=strategy.id)
uuids.append(six.text_type(audit['uuid']))
audits = self.dbapi.get_audit_list(self.context, eager=True)
audit_map = {a.uuid: a for a in audits}
self.assertEqual(sorted(uuids), sorted(audit_map.keys()))
eager_audit = audit_map[audit.uuid]
self.assertEqual(goal.as_dict(), eager_audit.goal.as_dict())
self.assertEqual(strategy.as_dict(), eager_audit.strategy.as_dict())
def setUp(self):
super(TestGoalObject, self).setUp()
self.fake_goal = utils.get_test_goal(
created_at=datetime.datetime.utcnow())
def _create_test_goal(self, **kwargs):
goal = utils.get_test_goal(**kwargs)
self.dbapi.create_goal(goal)
return goal
class TestAuditTemplateObject(base.DbTestCase):
goal_id = 1
goal_data = utils.get_test_goal(id=goal_id,
uuid=w_utils.generate_uuid(),
name="DUMMY")
scenarios = [
('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))),
]
def setUp(self):
super(TestAuditTemplateObject, self).setUp()
self.fake_goal = utils.create_test_goal(**self.goal_data)
def eager_load_audit_template_assert(self, audit_template, goal):
if self.eager:
self.assertIsNotNone(audit_template.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_template.goal.as_dict().items()
if k in fields_to_check
}
self.assertEqual(db_data, object_data)
@mock.patch.object(db_api.Connection, 'get_audit_template_by_id')
def test_get_by_id(self, mock_get_audit_template):
mock_get_audit_template.return_value = self.fake_audit_template
audit_template_id = self.fake_audit_template['id']
audit_template = objects.AuditTemplate.get(self.context,
audit_template_id,
eager=self.eager)
mock_get_audit_template.assert_called_once_with(self.context,
audit_template_id,
eager=self.eager)
self.assertEqual(self.context, audit_template._context)
self.eager_load_audit_template_assert(audit_template, self.fake_goal)
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
def test_get_by_uuid(self, mock_get_audit_template):
mock_get_audit_template.return_value = self.fake_audit_template
uuid = self.fake_audit_template['uuid']
audit_template = objects.AuditTemplate.get(self.context,
uuid,
eager=self.eager)
mock_get_audit_template.assert_called_once_with(self.context,
uuid,
eager=self.eager)
self.assertEqual(self.context, audit_template._context)
self.eager_load_audit_template_assert(audit_template, self.fake_goal)
@mock.patch.object(db_api.Connection, 'get_audit_template_by_name')
def test_get_by_name(self, mock_get_audit_template):
mock_get_audit_template.return_value = self.fake_audit_template
name = self.fake_audit_template['name']
audit_template = objects.AuditTemplate.get_by_name(self.context,
name,
eager=self.eager)
mock_get_audit_template.assert_called_once_with(self.context,
name,
eager=self.eager)
self.assertEqual(self.context, audit_template._context)
self.eager_load_audit_template_assert(audit_template, self.fake_goal)
def test_get_bad_id_and_uuid(self):
self.assertRaises(exception.InvalidIdentity,
objects.AuditTemplate.get,
self.context,
'not-a-uuid',
eager=self.eager)
@mock.patch.object(db_api.Connection, 'get_audit_template_list')
def test_list(self, mock_get_list):
mock_get_list.return_value = [self.fake_audit_template]
audit_templates = objects.AuditTemplate.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(audit_templates))
self.assertIsInstance(audit_templates[0], objects.AuditTemplate)
self.assertEqual(self.context, audit_templates[0]._context)
for audit_template in audit_templates:
self.eager_load_audit_template_assert(audit_template,
self.fake_goal)
@mock.patch.object(db_api.Connection, 'update_audit_template')
@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)
audit_template.goal_id = self.fake_goal.id
audit_template.save()
mock_get_audit_template.assert_called_once_with(self.context,
uuid,
eager=self.eager)
mock_update_audit_template.assert_called_once_with(
uuid, {'goal_id': self.fake_goal.id})
self.assertEqual(self.context, audit_template._context)
self.eager_load_audit_template_assert(audit_template, self.fake_goal)
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
def test_refresh(self, mock_get_audit_template):
returns = [
dict(self.fake_audit_template, name="first name"),
dict(self.fake_audit_template, name="second name")
]
mock_get_audit_template.side_effect = returns
uuid = self.fake_audit_template['uuid']
expected = [
mock.call(self.context, uuid, eager=self.eager),
mock.call(self.context, uuid, eager=self.eager)
]
audit_template = objects.AuditTemplate.get(self.context,
uuid,
eager=self.eager)
self.assertEqual("first name", audit_template.name)
audit_template.refresh(eager=self.eager)
self.assertEqual("second name", audit_template.name)
self.assertEqual(expected, mock_get_audit_template.call_args_list)
self.assertEqual(self.context, audit_template._context)
self.eager_load_audit_template_assert(audit_template, self.fake_goal)
class TestStrategyObject(base.DbTestCase):
goal_id = 2
scenarios = [
('non_eager',
dict(eager=False,
fake_strategy=utils.get_test_strategy(goal_id=goal_id))),
('eager_with_non_eager_load',
dict(eager=True,
fake_strategy=utils.get_test_strategy(goal_id=goal_id))),
('eager_with_eager_load',
dict(eager=True,
fake_strategy=utils.get_test_strategy(
goal_id=goal_id, goal=utils.get_test_goal(id=goal_id)))),
]
def setUp(self):
super(TestStrategyObject, self).setUp()
self.fake_goal = utils.create_test_goal(id=self.goal_id)
def eager_load_strategy_assert(self, strategy):
if self.eager:
self.assertIsNotNone(strategy.goal)
fields_to_check = set(super(
objects.Goal,
objects.Goal).fields).symmetric_difference(objects.Goal.fields)
db_data = {
k: v
for k, v in self.fake_goal.as_dict().items()
if k in fields_to_check
}
object_data = {
k: v
for k, v in strategy.goal.as_dict().items()
if k in fields_to_check
}
self.assertEqual(db_data, object_data)
@mock.patch.object(db_api.Connection, 'get_strategy_by_id')
def test_get_by_id(self, mock_get_strategy):
strategy_id = self.fake_strategy['id']
mock_get_strategy.return_value = self.fake_strategy
strategy = objects.Strategy.get(self.context,
strategy_id,
eager=self.eager)
mock_get_strategy.assert_called_once_with(self.context,
strategy_id,
eager=self.eager)
self.assertEqual(self.context, strategy._context)
self.eager_load_strategy_assert(strategy)
@mock.patch.object(db_api.Connection, 'get_strategy_by_uuid')
def test_get_by_uuid(self, mock_get_strategy):
uuid = self.fake_strategy['uuid']
mock_get_strategy.return_value = self.fake_strategy
strategy = objects.Strategy.get(self.context, uuid, eager=self.eager)
mock_get_strategy.assert_called_once_with(self.context,
uuid,
eager=self.eager)
self.assertEqual(self.context, strategy._context)
self.eager_load_strategy_assert(strategy)
def test_get_bad_uuid(self):
self.assertRaises(exception.InvalidIdentity, objects.Strategy.get,
self.context, 'not-a-uuid')
@mock.patch.object(db_api.Connection, 'get_strategy_list')
def test_list(self, mock_get_list):
mock_get_list.return_value = [self.fake_strategy]
strategies = objects.Strategy.list(self.context, eager=self.eager)
self.assertEqual(1, mock_get_list.call_count, 1)
self.assertEqual(1, len(strategies))
self.assertIsInstance(strategies[0], objects.Strategy)
self.assertEqual(self.context, strategies[0]._context)
for strategy in strategies:
self.eager_load_strategy_assert(strategy)
@mock.patch.object(db_api.Connection, 'update_strategy')
@mock.patch.object(db_api.Connection, 'get_strategy_by_id')
def test_save(self, mock_get_strategy, mock_update_strategy):
_id = self.fake_strategy['id']
mock_get_strategy.return_value = self.fake_strategy
strategy = objects.Strategy.get_by_id(self.context,
_id,
eager=self.eager)
strategy.name = 'UPDATED NAME'
strategy.save()
mock_get_strategy.assert_called_once_with(self.context,
_id,
eager=self.eager)
mock_update_strategy.assert_called_once_with(_id,
{'name': 'UPDATED NAME'})
self.assertEqual(self.context, strategy._context)
self.eager_load_strategy_assert(strategy)
@mock.patch.object(db_api.Connection, 'get_strategy_by_id')
def test_refresh(self, mock_get_strategy):
_id = self.fake_strategy['id']
returns = [
dict(self.fake_strategy, name="first name"),
dict(self.fake_strategy, name="second name")
]
mock_get_strategy.side_effect = returns
expected = [
mock.call(self.context, _id, eager=self.eager),
mock.call(self.context, _id, eager=self.eager)
]
strategy = objects.Strategy.get(self.context, _id, eager=self.eager)
self.assertEqual("first name", strategy.name)
strategy.refresh(eager=self.eager)
self.assertEqual("second name", strategy.name)
self.assertEqual(expected, mock_get_strategy.call_args_list)
self.assertEqual(self.context, strategy._context)
self.eager_load_strategy_assert(strategy)
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 setUp(self):
super(TestGoalObject, self).setUp()
self.fake_goal = utils.get_test_goal()
def _create_test_goal(self, **kwargs):
goal = utils.get_test_goal(**kwargs)
self.dbapi.create_goal(goal)
return goal
