Merge "Replace of private _create methods in tests"
This commit is contained in:
commit
00aa77651b
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
Loading…
Reference in New Issue