From 415bab4bc916699aa93b3fcd5ce3d690c37c67e5 Mon Sep 17 00:00:00 2001 From: Egor Panfilov Date: Sat, 21 Apr 2018 22:32:25 +0300 Subject: [PATCH] Replace of private _create methods in tests Methods that already implemented in utils module are removed from test classes TrivialFix Change-Id: I38d806e23c162805b7d362b68bf3fe18da123ee3 --- watcher/tests/db/test_action.py | 38 ++++++++------------ watcher/tests/db/test_action_description.py | 13 +++---- watcher/tests/db/test_action_plan.py | 36 +++++++------------ watcher/tests/db/test_audit.py | 29 +++++++-------- watcher/tests/db/test_audit_template.py | 34 +++++++----------- watcher/tests/db/test_efficacy_indicator.py | 39 ++++++++------------- watcher/tests/db/test_goal.py | 21 +++++------ watcher/tests/db/test_scoring_engine.py | 25 ++++++------- watcher/tests/db/test_service.py | 17 ++++----- watcher/tests/db/test_strategy.py | 23 +++++------- 10 files changed, 103 insertions(+), 172 deletions(-) diff --git a/watcher/tests/db/test_action.py b/watcher/tests/db/test_action.py index d98d85472..a581d303d 100644 --- a/watcher/tests/db/test_action.py +++ b/watcher/tests/db/test_action.py @@ -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) diff --git a/watcher/tests/db/test_action_description.py b/watcher/tests/db/test_action_description.py index e9ea7f2a6..4a6a9a5e7 100644 --- a/watcher/tests/db/test_action_description.py +++ b/watcher/tests/db/test_action_description.py @@ -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) diff --git a/watcher/tests/db/test_action_plan.py b/watcher/tests/db/test_action_plan.py index 94e5757b0..af0e51f6c 100644 --- a/watcher/tests/db/test_action_plan.py +++ b/watcher/tests/db/test_action_plan.py @@ -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) diff --git a/watcher/tests/db/test_audit.py b/watcher/tests/db/test_audit.py index 9ec564949..ea7dd8d56 100644 --- a/watcher/tests/db/test_audit.py +++ b/watcher/tests/db/test_audit.py @@ -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): diff --git a/watcher/tests/db/test_audit_template.py b/watcher/tests/db/test_audit_template.py index a885be4f7..ce126a51f 100644 --- a/watcher/tests/db/test_audit_template.py +++ b/watcher/tests/db/test_audit_template.py @@ -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): diff --git a/watcher/tests/db/test_efficacy_indicator.py b/watcher/tests/db/test_efficacy_indicator.py index 673678c08..eb09f9771 100644 --- a/watcher/tests/db/test_efficacy_indicator.py +++ b/watcher/tests/db/test_efficacy_indicator.py @@ -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) diff --git a/watcher/tests/db/test_goal.py b/watcher/tests/db/test_goal.py index cae9449ea..b39f43d2c 100644 --- a/watcher/tests/db/test_goal.py +++ b/watcher/tests/db/test_goal.py @@ -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) diff --git a/watcher/tests/db/test_scoring_engine.py b/watcher/tests/db/test_scoring_engine.py index 02da05e8c..2b37127cc 100644 --- a/watcher/tests/db/test_scoring_engine.py +++ b/watcher/tests/db/test_scoring_engine.py @@ -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) diff --git a/watcher/tests/db/test_service.py b/watcher/tests/db/test_service.py index cda5470f3..c854b2858 100644 --- a/watcher/tests/db/test_service.py +++ b/watcher/tests/db/test_service.py @@ -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) diff --git a/watcher/tests/db/test_strategy.py b/watcher/tests/db/test_strategy.py index 081fa7973..8cf7905ba 100644 --- a/watcher/tests/db/test_strategy.py +++ b/watcher/tests/db/test_strategy.py @@ -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)