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