openstack
/
watcher
Code Issues Proposed changes

Merge "Replace of private _create methods in tests"

This commit is contained in:
Zuul 2018-05-09 08:20:36 +00:00 committed by Gerrit Code Review
parent 7d62175b23 415bab4bc9
commit 00aa77651b
10 changed files with 103 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
watcher/tests/db/test_action.py
View File

@ -233,16 +233,6 @@ class TestDbActionFilters(base.DbTestCase):
class DbActionTestCase(base.DbTestCase):
def _create_test_action(self, **kwargs):
action = utils.get_test_action(**kwargs)
self.dbapi.create_action(action)
return action
def _create_test_action_plan(self, **kwargs):
action_plan = utils.get_test_action_plan(**kwargs)
self.dbapi.create_action_plan(action_plan)
return action_plan
def test_get_action_list(self):
uuids = []
for _ in range(1, 4):
@ -274,33 +264,35 @@ class DbActionTestCase(base.DbTestCase):
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(
action_plan = utils.create_test_action_plan(
id=1,
uuid=w_utils.generate_uuid(),
audit_id=audit.id,
parents=None,
state=objects.action_plan.State.RECOMMENDED)
action1 = self._create_test_action(
action1 = utils.create_test_action(
id=1,
action_plan_id=1,
description='description action 1',
uuid=w_utils.generate_uuid(),
parents=None,
state=objects.action_plan.State.PENDING)
action2 = self._create_test_action(
action2 = utils.create_test_action(
id=2,
action_plan_id=2,
description='description action 2',
uuid=w_utils.generate_uuid(),
parents=[action1['uuid']],
state=objects.action_plan.State.PENDING)
action3 = self._create_test_action(
action3 = utils.create_test_action(
id=3,
action_plan_id=1,
description='description action 3',
uuid=w_utils.generate_uuid(),
parents=[action2['uuid']],
state=objects.action_plan.State.ONGOING)
res = self.dbapi.get_action_list(
self.context,
filters={'state': objects.action_plan.State.ONGOING})
@ -329,7 +321,7 @@ class DbActionTestCase(base.DbTestCase):
self.assertEqual(action_plan['id'], action.action_plan_id)
def test_get_action_list_with_filter_by_uuid(self):
action = self._create_test_action()
action = utils.create_test_action()
res = self.dbapi.get_action_list(
self.context, filters={'uuid': action["uuid"]})
@ -337,12 +329,12 @@ class DbActionTestCase(base.DbTestCase):
self.assertEqual(action['uuid'], res[0].uuid)
def test_get_action_by_id(self):
action = self._create_test_action()
action = utils.create_test_action()
action = self.dbapi.get_action_by_id(self.context, action['id'])
self.assertEqual(action['uuid'], action.uuid)
def test_get_action_by_uuid(self):
action = self._create_test_action()
action = utils.create_test_action()
action = self.dbapi.get_action_by_uuid(self.context, action['uuid'])
self.assertEqual(action['id'], action.id)
@ -351,7 +343,7 @@ class DbActionTestCase(base.DbTestCase):
self.dbapi.get_action_by_id, self.context, 1234)
def test_update_action(self):
action = self._create_test_action()
action = utils.create_test_action()
res = self.dbapi.update_action(
action['id'], {'state': objects.action_plan.State.CANCELLED})
self.assertEqual(objects.action_plan.State.CANCELLED, res.state)
@ -361,13 +353,13 @@ class DbActionTestCase(base.DbTestCase):
self.dbapi.update_action, 1234, {'state': ''})
def test_update_action_uuid(self):
action = self._create_test_action()
action = utils.create_test_action()
self.assertRaises(exception.Invalid,
self.dbapi.update_action, action['id'],
{'uuid': 'hello'})
def test_destroy_action(self):
action = self._create_test_action()
action = utils.create_test_action()
self.dbapi.destroy_action(action['id'])
self.assertRaises(exception.ActionNotFound,
self.dbapi.get_action_by_id,
@ -375,7 +367,7 @@ class DbActionTestCase(base.DbTestCase):
def test_destroy_action_by_uuid(self):
uuid = w_utils.generate_uuid()
self._create_test_action(uuid=uuid)
utils.create_test_action(uuid=uuid)
self.assertIsNotNone(self.dbapi.get_action_by_uuid(self.context,
uuid))
self.dbapi.destroy_action(uuid)
@ -388,7 +380,7 @@ class DbActionTestCase(base.DbTestCase):
def test_create_action_already_exists(self):
uuid = w_utils.generate_uuid()
self._create_test_action(id=1, uuid=uuid)
utils.create_test_action(id=1, uuid=uuid)
self.assertRaises(exception.ActionAlreadyExists,
self._create_test_action,
utils.create_test_action,
id=2, uuid=uuid)

13
watcher/tests/db/test_action_description.py
View File

@ -232,11 +232,6 @@ class TestDbActionDescriptionFilters(base.DbTestCase):
class DbActionDescriptionTestCase(base.DbTestCase):
def _create_test_action_desc(self, **kwargs):
action_desc = utils.get_test_action_desc(**kwargs)
self.dbapi.create_action_description(action_desc)
return action_desc
def test_get_action_desc_list(self):
ids = []
for i in range(1, 4):
@ -250,12 +245,12 @@ class DbActionDescriptionTestCase(base.DbTestCase):
self.assertEqual(sorted(ids), sorted(action_desc_ids))
def test_get_action_desc_list_with_filters(self):
action_desc1 = self._create_test_action_desc(
action_desc1 = utils.create_test_action_desc(
id=1,
action_type="action_1",
description="description_1",
)
action_desc2 = self._create_test_action_desc(
action_desc2 = utils.create_test_action_desc(
id=2,
action_type="action_2",
description="description_2",
@ -275,7 +270,7 @@ class DbActionDescriptionTestCase(base.DbTestCase):
self.assertEqual([action_desc2['id']], [r.id for r in res])
def test_get_action_desc_by_type(self):
created_action_desc = self._create_test_action_desc()
created_action_desc = utils.create_test_action_desc()
action_desc = self.dbapi.get_action_description_by_type(
self.context, created_action_desc['action_type'])
self.assertEqual(action_desc.action_type,
@ -287,7 +282,7 @@ class DbActionDescriptionTestCase(base.DbTestCase):
self.context, 404)
def test_update_action_desc(self):
action_desc = self._create_test_action_desc()
action_desc = utils.create_test_action_desc()
res = self.dbapi.update_action_description(
action_desc['id'], {'description': 'description_test'})
self.assertEqual('description_test', res.description)

36
watcher/tests/db/test_action_plan.py
View File

@ -230,16 +230,6 @@ class TestDbActionPlanFilters(base.DbTestCase):
class DbActionPlanTestCase(base.DbTestCase):
def _create_test_audit(self, **kwargs):
audit = utils.get_test_audit(**kwargs)
self.dbapi.create_audit(audit)
return audit
def _create_test_action_plan(self, **kwargs):
action_plan = utils.get_test_action_plan(**kwargs)
self.dbapi.create_action_plan(action_plan)
return action_plan
def test_get_action_plan_list(self):
uuids = []
for _ in range(1, 4):
@ -274,17 +264,17 @@ class DbActionPlanTestCase(base.DbTestCase):
self.assertEqual(audit.as_dict(), eager_action_plan.audit.as_dict())
def test_get_action_plan_list_with_filters(self):
audit = self._create_test_audit(
audit = utils.create_test_audit(
id=2,
audit_type='ONESHOT',
uuid=w_utils.generate_uuid(),
state=ap_objects.State.ONGOING)
action_plan1 = self._create_test_action_plan(
action_plan1 = utils.create_test_action_plan(
id=1,
uuid=w_utils.generate_uuid(),
audit_id=audit['id'],
state=ap_objects.State.RECOMMENDED)
action_plan2 = self._create_test_action_plan(
action_plan2 = utils.create_test_action_plan(
id=2,
uuid=w_utils.generate_uuid(),
audit_id=audit['id'],
@ -316,7 +306,7 @@ class DbActionPlanTestCase(base.DbTestCase):
self.assertNotEqual([action_plan1['id']], [r.id for r in res])
def test_get_action_plan_list_with_filter_by_uuid(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
res = self.dbapi.get_action_plan_list(
self.context, filters={'uuid': action_plan["uuid"]})
@ -324,13 +314,13 @@ class DbActionPlanTestCase(base.DbTestCase):
self.assertEqual(action_plan['uuid'], res[0].uuid)
def test_get_action_plan_by_id(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
action_plan = self.dbapi.get_action_plan_by_id(
self.context, action_plan['id'])
self.assertEqual(action_plan['uuid'], action_plan.uuid)
def test_get_action_plan_by_uuid(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
action_plan = self.dbapi.get_action_plan_by_uuid(
self.context, action_plan['uuid'])
self.assertEqual(action_plan['id'], action_plan.id)
@ -340,7 +330,7 @@ class DbActionPlanTestCase(base.DbTestCase):
self.dbapi.get_action_plan_by_id, self.context, 1234)
def test_update_action_plan(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
res = self.dbapi.update_action_plan(
action_plan['id'], {'name': 'updated-model'})
self.assertEqual('updated-model', res.name)
@ -350,13 +340,13 @@ class DbActionPlanTestCase(base.DbTestCase):
self.dbapi.update_action_plan, 1234, {'name': ''})
def test_update_action_plan_uuid(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
self.assertRaises(exception.Invalid,
self.dbapi.update_action_plan, action_plan['id'],
{'uuid': 'hello'})
def test_destroy_action_plan(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
self.dbapi.destroy_action_plan(action_plan['id'])
self.assertRaises(exception.ActionPlanNotFound,
self.dbapi.get_action_plan_by_id,
@ -364,7 +354,7 @@ class DbActionPlanTestCase(base.DbTestCase):
def test_destroy_action_plan_by_uuid(self):
uuid = w_utils.generate_uuid()
self._create_test_action_plan(uuid=uuid)
utils.create_test_action_plan(uuid=uuid)
self.assertIsNotNone(self.dbapi.get_action_plan_by_uuid(
self.context, uuid))
self.dbapi.destroy_action_plan(uuid)
@ -377,7 +367,7 @@ class DbActionPlanTestCase(base.DbTestCase):
self.dbapi.destroy_action_plan, 1234)
def test_destroy_action_plan_that_referenced_by_actions(self):
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
action = utils.create_test_action(action_plan_id=action_plan['id'])
self.assertEqual(action_plan['id'], action.action_plan_id)
self.assertRaises(exception.ActionPlanReferenced,
@ -385,7 +375,7 @@ class DbActionPlanTestCase(base.DbTestCase):
def test_create_action_plan_already_exists(self):
uuid = w_utils.generate_uuid()
self._create_test_action_plan(id=1, uuid=uuid)
utils.create_test_action_plan(id=1, uuid=uuid)
self.assertRaises(exception.ActionPlanAlreadyExists,
self._create_test_action_plan,
utils.create_test_action_plan,
id=2, uuid=uuid)

29
watcher/tests/db/test_audit.py
View File

@ -265,11 +265,6 @@ class TestDbAuditFilters(base.DbTestCase):
class DbAuditTestCase(base.DbTestCase):
def _create_test_audit(self, **kwargs):
audit = utils.get_test_audit(**kwargs)
self.dbapi.create_audit(audit)
return audit
def test_get_audit_list(self):
uuids = []
for id_ in range(1, 4):
@ -304,13 +299,13 @@ class DbAuditTestCase(base.DbTestCase):
self.assertEqual(strategy.as_dict(), eager_audit.strategy.as_dict())
def test_get_audit_list_with_filters(self):
audit1 = self._create_test_audit(
audit1 = utils.create_test_audit(
id=1,
audit_type=objects.audit.AuditType.ONESHOT.value,
uuid=w_utils.generate_uuid(),
name='My Audit {0}'.format(1),
state=objects.audit.State.ONGOING)
audit2 = self._create_test_audit(
audit2 = utils.create_test_audit(
id=2,
audit_type='CONTINUOUS',
uuid=w_utils.generate_uuid(),
@ -336,7 +331,7 @@ class DbAuditTestCase(base.DbTestCase):
self.assertEqual([audit2['id']], [r.id for r in res])
def test_get_audit_list_with_filter_by_uuid(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
res = self.dbapi.get_audit_list(
self.context, filters={'uuid': audit["uuid"]})
@ -344,12 +339,12 @@ class DbAuditTestCase(base.DbTestCase):
self.assertEqual(audit['uuid'], res[0].uuid)
def test_get_audit_by_id(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
audit = self.dbapi.get_audit_by_id(self.context, audit['id'])
self.assertEqual(audit['uuid'], audit.uuid)
def test_get_audit_by_uuid(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
audit = self.dbapi.get_audit_by_uuid(self.context, audit['uuid'])
self.assertEqual(audit['id'], audit.id)
@ -358,7 +353,7 @@ class DbAuditTestCase(base.DbTestCase):
self.dbapi.get_audit_by_id, self.context, 1234)
def test_update_audit(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
res = self.dbapi.update_audit(audit['id'], {'name': 'updated-model'})
self.assertEqual('updated-model', res.name)
@ -367,20 +362,20 @@ class DbAuditTestCase(base.DbTestCase):
self.dbapi.update_audit, 1234, {'name': ''})
def test_update_audit_uuid(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
self.assertRaises(exception.Invalid,
self.dbapi.update_audit, audit['id'],
{'uuid': 'hello'})
def test_destroy_audit(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
self.dbapi.destroy_audit(audit['id'])
self.assertRaises(exception.AuditNotFound,
self.dbapi.get_audit_by_id,
self.context, audit['id'])
def test_destroy_audit_by_uuid(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
self.assertIsNotNone(self.dbapi.get_audit_by_uuid(self.context,
audit['uuid']))
self.dbapi.destroy_audit(audit['uuid'])
@ -393,7 +388,7 @@ class DbAuditTestCase(base.DbTestCase):
self.dbapi.destroy_audit, 1234)
def test_destroy_audit_that_referenced_by_action_plans(self):
audit = self._create_test_audit()
audit = utils.create_test_audit()
action_plan = utils.create_test_action_plan(audit_id=audit['id'])
self.assertEqual(audit['id'], action_plan.audit_id)
self.assertRaises(exception.AuditReferenced,
@ -401,9 +396,9 @@ class DbAuditTestCase(base.DbTestCase):
def test_create_audit_already_exists(self):
uuid = w_utils.generate_uuid()
self._create_test_audit(id=1, uuid=uuid)
utils.create_test_audit(id=1, uuid=uuid)
self.assertRaises(exception.AuditAlreadyExists,
self._create_test_audit,
utils.create_test_audit,
id=2, uuid=uuid)
def test_create_same_name_audit(self):

34
watcher/tests/db/test_audit_template.py
View File

@ -225,16 +225,6 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
class DbAuditTemplateTestCase(base.DbTestCase):
def _create_test_goal(self, **kwargs):
goal = utils.get_test_goal(**kwargs)
self.dbapi.create_goal(goal)
return goal
def _create_test_audit_template(self, **kwargs):
audit_template = utils.get_test_audit_template(**kwargs)
self.dbapi.create_audit_template(audit_template)
return audit_template
def test_get_audit_template_list(self):
uuids = []
for i in range(1, 4):
@ -273,14 +263,14 @@ class DbAuditTemplateTestCase(base.DbTestCase):
strategy.as_dict(), eager_audit_template.strategy.as_dict())
def test_get_audit_template_list_with_filters(self):
goal = self._create_test_goal(name='DUMMY')
audit_template1 = self._create_test_audit_template(
goal = utils.create_test_goal(name='DUMMY')
audit_template1 = utils.create_test_audit_template(
id=1,
uuid=w_utils.generate_uuid(),
name='My Audit Template 1',
description='Description of my audit template 1',
goal_id=goal['id'])
audit_template2 = self._create_test_audit_template(
audit_template2 = utils.create_test_audit_template(
id=2,
uuid=w_utils.generate_uuid(),
name='My Audit Template 2',
@ -307,7 +297,7 @@ class DbAuditTemplateTestCase(base.DbTestCase):
self.assertEqual([audit_template2['id']], [r.id for r in res])
def test_get_audit_template_list_with_filter_by_uuid(self):
audit_template = self._create_test_audit_template()
audit_template = utils.create_test_audit_template()
res = self.dbapi.get_audit_template_list(
self.context, filters={'uuid': audit_template["uuid"]})
@ -315,13 +305,13 @@ class DbAuditTemplateTestCase(base.DbTestCase):
self.assertEqual(audit_template['uuid'], res[0].uuid)
def test_get_audit_template_by_id(self):
audit_template = self._create_test_audit_template()
audit_template = utils.create_test_audit_template()
audit_template = self.dbapi.get_audit_template_by_id(
self.context, audit_template['id'])
self.assertEqual(audit_template['uuid'], audit_template.uuid)
def test_get_audit_template_by_uuid(self):
audit_template = self._create_test_audit_template()
audit_template = utils.create_test_audit_template()
audit_template = self.dbapi.get_audit_template_by_uuid(
self.context, audit_template['uuid'])
self.assertEqual(audit_template['id'], audit_template.id)
@ -332,7 +322,7 @@ class DbAuditTemplateTestCase(base.DbTestCase):
self.context, 1234)
def test_update_audit_template(self):
audit_template = self._create_test_audit_template()
audit_template = utils.create_test_audit_template()
res = self.dbapi.update_audit_template(audit_template['id'],
{'name': 'updated-model'})
self.assertEqual('updated-model', res.name)
@ -342,14 +332,14 @@ class DbAuditTemplateTestCase(base.DbTestCase):
self.dbapi.update_audit_template, 1234, {'name': ''})
def test_update_audit_template_uuid(self):
audit_template = self._create_test_audit_template()
audit_template = utils.create_test_audit_template()
self.assertRaises(exception.Invalid,
self.dbapi.update_audit_template,
audit_template['id'],
{'uuid': 'hello'})
def test_destroy_audit_template(self):
audit_template = self._create_test_audit_template()
audit_template = utils.create_test_audit_template()
self.dbapi.destroy_audit_template(audit_template['id'])
self.assertRaises(exception.AuditTemplateNotFound,
self.dbapi.get_audit_template_by_id,
@ -357,7 +347,7 @@ class DbAuditTemplateTestCase(base.DbTestCase):
def test_destroy_audit_template_by_uuid(self):
uuid = w_utils.generate_uuid()
self._create_test_audit_template(uuid=uuid)
utils.create_test_audit_template(uuid=uuid)
self.assertIsNotNone(self.dbapi.get_audit_template_by_uuid(
self.context, uuid))
self.dbapi.destroy_audit_template(uuid)
@ -371,9 +361,9 @@ class DbAuditTemplateTestCase(base.DbTestCase):
def test_create_audit_template_already_exists(self):
uuid = w_utils.generate_uuid()
self._create_test_audit_template(id=1, uuid=uuid)
utils.create_test_audit_template(id=1, uuid=uuid)
self.assertRaises(exception.AuditTemplateAlreadyExists,
self._create_test_audit_template,
utils.create_test_audit_template,
id=2, uuid=uuid)
def test_audit_template_create_same_name(self):

39
watcher/tests/db/test_efficacy_indicator.py
View File

@ -242,20 +242,9 @@ class TestDbEfficacyIndicatorFilters(base.DbTestCase):
class DbEfficacyIndicatorTestCase(base.DbTestCase):
def _create_test_efficacy_indicator(self, **kwargs):
efficacy_indicator_dict = utils.get_test_efficacy_indicator(**kwargs)
efficacy_indicator = self.dbapi.create_efficacy_indicator(
efficacy_indicator_dict)
return efficacy_indicator
def _create_test_action_plan(self, **kwargs):
action_plan_dict = utils.get_test_action_plan(**kwargs)
action_plan = self.dbapi.create_action_plan(action_plan_dict)
return action_plan
def test_get_efficacy_indicator_list(self):
uuids = []
action_plan = self._create_test_action_plan()
action_plan = utils.create_test_action_plan()
for id_ in range(1, 4):
efficacy_indicator = utils.create_test_efficacy_indicator(
action_plan_id=action_plan.id, id=id_, uuid=None,
@ -290,27 +279,27 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
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(
action_plan = utils.create_test_action_plan(
id=1,
uuid=w_utils.generate_uuid(),
audit_id=audit.id,
first_efficacy_indicator_id=None,
state=objects.action_plan.State.RECOMMENDED)
efficacy_indicator1 = self._create_test_efficacy_indicator(
efficacy_indicator1 = utils.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(
efficacy_indicator2 = utils.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(
efficacy_indicator3 = utils.create_test_efficacy_indicator(
id=3,
name='indicator_3',
uuid=w_utils.generate_uuid(),
@ -338,7 +327,7 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
sorted([r.id for r in res]))
def test_get_efficacy_indicator_list_with_filter_by_uuid(self):
efficacy_indicator = self._create_test_efficacy_indicator()
efficacy_indicator = utils.create_test_efficacy_indicator()
res = self.dbapi.get_efficacy_indicator_list(
self.context, filters={'uuid': efficacy_indicator.uuid})
@ -346,13 +335,13 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
self.assertEqual(efficacy_indicator.uuid, res[0].uuid)
def test_get_efficacy_indicator_by_id(self):
efficacy_indicator = self._create_test_efficacy_indicator()
efficacy_indicator = utils.create_test_efficacy_indicator()
efficacy_indicator = self.dbapi.get_efficacy_indicator_by_id(
self.context, efficacy_indicator.id)
self.assertEqual(efficacy_indicator.uuid, efficacy_indicator.uuid)
def test_get_efficacy_indicator_by_uuid(self):
efficacy_indicator = self._create_test_efficacy_indicator()
efficacy_indicator = utils.create_test_efficacy_indicator()
efficacy_indicator = self.dbapi.get_efficacy_indicator_by_uuid(
self.context, efficacy_indicator.uuid)
self.assertEqual(efficacy_indicator['id'], efficacy_indicator.id)
@ -363,7 +352,7 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
self.dbapi.get_efficacy_indicator_by_id, self.context, 1234)
def test_update_efficacy_indicator(self):
efficacy_indicator = self._create_test_efficacy_indicator()
efficacy_indicator = utils.create_test_efficacy_indicator()
res = self.dbapi.update_efficacy_indicator(
efficacy_indicator.id,
{'state': objects.action_plan.State.CANCELLED})
@ -375,14 +364,14 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
self.dbapi.update_efficacy_indicator, 1234, {'state': ''})
def test_update_efficacy_indicator_uuid(self):
efficacy_indicator = self._create_test_efficacy_indicator()
efficacy_indicator = utils.create_test_efficacy_indicator()
self.assertRaises(
exception.Invalid,
self.dbapi.update_efficacy_indicator, efficacy_indicator.id,
{'uuid': 'hello'})
def test_destroy_efficacy_indicator(self):
efficacy_indicator = self._create_test_efficacy_indicator()
efficacy_indicator = utils.create_test_efficacy_indicator()
self.dbapi.destroy_efficacy_indicator(efficacy_indicator['id'])
self.assertRaises(exception.EfficacyIndicatorNotFound,
self.dbapi.get_efficacy_indicator_by_id,
@ -390,7 +379,7 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
def test_destroy_efficacy_indicator_by_uuid(self):
uuid = w_utils.generate_uuid()
self._create_test_efficacy_indicator(uuid=uuid)
utils.create_test_efficacy_indicator(uuid=uuid)
self.assertIsNotNone(self.dbapi.get_efficacy_indicator_by_uuid(
self.context, uuid))
self.dbapi.destroy_efficacy_indicator(uuid)
@ -404,7 +393,7 @@ class DbEfficacyIndicatorTestCase(base.DbTestCase):
def test_create_efficacy_indicator_already_exists(self):
uuid = w_utils.generate_uuid()
self._create_test_efficacy_indicator(id=1, uuid=uuid)
utils.create_test_efficacy_indicator(id=1, uuid=uuid)
self.assertRaises(exception.EfficacyIndicatorAlreadyExists,
self._create_test_efficacy_indicator,
utils.create_test_efficacy_indicator,
id=2, uuid=uuid)

21
watcher/tests/db/test_goal.py
View File

@ -223,11 +223,6 @@ class TestDbGoalFilters(base.DbTestCase):
class DbGoalTestCase(base.DbTestCase):
def _create_test_goal(self, **kwargs):
goal = utils.get_test_goal(**kwargs)
self.dbapi.create_goal(goal)
return goal
def test_get_goal_list(self):
uuids = []
for i in range(1, 4):
@ -242,13 +237,13 @@ class DbGoalTestCase(base.DbTestCase):
self.assertEqual(sorted(uuids), sorted(goal_uuids))
def test_get_goal_list_with_filters(self):
goal1 = self._create_test_goal(
goal1 = utils.create_test_goal(
id=1,
uuid=w_utils.generate_uuid(),
name="GOAL_1",
display_name='Goal 1',
)
goal2 = self._create_test_goal(
goal2 = utils.create_test_goal(
id=2,
uuid=w_utils.generate_uuid(),
name="GOAL_2",
@ -277,7 +272,7 @@ class DbGoalTestCase(base.DbTestCase):
"schema": "Range(min=0, max=100, min_included=True, "
"max_included=True, msg=None)",
"description": "Dummy indicator"}]
created_goal = self._create_test_goal(
created_goal = utils.create_test_goal(
efficacy_specification=efficacy_spec)
goal = self.dbapi.get_goal_by_uuid(self.context, created_goal['uuid'])
self.assertEqual(goal.uuid, created_goal['uuid'])
@ -289,13 +284,13 @@ class DbGoalTestCase(base.DbTestCase):
self.context, random_uuid)
def test_update_goal(self):
goal = self._create_test_goal()
goal = utils.create_test_goal()
res = self.dbapi.update_goal(goal['uuid'],
{'display_name': 'updated-model'})
self.assertEqual('updated-model', res.display_name)
def test_update_goal_id(self):
goal = self._create_test_goal()
goal = utils.create_test_goal()
self.assertRaises(exception.Invalid,
self.dbapi.update_goal, goal['uuid'],
{'uuid': 'NEW_GOAL'})
@ -308,7 +303,7 @@ class DbGoalTestCase(base.DbTestCase):
{'display_name': ''})
def test_destroy_goal(self):
goal = self._create_test_goal()
goal = utils.create_test_goal()
self.dbapi.destroy_goal(goal['uuid'])
self.assertRaises(exception.GoalNotFound,
self.dbapi.get_goal_by_uuid,
@ -321,7 +316,7 @@ class DbGoalTestCase(base.DbTestCase):
def test_create_goal_already_exists(self):
goal_uuid = w_utils.generate_uuid()
self._create_test_goal(uuid=goal_uuid)
utils.create_test_goal(uuid=goal_uuid)
self.assertRaises(exception.GoalAlreadyExists,
self._create_test_goal,
utils.create_test_goal,
uuid=goal_uuid)

25
watcher/tests/db/test_scoring_engine.py
View File

@ -228,11 +228,6 @@ class TestDbScoringEngineFilters(base.DbTestCase):
class DbScoringEngineTestCase(base.DbTestCase):
def _create_test_scoring_engine(self, **kwargs):
scoring_engine = utils.get_test_scoring_engine(**kwargs)
self.dbapi.create_scoring_engine(scoring_engine)
return scoring_engine
def test_get_scoring_engine_list(self):
names = []
for i in range(1, 4):
@ -248,14 +243,14 @@ class DbScoringEngineTestCase(base.DbTestCase):
self.assertEqual(sorted(names), sorted(scoring_engines_names))
def test_get_scoring_engine_list_with_filters(self):
scoring_engine1 = self._create_test_scoring_engine(
scoring_engine1 = utils.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(
scoring_engine2 = utils.create_test_scoring_engine(
id=2,
uuid=w_utils.generate_uuid(),
name="SE_ID_2",
@ -277,19 +272,19 @@ class DbScoringEngineTestCase(base.DbTestCase):
self.assertEqual([scoring_engine2['name']], [r.name for r in res])
def test_get_scoring_engine_by_id(self):
created_scoring_engine = self._create_test_scoring_engine()
created_scoring_engine = utils.create_test_scoring_engine()
scoring_engine = self.dbapi.get_scoring_engine_by_id(
self.context, created_scoring_engine['id'])
self.assertEqual(scoring_engine.id, created_scoring_engine['id'])
def test_get_scoring_engine_by_uuid(self):
created_scoring_engine = self._create_test_scoring_engine()
created_scoring_engine = utils.create_test_scoring_engine()
scoring_engine = self.dbapi.get_scoring_engine_by_uuid(
self.context, created_scoring_engine['uuid'])
self.assertEqual(scoring_engine.uuid, created_scoring_engine['uuid'])
def test_get_scoring_engine_by_name(self):
created_scoring_engine = self._create_test_scoring_engine()
created_scoring_engine = utils.create_test_scoring_engine()
scoring_engine = self.dbapi.get_scoring_engine_by_name(
self.context, created_scoring_engine['name'])
self.assertEqual(scoring_engine.name, created_scoring_engine['name'])
@ -300,13 +295,13 @@ class DbScoringEngineTestCase(base.DbTestCase):
self.context, 404)
def test_update_scoring_engine(self):
scoring_engine = self._create_test_scoring_engine()
scoring_engine = utils.create_test_scoring_engine()
res = self.dbapi.update_scoring_engine(
scoring_engine['id'], {'description': 'updated-model'})
self.assertEqual('updated-model', res.description)
def test_update_scoring_engine_id(self):
scoring_engine = self._create_test_scoring_engine()
scoring_engine = utils.create_test_scoring_engine()
self.assertRaises(exception.Invalid,
self.dbapi.update_scoring_engine,
scoring_engine['id'],
@ -319,7 +314,7 @@ class DbScoringEngineTestCase(base.DbTestCase):
{'description': ''})
def test_destroy_scoring_engine(self):
scoring_engine = self._create_test_scoring_engine()
scoring_engine = utils.create_test_scoring_engine()
self.dbapi.destroy_scoring_engine(scoring_engine['id'])
self.assertRaises(exception.ScoringEngineNotFound,
self.dbapi.get_scoring_engine_by_id,
@ -331,7 +326,7 @@ class DbScoringEngineTestCase(base.DbTestCase):
def test_create_scoring_engine_already_exists(self):
scoring_engine_id = "SE_ID"
self._create_test_scoring_engine(name=scoring_engine_id)
utils.create_test_scoring_engine(name=scoring_engine_id)
self.assertRaises(exception.ScoringEngineAlreadyExists,
self._create_test_scoring_engine,
utils.create_test_scoring_engine,
name=scoring_engine_id)

17
watcher/tests/db/test_service.py
View File

@ -229,11 +229,6 @@ class TestDbServiceFilters(base.DbTestCase):
class DbServiceTestCase(base.DbTestCase):
def _create_test_service(self, **kwargs):
service = utils.get_test_service(**kwargs)
self.dbapi.create_service(service)
return service
def test_get_service_list(self):
ids = []
for i in range(1, 4):
@ -247,12 +242,12 @@ class DbServiceTestCase(base.DbTestCase):
self.assertEqual(sorted(ids), sorted(service_ids))
def test_get_service_list_with_filters(self):
service1 = self._create_test_service(
service1 = utils.create_test_service(
id=1,
name="SERVICE_ID_1",
host="controller_1",
)
service2 = self._create_test_service(
service2 = utils.create_test_service(
id=2,
name="SERVICE_ID_2",
host="controller_2",
@ -272,7 +267,7 @@ class DbServiceTestCase(base.DbTestCase):
self.assertEqual([service2['id']], [r.id for r in res])
def test_get_service_by_name(self):
created_service = self._create_test_service()
created_service = utils.create_test_service()
service = self.dbapi.get_service_by_name(
self.context, created_service['name'])
self.assertEqual(service.name, created_service['name'])
@ -283,7 +278,7 @@ class DbServiceTestCase(base.DbTestCase):
self.context, 404)
def test_update_service(self):
service = self._create_test_service()
service = utils.create_test_service()
res = self.dbapi.update_service(
service['id'], {'host': 'controller_test'})
self.assertEqual('controller_test', res.host)
@ -296,7 +291,7 @@ class DbServiceTestCase(base.DbTestCase):
def test_create_service_already_exists(self):
service_id = "STRATEGY_ID"
self._create_test_service(name=service_id)
utils.create_test_service(name=service_id)
self.assertRaises(exception.ServiceAlreadyExists,
self._create_test_service,
utils.create_test_service,
name=service_id)

23
watcher/tests/db/test_strategy.py
View File

@ -239,11 +239,6 @@ class TestDbStrategyFilters(base.DbTestCase):
class DbStrategyTestCase(base.DbTestCase):
def _create_test_strategy(self, **kwargs):
strategy = utils.get_test_strategy(**kwargs)
self.dbapi.create_strategy(strategy)
return strategy
def test_get_strategy_list(self):
uuids = []
for i in range(1, 4):
@ -278,13 +273,13 @@ class DbStrategyTestCase(base.DbTestCase):
self.assertEqual(goal.as_dict(), eager_strategy.goal.as_dict())
def test_get_strategy_list_with_filters(self):
strategy1 = self._create_test_strategy(
strategy1 = utils.create_test_strategy(
id=1,
uuid=w_utils.generate_uuid(),
name="STRATEGY_ID_1",
display_name='Strategy 1',
)
strategy2 = self._create_test_strategy(
strategy2 = utils.create_test_strategy(
id=2,
uuid=w_utils.generate_uuid(),
name="STRATEGY_ID_2",
@ -311,13 +306,13 @@ class DbStrategyTestCase(base.DbTestCase):
self.assertEqual([strategy2['uuid']], [r.uuid for r in res])
def test_get_strategy_by_uuid(self):
created_strategy = self._create_test_strategy()
created_strategy = utils.create_test_strategy()
strategy = self.dbapi.get_strategy_by_uuid(
self.context, created_strategy['uuid'])
self.assertEqual(strategy.uuid, created_strategy['uuid'])
def test_get_strategy_by_name(self):
created_strategy = self._create_test_strategy()
created_strategy = utils.create_test_strategy()
strategy = self.dbapi.get_strategy_by_name(
self.context, created_strategy['name'])
self.assertEqual(strategy.name, created_strategy['name'])
@ -328,13 +323,13 @@ class DbStrategyTestCase(base.DbTestCase):
self.context, 404)
def test_update_strategy(self):
strategy = self._create_test_strategy()
strategy = utils.create_test_strategy()
res = self.dbapi.update_strategy(
strategy['uuid'], {'display_name': 'updated-model'})
self.assertEqual('updated-model', res.display_name)
def test_update_goal_id(self):
strategy = self._create_test_strategy()
strategy = utils.create_test_strategy()
self.assertRaises(exception.Invalid,
self.dbapi.update_strategy, strategy['uuid'],
{'uuid': 'new_strategy_id'})
@ -346,7 +341,7 @@ class DbStrategyTestCase(base.DbTestCase):
{'display_name': ''})
def test_destroy_strategy(self):
strategy = self._create_test_strategy()
strategy = utils.create_test_strategy()
self.dbapi.destroy_strategy(strategy['uuid'])
self.assertRaises(exception.StrategyNotFound,
self.dbapi.get_strategy_by_id,
@ -358,7 +353,7 @@ class DbStrategyTestCase(base.DbTestCase):
def test_create_strategy_already_exists(self):
strategy_id = "STRATEGY_ID"
self._create_test_strategy(name=strategy_id)
utils.create_test_strategy(name=strategy_id)
self.assertRaises(exception.StrategyAlreadyExists,
self._create_test_strategy,
utils.create_test_strategy,
name=strategy_id)