def prepare_audit_template_strategy_with_parameter(self): fake_spec = { "properties": { "fake1": { "description": "number parameter example", "type": "number", "default": 3.2, "minimum": 1.0, "maximum": 10.2, } } } template_uuid = 'e74c40e0-d825-11e2-a28f-0800200c9a67' strategy_uuid = 'e74c40e0-d825-11e2-a28f-0800200c9a68' template_name = 'my template' strategy_name = 'my strategy' strategy_id = 3 strategy = db_utils.get_test_strategy(parameters_spec=fake_spec, id=strategy_id, uuid=strategy_uuid, name=strategy_name) obj_utils.create_test_strategy(self.context, parameters_spec=fake_spec, id=strategy_id, uuid=strategy_uuid, name=strategy_name) obj_utils.create_test_audit_template(self.context, strategy_id=strategy_id, uuid=template_uuid, name='name') audit_template = db_utils.get_test_audit_template( strategy_id=strategy['id'], uuid=template_uuid, name=template_name) return audit_template
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 get_test_strategy(context, **kw): """Return a Strategy 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.Strategy db_data = db_utils.get_test_strategy(**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_with_predefined_strategy(**kw): spec = kw.pop('strategy_parameters_spec', {}) strategy_id = 2 strategy = db_utils.get_test_strategy(parameters_spec=spec, id=strategy_id) audit_template = db_utils.get_test_audit_template( strategy_id=strategy['id']) audit = api_utils.audit_post_data(**kw) del audit['audit_template_id'] audit['audit_template_uuid'] = audit_template['uuid'] return audit
def get_test_strategy(context, **kw): """Return a Strategy 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_strategy = db_utils.get_test_strategy(**kw) # Let DB generate ID if it isn't specified explicitly if 'id' not in kw: del db_strategy['id'] strategy = objects.Strategy(context) for key in db_strategy: setattr(strategy, key, db_strategy[key]) return strategy
def post_get_test_audit_with_predefined_strategy(**kw): spec = kw.pop('strategy_parameters_spec', {}) strategy_id = 2 strategy = db_utils.get_test_strategy(parameters_spec=spec, id=strategy_id) audit = api_utils.audit_post_data(**kw) audit_template = db_utils.get_test_audit_template( strategy_id=strategy['id']) del_keys = ['goal_id', 'strategy_id'] add_keys = {'audit_template_uuid': audit_template['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_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 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(TestStrategyObject, self).setUp() self.fake_strategy = utils.get_test_strategy()
def _create_test_strategy(self, **kwargs): strategy = utils.get_test_strategy(**kwargs) self.dbapi.create_strategy(strategy) return strategy
def setUp(self): super(TestCreateDeleteStrategyObject, self).setUp() self.fake_goal = utils.create_test_goal() self.fake_strategy = utils.get_test_strategy(goal_id=self.fake_goal.id)
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 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)