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
