def test_execute_force_basic(self, mock_call): expected_strategy = "basic" mock_call.return_value = expected_strategy obj_utils.create_test_goal(self.context, id=50, uuid=utils.generate_uuid(), name="my_goal") strategy = obj_utils.create_test_strategy(self.context, id=42, uuid=utils.generate_uuid(), name=expected_strategy) audit_template = obj_utils.create_test_audit_template( self.context, uuid=utils.generate_uuid(), strategy_id=strategy.id, name="my_template") audit = obj_utils.create_test_audit( self.context, audit_template_id=audit_template.id, uuid=utils.generate_uuid(), ) solution = self.strategy_context.execute_strategy( audit.uuid, self.context) self.assertEqual(solution, expected_strategy)
def test_execute_force_dummy(self): obj_utils.create_test_goal(self.context, id=50, uuid=utils.generate_uuid(), name="my_goal") strategy = obj_utils.create_test_strategy(self.context, id=42, uuid=utils.generate_uuid(), name="dummy") audit_template = obj_utils.create_test_audit_template( self.context, uuid=utils.generate_uuid(), strategy_id=strategy.id, name="my_template") audit = obj_utils.create_test_audit( self.context, audit_template_id=audit_template.id, uuid=utils.generate_uuid(), ) solution = self.strategy_context.execute_strategy( audit.uuid, self.context) self.assertEqual(len(solution.actions), 3)
def test_get_audit_list_with_filters(self): audit1 = self._create_test_audit( id=1, type='ONESHOT', uuid=w_utils.generate_uuid(), deadline=None, state='ONGOING') audit2 = self._create_test_audit( id=2, type='CONTINUOUS', uuid=w_utils.generate_uuid(), deadline=None, state='PENDING') res = self.dbapi.get_audit_list(self.context, filters={'type': 'ONESHOT'}) self.assertEqual([audit1['id']], [r.id for r in res]) res = self.dbapi.get_audit_list(self.context, filters={'type': 'bad-type'}) self.assertEqual([], [r.id for r in res]) res = self.dbapi.get_audit_list( self.context, filters={'state': 'ONGOING'}) self.assertEqual([audit1['id']], [r.id for r in res]) res = self.dbapi.get_audit_list( self.context, filters={'state': 'PENDING'}) self.assertEqual([audit2['id']], [r.id for r in res])
def _data_setup(self): strategy1_name = "STRATEGY_ID_1" strategy2_name = "STRATEGY_ID_2" strategy3_name = "STRATEGY_ID_3" self.goal1 = utils.create_test_goal( id=1, uuid=w_utils.generate_uuid(), name="GOAL_ID", display_name="Goal") self.goal2 = utils.create_test_goal( id=2, uuid=w_utils.generate_uuid(), name="DUMMY", display_name="Dummy") with freezegun.freeze_time(self.FAKE_TODAY): self.strategy1 = utils.create_test_strategy( id=1, uuid=w_utils.generate_uuid(), name=strategy1_name, display_name="Strategy 1", goal_id=self.goal1.id) with freezegun.freeze_time(self.FAKE_OLD_DATE): self.strategy2 = utils.create_test_strategy( id=2, uuid=w_utils.generate_uuid(), name=strategy2_name, display_name="Strategy 2", goal_id=self.goal1.id) with freezegun.freeze_time(self.FAKE_OLDER_DATE): self.strategy3 = utils.create_test_strategy( id=3, uuid=w_utils.generate_uuid(), name=strategy3_name, display_name="Strategy 3", goal_id=self.goal2.id)
def test_get_scoring_engine_list_with_filters(self): scoring_engine1 = self._create_test_scoring_engine( id=1, uuid=w_utils.generate_uuid(), name="SE_ID_1", description='ScoringEngine 1', metainfo="a1=b1", ) scoring_engine2 = self._create_test_scoring_engine( id=2, uuid=w_utils.generate_uuid(), name="SE_ID_2", description='ScoringEngine 2', metainfo="a2=b2", ) res = self.dbapi.get_scoring_engine_list( self.context, filters={'description': 'ScoringEngine 1'}) self.assertEqual([scoring_engine1['name']], [r.name for r in res]) res = self.dbapi.get_scoring_engine_list( self.context, filters={'description': 'ScoringEngine 3'}) self.assertEqual([], [r.name for r in res]) res = self.dbapi.get_scoring_engine_list( self.context, filters={'description': 'ScoringEngine 2'}) self.assertEqual([scoring_engine2['name']], [r.name for r in res])
def test_filter_by_audit_template_name(self): audit_template_uuid = utils.generate_uuid() audit_template_name = 'My_Audit_Template' audit_template = obj_utils.create_test_audit_template( self.context, uuid=audit_template_uuid, name=audit_template_name) number_of_audits_with_audit_template_id = 5 for id_ in range(number_of_audits_with_audit_template_id): obj_utils.create_test_audit(self.context, id=id_, uuid=utils.generate_uuid(), audit_template_id=audit_template.id) for id_ in range(6, 8): obj_utils.create_test_audit(self.context, id=id_, uuid=utils.generate_uuid()) response = self.get_json('/audits/?audit_template=%s' % audit_template_name) audits = response['audits'] self.assertEqual(5, len(audits)) for audit in audits: self.assertEqual(audit_template_uuid, audit['audit_template_uuid'])
def setUp(self): super(TestAuditTemplateObject, self).setUp() self.fake_audit_template = utils.get_test_audit_template() self.fake_goal1 = utils.create_test_goal( id=1, uuid=w_utils.generate_uuid(), name="DUMMY") self.fake_goal2 = utils.create_test_goal( id=2, uuid=w_utils.generate_uuid(), name="BALANCE_LOAD")
def test_get_audit_list_with_filter_by_audit_template_name(self): audit_template = self.dbapi.create_audit_template( utils.get_test_audit_template( uuid=w_utils.generate_uuid(), name='My Audit Template 1', description='Description of my audit template 1', host_aggregate=5, goal='DUMMY', extra={'automatic': True}) ) audit = self._create_test_audit( type='ONESHOT', uuid=w_utils.generate_uuid(), deadline=None, state='ONGOING', audit_template_id=audit_template.id) res = self.dbapi.get_audit_list( self.context, filters={'audit_template_name': audit_template.name}) for r in res: self.assertEqual(audit['audit_template_id'], r.audit_template_id)
def test_get_strategy_list_with_filters(self): strategy1 = self._create_test_strategy( id=1, uuid=w_utils.generate_uuid(), name="STRATEGY_ID_1", display_name='Strategy 1', ) strategy2 = self._create_test_strategy( id=2, uuid=w_utils.generate_uuid(), name="STRATEGY_ID_2", display_name='Strategy 2', ) res = self.dbapi.get_strategy_list( self.context, filters={'display_name': 'Strategy 1'}) self.assertEqual([strategy1['uuid']], [r.uuid for r in res]) res = self.dbapi.get_strategy_list( self.context, filters={'display_name': 'Strategy 3'}) self.assertEqual([], [r.uuid for r in res]) res = self.dbapi.get_strategy_list( self.context, filters={'goal_id': 1}) self.assertEqual([strategy1['uuid'], strategy2['uuid']], [r.uuid for r in res]) res = self.dbapi.get_strategy_list( self.context, filters={'display_name': 'Strategy 2'}) self.assertEqual([strategy2['uuid']], [r.uuid for r in res])
def test_get_goal_list_with_filters(self): goal1 = self._create_test_goal( id=1, uuid=w_utils.generate_uuid(), name="GOAL_1", display_name='Goal 1', ) goal2 = self._create_test_goal( id=2, uuid=w_utils.generate_uuid(), name="GOAL_2", display_name='Goal 2', ) res = self.dbapi.get_goal_list(self.context, filters={'display_name': 'Goal 1'}) self.assertEqual([goal1['uuid']], [r.uuid for r in res]) res = self.dbapi.get_goal_list(self.context, filters={'display_name': 'Goal 3'}) self.assertEqual([], [r.uuid for r in res]) res = self.dbapi.get_goal_list( self.context, filters={'name': 'GOAL_1'}) self.assertEqual([goal1['uuid']], [r.uuid for r in res]) res = self.dbapi.get_goal_list( self.context, filters={'display_name': 'Goal 2'}) self.assertEqual([goal2['uuid']], [r.uuid for r in res])
def test_many_with_soft_deleted_audit_uuid(self): action_plan_list = [] audit1 = obj_utils.create_test_audit(self.context, id=1, uuid=utils.generate_uuid()) audit2 = obj_utils.create_test_audit(self.context, id=2, uuid=utils.generate_uuid()) for id_ in range(0, 2): action_plan = obj_utils.create_test_action_plan( self.context, id=id_, uuid=utils.generate_uuid(), audit_id=audit1.id) action_plan_list.append(action_plan.uuid) for id_ in range(2, 4): action_plan = obj_utils.create_test_action_plan( self.context, id=id_, uuid=utils.generate_uuid(), audit_id=audit2.id) action_plan_list.append(action_plan.uuid) self.delete('/audits/%s' % audit1.uuid) response = self.get_json('/action_plans') self.assertEqual(len(action_plan_list), len(response['action_plans'])) for id_ in range(0, 2): action_plan = response['action_plans'][id_] self.assertIsNone(action_plan['audit_uuid']) for id_ in range(2, 4): action_plan = response['action_plans'][id_] self.assertEqual(audit2.uuid, action_plan['audit_uuid'])
def test_filter_by_goal_name(self): goal1 = obj_utils.create_test_goal( self.context, id=1, uuid=utils.generate_uuid(), name='My_Goal 1') goal2 = obj_utils.create_test_goal( self.context, id=2, uuid=utils.generate_uuid(), name='My Goal 2') for id_ in range(1, 3): obj_utils.create_test_strategy( self.context, id=id_, uuid=utils.generate_uuid(), goal_id=goal1['id']) for id_ in range(3, 5): obj_utils.create_test_strategy( self.context, id=id_, uuid=utils.generate_uuid(), goal_id=goal2['id']) response = self.get_json('/strategies/?goal=%s' % goal1['name']) strategies = response['strategies'] self.assertEqual(2, len(strategies)) for strategy in strategies: self.assertEqual(goal1['uuid'], strategy['goal_uuid'])
def test_get_action_list_with_filters(self): audit = utils.create_test_audit(uuid=w_utils.generate_uuid()) action_plan = self._create_test_action_plan( id=1, uuid=w_utils.generate_uuid(), audit_id=audit.id, first_action_id=None, state='RECOMMENDED') action1 = self._create_test_action( id=1, action_plan_id=1, description='description action 1', uuid=w_utils.generate_uuid(), next=None, state='PENDING', alarm=None) action2 = self._create_test_action( id=2, action_plan_id=2, description='description action 2', uuid=w_utils.generate_uuid(), next=action1['uuid'], state='PENDING', alarm=None) action3 = self._create_test_action( id=3, action_plan_id=1, description='description action 3', uuid=w_utils.generate_uuid(), next=action2['uuid'], state='ONGOING', alarm=None) res = self.dbapi.get_action_list(self.context, filters={'state': 'ONGOING'}) self.assertEqual([action3['id']], [r.id for r in res]) res = self.dbapi.get_action_list(self.context, filters={'state': 'bad-state'}) self.assertEqual([], [r.id for r in res]) res = self.dbapi.get_action_list( self.context, filters={'action_plan_id': 2}) self.assertEqual([action2['id']], [r.id for r in res]) res = self.dbapi.get_action_list( self.context, filters={'action_plan_uuid': action_plan['uuid']}) self.assertEqual( [action1['id'], action3['id']].sort(), [r.id for r in res].sort()) res = self.dbapi.get_action_list( self.context, filters={'audit_uuid': audit.uuid}) for action in res: self.assertEqual(action_plan['id'], action.action_plan_id)
def test_audit_template_create_same_name(self): audit_template1 = utils.create_test_audit_template( uuid=w_utils.generate_uuid(), name='audit_template_name') self.assertEqual(audit_template1['uuid'], audit_template1.uuid) self.assertRaises( exception.AuditTemplateAlreadyExists, utils.create_test_audit_template, uuid=w_utils.generate_uuid(), name='audit_template_name')
def test_filter_by_action_plan_and_audit_uuids(self): audit = obj_utils.create_test_audit( self.context, uuid=utils.generate_uuid()) action_plan = obj_utils.create_test_action_plan( self.context, uuid=utils.generate_uuid(), audit_id=audit.id) url = '/actions?action_plan_uuid=%s&audit_uuid=%s' % ( action_plan.uuid, audit.uuid) response = self.get_json(url, expect_errors=True) self.assertEqual(400, response.status_int)
def _data_setup(self): with freezegun.freeze_time(self.FAKE_TODAY): self.goal1 = utils.create_test_goal( id=1, uuid=w_utils.generate_uuid(), name="GOAL_1", display_name="Goal 1") with freezegun.freeze_time(self.FAKE_OLD_DATE): self.goal2 = utils.create_test_goal( id=2, uuid=w_utils.generate_uuid(), name="GOAL_2", display_name="Goal 2") with freezegun.freeze_time(self.FAKE_OLDER_DATE): self.goal3 = utils.create_test_goal( id=3, uuid=w_utils.generate_uuid(), name="GOAL_3", display_name="Goal 3")
def test_many_with_audit_uuid(self): action_plan_list = [] audit = obj_utils.create_test_audit(self.context, uuid=utils.generate_uuid()) for id_ in range(5): action_plan = obj_utils.create_test_action_plan( self.context, id=id_, uuid=utils.generate_uuid(), audit_id=audit.id) action_plan_list.append(action_plan.uuid) response = self.get_json('/action_plans') self.assertEqual(len(action_plan_list), len(response['action_plans'])) for action in response['action_plans']: self.assertEqual(audit.uuid, action['audit_uuid'])
def test_many_without_soft_deleted(self): action_list = [] for id_ in [1, 2, 3]: action = obj_utils.create_test_action(self.context, id=id_, uuid=utils.generate_uuid()) action_list.append(action.uuid) for id_ in [4, 5]: action = obj_utils.create_test_action(self.context, id=id_, uuid=utils.generate_uuid()) action.soft_delete() response = self.get_json('/actions') self.assertEqual(3, len(response['actions'])) uuids = [s['uuid'] for s in response['actions']] self.assertEqual(sorted(action_list), sorted(uuids))
def test_JSONEncodedDict_default_value(self): # Create audit_template w/o extra audit_template1_id = w_utils.generate_uuid() self.dbapi.create_audit_template({'uuid': audit_template1_id}) audit_template1 = sa_api.model_query(models.AuditTemplate) \ .filter_by(uuid=audit_template1_id).one() self.assertEqual({}, audit_template1.extra) # Create audit_template with extra audit_template2_id = w_utils.generate_uuid() self.dbapi.create_audit_template({'uuid': audit_template2_id, 'extra': {'bar': 'foo'}}) audit_template2 = sa_api.model_query(models.AuditTemplate) \ .filter_by(uuid=audit_template2_id).one() self.assertEqual('foo', audit_template2.extra['bar'])
def test_many_with_sort_key_audit_uuid(self): audit_list = [] for id_ in range(5): audit = obj_utils.create_test_audit(self.context, uuid=utils.generate_uuid()) obj_utils.create_test_action_plan( self.context, id=id_, uuid=utils.generate_uuid(), audit_id=audit.id) audit_list.append(audit.uuid) response = self.get_json('/action_plans/?sort_key=audit_uuid') self.assertEqual(5, len(response['action_plans'])) uuids = [s['audit_uuid'] for s in response['action_plans']] self.assertEqual(sorted(audit_list), uuids)
def test_policy_disallow_create(self): fake_goal1 = obj_utils.get_test_goal( self.context, id=1, uuid=utils.generate_uuid(), name="dummy_1") fake_goal1.create() fake_strategy1 = obj_utils.get_test_strategy( self.context, id=1, uuid=utils.generate_uuid(), name="strategy_1", goal_id=fake_goal1.id) fake_strategy1.create() audit_template_dict = post_get_test_audit_template( goal=fake_goal1.uuid, strategy=fake_strategy1.uuid) self._common_policy_check( "audit_template:create", self.post_json, '/audit_templates', audit_template_dict, expect_errors=True)
def test_remove_strategy(self): audit_template = obj_utils.create_test_audit_template( self.context, uuid=utils.generate_uuid(), name="AT_%s" % utils.generate_uuid(), goal_id=self.fake_goal1.id, strategy_id=self.fake_strategy1.id) response = self.get_json( '/audit_templates/%s' % audit_template.uuid) self.assertIsNotNone(response['strategy_uuid']) response = self.patch_json( '/audit_templates/%s' % self.audit_template.uuid, [{'path': '/strategy', 'op': 'remove'}]) self.assertEqual('application/json', response.content_type) self.assertEqual(200, response.status_code)
def test_get_efficacy_indicator_list_with_filters(self): audit = utils.create_test_audit(uuid=w_utils.generate_uuid()) action_plan = self._create_test_action_plan( id=1, uuid=w_utils.generate_uuid(), audit_id=audit.id, first_efficacy_indicator_id=None, state='RECOMMENDED') efficacy_indicator1 = self._create_test_efficacy_indicator( id=1, name='indicator_1', uuid=w_utils.generate_uuid(), action_plan_id=1, description='Description efficacy indicator 1', unit='%') efficacy_indicator2 = self._create_test_efficacy_indicator( id=2, name='indicator_2', uuid=w_utils.generate_uuid(), action_plan_id=2, description='Description efficacy indicator 2', unit='%') efficacy_indicator3 = self._create_test_efficacy_indicator( id=3, name='indicator_3', uuid=w_utils.generate_uuid(), action_plan_id=1, description='Description efficacy indicator 3', unit='%') res = self.dbapi.get_efficacy_indicator_list( self.context, filters={'name': 'indicator_3'}) self.assertEqual([efficacy_indicator3['id']], [r.id for r in res]) res = self.dbapi.get_efficacy_indicator_list( self.context, filters={'unit': 'kWh'}) self.assertEqual([], [r.id for r in res]) res = self.dbapi.get_efficacy_indicator_list( self.context, filters={'action_plan_id': 2}) self.assertEqual([efficacy_indicator2['id']], [r.id for r in res]) res = self.dbapi.get_efficacy_indicator_list( self.context, filters={'action_plan_uuid': action_plan['uuid']}) self.assertEqual( [efficacy_indicator1['id'], efficacy_indicator3['id']].sort(), [r.id for r in res].sort())
def setUp(self): super(TestStrategyContext, self).setUp() obj_utils.create_test_goal(self.context, id=1, name="DUMMY") audit_template = obj_utils.create_test_audit_template( self.context, uuid=utils.generate_uuid()) self.audit = obj_utils.create_test_audit( self.context, audit_template_id=audit_template.id)
def test_many_with_soft_deleted(self): audit_list = [] for id_ in [1, 2, 3]: audit = obj_utils.create_test_audit(self.context, id=id_, uuid=utils.generate_uuid()) audit_list.append(audit.uuid) for id_ in [4, 5]: audit = obj_utils.create_test_audit(self.context, id=id_, uuid=utils.generate_uuid()) audit.soft_delete() audit_list.append(audit.uuid) response = self.get_json('/audits', headers={'X-Show-Deleted': 'True'}) self.assertEqual(5, len(response['audits'])) uuids = [s['uuid'] for s in response['audits']] self.assertEqual(sorted(audit_list), sorted(uuids))
def test_sync_with_modified_strategy( self, m_g_list, m_g_create, m_g_save, m_g_soft_delete, m_g_get_by_name, m_s_list, m_s_create, m_s_save, m_s_soft_delete): m_g_get_by_name.side_effect = [ objects.Goal(self.ctx, id=i) for i in range(1, 10)] m_g_list.return_value = [ objects.Goal(self.ctx, id=1, uuid=utils.generate_uuid(), name="dummy_1", display_name="Dummy 1", efficacy_specification=( self.goal1_spec.serialize_indicators_specs())) ] m_s_list.return_value = [ objects.Strategy(self.ctx, id=1, name="strategy_1", goal_id=1, display_name="original", parameters_spec='{}') ] self.syncer.sync() self.assertEqual(1, m_g_create.call_count) self.assertEqual(0, m_g_save.call_count) self.assertEqual(0, m_g_soft_delete.call_count) self.assertEqual(4, m_s_create.call_count) self.assertEqual(0, m_s_save.call_count) self.assertEqual(1, m_s_soft_delete.call_count)
def test_schedule_two_actions(self): default_planner = pbase.DefaultPlanner(mock.Mock()) audit = db_utils.create_test_audit(uuid=utils.generate_uuid()) solution = dsol.DefaultSolution( goal=mock.Mock(), strategy=mock.Mock()) parameters = { "src_uuid_hypervisor": "server1", "dst_uuid_hypervisor": "server2", } solution.add_action(action_type="migrate", resource_id="b199db0c-1408-4d52-b5a5-5ca14de0ff36", input_parameters=parameters) solution.add_action(action_type="nop", resource_id="", input_parameters={}) with mock.patch.object( pbase.DefaultPlanner, "create_action", wraps=default_planner.create_action) as m_create_action: action_plan = default_planner.schedule( self.context, audit.id, solution ) self.assertIsNotNone(action_plan.uuid) self.assertEqual(2, m_create_action.call_count) # check order filters = {'action_plan_id': action_plan.id} actions = objects.Action.dbapi.get_action_list(self.context, filters) self.assertEqual("nop", actions[0].action_type) self.assertEqual("migrate", actions[1].action_type)
def test_many_without_soft_deleted(self): audit_template_list = [] for id_ in [1, 2, 3]: audit_template = obj_utils.create_test_audit_template( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit Template {0}'.format(id_)) audit_template_list.append(audit_template.uuid) for id_ in [4, 5]: audit_template = obj_utils.create_test_audit_template( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit Template {0}'.format(id_)) audit_template.soft_delete() response = self.get_json('/audit_templates') self.assertEqual(3, len(response['audit_templates'])) uuids = [s['uuid'] for s in response['audit_templates']] self.assertEqual(sorted(audit_template_list), sorted(uuids))
def test_delete_audit_template_not_found(self): uuid = utils.generate_uuid() response = self.delete( '/audit_templates/%s' % uuid, expect_errors=True) self.assertEqual(404, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message'])
def test_many_without_soft_deleted(self): goal_list = [] for id_ in [1, 2, 3]: goal = obj_utils.create_test_goal( self.context, id=id_, uuid=utils.generate_uuid(), name='GOAL_{0}'.format(id_)) goal_list.append(goal.uuid) for id_ in [4, 5]: goal = obj_utils.create_test_goal( self.context, id=id_, uuid=utils.generate_uuid(), name='GOAL_{0}'.format(id_)) goal.soft_delete() response = self.get_json('/goals') self.assertEqual(3, len(response['goals'])) uuids = [s['uuid'] for s in response['goals']] self.assertEqual(sorted(goal_list), sorted(uuids))
def test_many_with_soft_deleted(self): audit_list = [] for id_ in [1, 2, 3]: audit = obj_utils.create_test_audit( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit {0}'.format(id_)) audit_list.append(audit.uuid) for id_ in [4, 5]: audit = obj_utils.create_test_audit( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit {0}'.format(id_)) audit.soft_delete() audit_list.append(audit.uuid) response = self.get_json('/audits', headers={'X-Show-Deleted': 'True'}) self.assertEqual(5, len(response['audits'])) uuids = [s['uuid'] for s in response['audits']] self.assertEqual(sorted(audit_list), sorted(uuids))
def test_watcher_non_live_migrate_instance_volume(self, mock_glance, mock_cinder, mock_neutron, mock_nova): nova_util = nova_helper.NovaHelper() nova_servers = nova_util.nova.servers instance = self.fake_server(self.instance_uuid) setattr(instance, 'OS-EXT-SRV-ATTR:host', self.source_node) setattr(instance, 'OS-EXT-STS:vm_state', "stopped") attached_volumes = [{'id': str(utils.generate_uuid())}] setattr(instance, "os-extended-volumes:volumes_attached", attached_volumes) self.fake_nova_find_list(nova_util, find=instance, list=instance) nova_servers.create_image.return_value = utils.generate_uuid() nova_util.glance.images.get.return_value = mock.MagicMock( status='active') nova_util.cinder.volumes.get.return_value = mock.MagicMock( status='available') is_success = nova_util.watcher_non_live_migrate_instance( self.instance_uuid, self.destination_node) self.assertTrue(is_success)
def test_trigger_audit(self, mock_collector): mock_collector.return_value = FakerModelCollector() audit_uuid = utils.generate_uuid() audit_handler = DefaultAuditHandler(mock.MagicMock()) endpoint = AuditEndpoint(audit_handler, max_workers=2) with mock.patch.object(DefaultAuditHandler, 'execute') \ as mock_call: mock_call.return_value = 0 endpoint.trigger_audit(audit_handler, audit_uuid) mock_call.assert_called_once_with(audit_uuid, audit_handler)
def fake_instance(**kwargs): instance = mock.MagicMock(spec=novaclient.v2.servers.Server) instance.id = kwargs.get('id', utils.generate_uuid()) instance.status = kwargs.get('status', 'ACTIVE') instance.tenant_id = kwargs.get('project_id', None) instance.flavor = {'id': kwargs.get('flavor_id', None)} setattr(instance, 'OS-EXT-SRV-ATTR:host', kwargs.get('host')) setattr(instance, 'created_at', kwargs.get('created_at', '1977-01-01T00:00:00')) setattr(instance, 'OS-EXT-STS:vm_state', kwargs.get('state', 'active')) return instance
def test_replace_non_existent_action_plan_denied(self): response = self.patch_json( '/action_plans/%s' % utils.generate_uuid(), [{ 'path': '/state', 'value': objects.action_plan.State.PENDING, 'op': 'replace' }], expect_errors=True) self.assertEqual(404, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message'])
def test_collection_links(self): for id_ in range(5): obj_utils.create_test_audit_template( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit Template {0}'.format(id_)) response = self.get_json('/audit_templates/?limit=3') self.assertEqual(3, len(response['audit_templates'])) next_marker = response['audit_templates'][-1]['uuid'] self.assertIn(next_marker, response['next'])
def test_get_action_plan_list(self): 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) action_plan_uuids = [ap.uuid for ap in action_plans] self.assertEqual(sorted(uuids), sorted(action_plan_uuids)) for action_plan in action_plans: self.assertIsNone(action_plan.audit) self.assertIsNone(action_plan.strategy)
def create_action(self, values): # ensure defaults are present for new actions if not values.get('uuid'): values['uuid'] = utils.generate_uuid() action = models.Action() action.update(values) try: action.save() except db_exc.DBDuplicateEntry: raise exception.ActionAlreadyExists(uuid=values['uuid']) return action
def test_create_audit_template_with_invalid_goal(self): with mock.patch.object( self.dbapi, 'create_audit_template', wraps=self.dbapi.create_audit_template ) as cn_mock: audit_template_dict = post_get_test_audit_template( goal_uuid=utils.generate_uuid()) response = self.post_json('/audit_templates', audit_template_dict, expect_errors=True) self.assertEqual(400, response.status_int) assert not cn_mock.called
def test_get_audit_list(self): uuids = [] for id_ in range(1, 4): audit = utils.create_test_audit(uuid=w_utils.generate_uuid(), name='My Audit {0}'.format(id_)) uuids.append(six.text_type(audit['uuid'])) audits = self.dbapi.get_audit_list(self.context) audit_uuids = [a.uuid for a in audits] self.assertEqual(sorted(uuids), sorted(audit_uuids)) for audit in audits: self.assertIsNone(audit.goal) self.assertIsNone(audit.strategy)
def test_links(self): uuid = utils.generate_uuid() obj_utils.create_action_plan_without_audit(self.context, id=1, uuid=uuid) response = self.get_json('/action_plans/%s' % uuid) self.assertIn('links', response.keys()) self.assertEqual(2, len(response['links'])) self.assertIn(uuid, response['links'][0]['href']) for l in response['links']: bookmark = l['rel'] == 'bookmark' self.assertTrue(self.validate_link(l['href'], bookmark=bookmark))
def test_collection_links_default_limit(self): cfg.CONF.set_override('max_limit', 3, 'api') for id_ in range(5): obj_utils.create_test_audit(self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit {0}'.format(id_)) response = self.get_json('/audits') self.assertEqual(3, len(response['audits'])) next_marker = response['audits'][-1]['uuid'] self.assertIn(next_marker, response['next'])
def test_many_with_parents(self): action_list = [] for id_ in range(5): if id_ > 0: action = obj_utils.create_test_action( self.context, id=id_, uuid=utils.generate_uuid(), parents=[action_list[id_ - 1]]) else: action = obj_utils.create_test_action( self.context, id=id_, uuid=utils.generate_uuid(), parents=[]) action_list.append(action.uuid) response = self.get_json('/actions') response_actions = response['actions'] for id_ in range(4): self.assertEqual(response_actions[id_]['uuid'], response_actions[id_ + 1]['parents'][0])
def _create_action_plan(self, context, audit_id): action_plan_dict = { 'uuid': utils.generate_uuid(), 'audit_id': audit_id, 'first_action_id': None, 'state': objects.action_plan.State.RECOMMENDED } new_action_plan = objects.ActionPlan(context, **action_plan_dict) new_action_plan.create(context) new_action_plan.save() return new_action_plan
def test_filter_by_strategy_name(self): for id_, strategy_id in enumerate(itertools.chain.from_iterable([ itertools.repeat(self.fake_strategy1.id, 3), itertools.repeat(self.fake_strategy2.id, 2)]), 1): obj_utils.create_test_audit_template( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit Template {0}'.format(id_), strategy_id=strategy_id) response = self.get_json( '/audit_templates?strategy=%s' % self.fake_strategy2.name) self.assertEqual(2, len(response['audit_templates']))
def test_replace_non_existent_audit_template(self): response = self.patch_json('/audit_templates/%s' % utils.generate_uuid(), [{ 'path': '/goal', 'value': self.fake_goal1.uuid, 'op': 'replace' }], expect_errors=True) self.assertEqual(404, response.status_int) self.assertEqual('application/json', response.content_type) self.assertTrue(response.json['error_message'])
def test_many_with_soft_deleted_audit_uuid(self): action_plan_list = [] audit1 = obj_utils.create_test_audit(self.context, id=2, uuid=utils.generate_uuid(), name='My Audit {0}'.format(2)) audit2 = obj_utils.create_test_audit(self.context, id=3, uuid=utils.generate_uuid(), name='My Audit {0}'.format(3)) for id_ in range(0, 2): action_plan = obj_utils.create_test_action_plan( self.context, id=id_, uuid=utils.generate_uuid(), audit_id=audit1.id) action_plan_list.append(action_plan.uuid) for id_ in range(2, 4): action_plan = obj_utils.create_test_action_plan( self.context, id=id_, uuid=utils.generate_uuid(), audit_id=audit2.id) action_plan_list.append(action_plan.uuid) self.delete('/audits/%s' % audit1.uuid) response = self.get_json('/action_plans') self.assertEqual(len(action_plan_list), len(response['action_plans'])) for id_ in range(0, 2): action_plan = response['action_plans'][id_] self.assertIsNone(action_plan['audit_uuid']) for id_ in range(2, 4): action_plan = response['action_plans'][id_] self.assertEqual(audit2.uuid, action_plan['audit_uuid'])
def test_filter_by_audit_uuid(self): audit = obj_utils.create_test_audit(self.context, uuid=utils.generate_uuid()) action_plan_1 = obj_utils.create_test_action_plan( self.context, uuid=utils.generate_uuid(), audit_id=audit.id) action_list = [] for id_ in range(3): action = obj_utils.create_test_action( self.context, id=id_, action_plan_id=action_plan_1.id, uuid=utils.generate_uuid()) action_list.append(action.uuid) audit2 = obj_utils.create_test_audit(self.context, uuid=utils.generate_uuid()) action_plan_2 = obj_utils.create_test_action_plan( self.context, uuid=utils.generate_uuid(), audit_id=audit2.id) for id_ in range(4, 5, 6): obj_utils.create_test_action(self.context, id=id_, action_plan_id=action_plan_2.id, uuid=utils.generate_uuid()) response = self.get_json('/actions?audit_uuid=%s' % audit.uuid) self.assertEqual(len(action_list), len(response['actions'])) for action in response['actions']: self.assertEqual(action_plan_1.uuid, action['action_plan_uuid'])
def fake_volume(**kwargs): volume = mock.MagicMock(spec=cinderclient.v2.volumes.Volume) volume.id = kwargs.get('id', utils.generate_uuid()) volume.status = kwargs.get('status', 'available') tenant_id = kwargs.get('project_id', None) setattr(volume, 'os-vol-tenant-attr:tenant_id', tenant_id) setattr(volume, 'os-vol-host-attr:host', kwargs.get('host')) setattr(volume, 'size', kwargs.get('size', '1')) setattr(volume, 'created_at', kwargs.get('created_at', '1977-01-01T00:00:00')) volume.volume_type = kwargs.get('volume_type', 'type1') return volume
def create_strategy(self, values): # ensure defaults are present for new strategies if not values.get('uuid'): values['uuid'] = utils.generate_uuid() strategy = models.Strategy() strategy.update(values) try: strategy.save() except db_exc.DBDuplicateEntry: raise exception.StrategyAlreadyExists(uuid=values['uuid']) return strategy
def create_efficacy_indicator(self, values): # ensure defaults are present for new efficacy indicators if not values.get('uuid'): values['uuid'] = utils.generate_uuid() efficacy_indicator = models.EfficacyIndicator() efficacy_indicator.update(values) try: efficacy_indicator.save() except db_exc.DBDuplicateEntry: raise exception.EfficacyIndicatorAlreadyExists(uuid=values['uuid']) return efficacy_indicator
def test_get_scoring_engine_list(self): names = [] for i in range(1, 6): scoring_engine = utils.create_test_scoring_engine( id=i, uuid=w_utils.generate_uuid(), name="SE_ID_%s" % i, description='My ScoringEngine {0}'.format(i), metainfo='a{0}=b{0}'.format(i)) names.append(six.text_type(scoring_engine['name'])) res = self.dbapi.get_scoring_engine_list(self.context) res_names = [r.name for r in res] self.assertEqual(names.sort(), res_names.sort())
def create_goal(self, values): # ensure defaults are present for new goals if not values.get('uuid'): values['uuid'] = utils.generate_uuid() goal = models.Goal() goal.update(values) try: goal.save() except db_exc.DBDuplicateEntry: raise exception.GoalAlreadyExists(uuid=values['uuid']) return goal
def test_many(self): audit_list = [] for id_ in range(5): audit = obj_utils.create_test_audit( self.context, id=id_, uuid=utils.generate_uuid(), name='My Audit {0}'.format(id_)) audit_list.append(audit.uuid) response = self.get_json('/audits') self.assertEqual(len(audit_list), len(response['audits'])) uuids = [s['uuid'] for s in response['audits']] self.assertEqual(sorted(audit_list), sorted(uuids))
def test_get_audit_list_with_filter_by_audit_template_name(self): audit_template = self.dbapi.create_audit_template( utils.get_test_audit_template( uuid=w_utils.generate_uuid(), name='My Audit Template 1', description='Description of my audit template 1', host_aggregate=5, goal='DUMMY', extra={'automatic': True})) audit = self._create_test_audit(type='ONESHOT', uuid=w_utils.generate_uuid(), deadline=None, state='ONGOING', audit_template_id=audit_template.id) res = self.dbapi.get_audit_list( self.context, filters={'audit_template_name': audit_template.name}) for r in res: self.assertEqual(audit['audit_template_id'], r.audit_template_id)
def test_stop_instance(self, mock_glance, mock_cinder, mock_neutron, mock_nova): nova_util = nova_helper.NovaHelper() instance_id = utils.generate_uuid() server = mock.MagicMock() server.id = instance_id setattr(server, 'OS-EXT-STS:vm_state', 'stopped') nova_util.nova.servers = mock.MagicMock() nova_util.nova.servers.find.return_value = server nova_util.nova.servers.list.return_value = [server] result = nova_util.stop_instance(instance_id) self.assertEqual(result, True)
def test_many_without_soft_deleted(self): scoring_engine_list = [] for id_ in [1, 2, 3]: scoring_engine = obj_utils.create_test_scoring_engine( self.context, id=id_, uuid=utils.generate_uuid(), name=str(id_), description='SE_{0}'.format(id_)) scoring_engine_list.append(scoring_engine.name) for id_ in [4, 5]: scoring_engine = obj_utils.create_test_scoring_engine( self.context, id=id_, uuid=utils.generate_uuid(), name=str(id_), description='SE_{0}'.format(id_)) scoring_engine.soft_delete() response = self.get_json('/scoring_engines') self.assertEqual(3, len(response['scoring_engines'])) names = [s['name'] for s in response['scoring_engines']] self.assertEqual(sorted(scoring_engine_list), sorted(names))
def test_collection_links(self): next = -1 for id_ in range(5): action = obj_utils.create_test_action(self.context, id=id_, uuid=utils.generate_uuid(), next=next) next = action.id response = self.get_json('/actions/?limit=3') self.assertEqual(3, len(response['actions'])) next_marker = response['actions'][-1]['uuid'] self.assertIn(next_marker, response['next'])
def test_many_with_next_uuid(self): action_list = [] for id_ in range(5): action = obj_utils.create_test_action(self.context, id=id_, uuid=utils.generate_uuid(), next=id_ + 1) action_list.append(action.uuid) response = self.get_json('/actions') response_actions = response['actions'] for id in [0, 1, 2, 3]: self.assertEqual(response_actions[id]['next_uuid'], response_actions[id + 1]['uuid'])
def create_action(self, values): # ensure defaults are present for new actions if not values.get('uuid'): values['uuid'] = utils.generate_uuid() if values.get('state') is None: values['state'] = objects.action.State.PENDING try: action = self._create(models.Action, values) except db_exc.DBDuplicateEntry: raise exception.ActionAlreadyExists(uuid=values['uuid']) return action