def test_create_action_plan_already_exists(self):
uuid = w_utils.generate_uuid()
utils.create_test_action_plan(id=1, uuid=uuid)
self.assertRaises(exception.ActionPlanAlreadyExists,
utils.create_test_action_plan,
id=2,
uuid=uuid)
def test_destroy_action_plan_by_uuid(self):
uuid = w_utils.generate_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)
self.assertRaises(exception.ActionPlanNotFound,
self.dbapi.get_action_plan_by_uuid, self.context,
uuid)
def setUp(self):
super(TestCreateDeleteActionObject, self).setUp()
self.fake_strategy = utils.create_test_strategy(name="DUMMY")
self.fake_audit = utils.create_test_audit()
self.fake_action_plan = utils.create_test_action_plan()
self.fake_action = utils.get_test_action(
created_at=datetime.datetime.utcnow())
def test_get_action_plan_list_with_filter_by_uuid(self):
action_plan = utils.create_test_action_plan()
res = self.dbapi.get_action_plan_list(
self.context, filters={'uuid': action_plan["uuid"]})
self.assertEqual(len(res), 1)
self.assertEqual(action_plan['uuid'], res[0].uuid)
def _data_setup(self):
self.audit_template_name = "Audit Template"
self.audit_template = utils.create_test_audit_template(
name=self.audit_template_name, id=1, uuid=None)
self.audit = utils.create_test_audit(
audit_template_id=self.audit_template.id, id=1, uuid=None)
self.action_plan = utils.create_test_action_plan(
audit_id=self.audit.id, id=1, uuid=None)
with freezegun.freeze_time(self.FAKE_TODAY):
self.efficacy_indicator1 = utils.create_test_efficacy_indicator(
action_plan_id=self.action_plan.id,
id=1,
uuid=None,
name="efficacy_indicator1",
description="Test Indicator 1")
with freezegun.freeze_time(self.FAKE_OLD_DATE):
self.efficacy_indicator2 = utils.create_test_efficacy_indicator(
action_plan_id=self.action_plan.id,
id=2,
uuid=None,
name="efficacy_indicator2",
description="Test Indicator 2")
with freezegun.freeze_time(self.FAKE_OLDER_DATE):
self.efficacy_indicator3 = utils.create_test_efficacy_indicator(
action_plan_id=self.action_plan.id,
id=3,
uuid=None,
name="efficacy_indicator3",
description="Test Indicator 3")
def test_get_action_plan_list_with_filters(self):
audit = utils.create_test_audit(id=2,
audit_type='ONESHOT',
uuid=w_utils.generate_uuid(),
state=ap_objects.State.ONGOING)
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 = utils.create_test_action_plan(
id=2,
uuid=w_utils.generate_uuid(),
audit_id=audit['id'],
state=ap_objects.State.ONGOING)
action_plan3 = utils.create_test_action_plan(
id=3,
uuid=w_utils.generate_uuid(),
audit_id=audit['id'],
state=ap_objects.State.RECOMMENDED)
# check on bug 1761956
self.dbapi.soft_delete_action_plan(action_plan3['uuid'])
res = self.dbapi.get_action_plan_list(
self.context, filters={'state': ap_objects.State.RECOMMENDED})
self.assertEqual([action_plan1['id']], [r.id for r in res])
res = self.dbapi.get_action_plan_list(
self.context, filters={'state': ap_objects.State.ONGOING})
self.assertEqual([action_plan2['id']], [r.id for r in res])
res = self.dbapi.get_action_plan_list(
self.context, filters={'audit_uuid': audit['uuid']})
self.assertEqual(sorted([action_plan1['id'], action_plan2['id']]),
sorted([r.id for r in res]))
for r in res:
self.assertEqual(audit['id'], r.audit_id)
self.dbapi.soft_delete_action_plan(action_plan1['uuid'])
res = self.dbapi.get_action_plan_list(
self.context, filters={'audit_uuid': audit['uuid']})
self.assertEqual([action_plan2['id']], [r.id for r in res])
self.assertNotEqual([action_plan1['id']], [r.id for r in res])
def _data_setup(self):
self.audit_template_name = "Audit Template"
self.audit_template = utils.create_test_audit_template(
name=self.audit_template_name, id=1, uuid=None)
self.audit = utils.create_test_audit(
audit_template_id=self.audit_template.id, id=1, uuid=None)
with freezegun.freeze_time(self.FAKE_TODAY):
self.action_plan1 = utils.create_test_action_plan(
audit_id=self.audit.id, id=1, uuid=None)
with freezegun.freeze_time(self.FAKE_OLD_DATE):
self.action_plan2 = utils.create_test_action_plan(
audit_id=self.audit.id, id=2, uuid=None)
with freezegun.freeze_time(self.FAKE_OLDER_DATE):
self.action_plan3 = utils.create_test_action_plan(
audit_id=self.audit.id, id=3, uuid=None)
def test_get_action_plan_list(self):
uuids = []
for i in range(1, 6):
audit = utils.create_test_action_plan(uuid=w_utils.generate_uuid())
uuids.append(six.text_type(audit['uuid']))
res = self.dbapi.get_action_plan_list(self.context)
res_uuids = [r.uuid for r in res]
self.assertEqual(uuids.sort(), res_uuids.sort())
def test_get_action_plan_list(self):
uuids = []
for i in range(1, 6):
audit = utils.create_test_action_plan(uuid=w_utils.generate_uuid())
uuids.append(six.text_type(audit['uuid']))
res = self.dbapi.get_action_plan_list(self.context)
res_uuids = [r.uuid for r in res]
self.assertEqual(uuids.sort(), res_uuids.sort())
def _data_setup(self):
self.audit_template_name = "Audit Template"
self.audit_template = utils.create_test_audit_template(
name=self.audit_template_name, id=1, uuid=None)
self.audit = utils.create_test_audit(
audit_template_id=self.audit_template.id, id=1, uuid=None)
with freezegun.freeze_time(self.FAKE_TODAY):
self.action_plan1 = utils.create_test_action_plan(
audit_id=self.audit.id, id=1, uuid=None)
with freezegun.freeze_time(self.FAKE_OLD_DATE):
self.action_plan2 = utils.create_test_action_plan(
audit_id=self.audit.id, id=2, uuid=None)
with freezegun.freeze_time(self.FAKE_OLDER_DATE):
self.action_plan3 = utils.create_test_action_plan(
audit_id=self.audit.id, id=3, uuid=None)
def test_get_efficacy_indicator_list_with_filters(self):
audit = utils.create_test_audit(uuid=w_utils.generate_uuid())
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 = utils.create_test_efficacy_indicator(
id=1,
name='indicator_1',
uuid=w_utils.generate_uuid(),
action_plan_id=action_plan['id'],
description='Description efficacy indicator 1',
unit='%')
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 = utils.create_test_efficacy_indicator(
id=3,
name='indicator_3',
uuid=w_utils.generate_uuid(),
action_plan_id=action_plan['id'],
description='Description efficacy indicator 3',
unit='%')
efficacy_indicator4 = utils.create_test_efficacy_indicator(
id=4,
name='indicator_4',
uuid=w_utils.generate_uuid(),
action_plan_id=action_plan['id'],
description='Description efficacy indicator 4',
unit='%')
self.dbapi.soft_delete_efficacy_indicator(efficacy_indicator4['uuid'])
res = self.dbapi.get_efficacy_indicator_list(
self.context, filters={'name': 'indicator_3'})
self.assertEqual([efficacy_indicator3['id']], [r.id for r in res])
res = self.dbapi.get_efficacy_indicator_list(self.context,
filters={'unit': 'kWh'})
self.assertEqual([], [r.id for r in res])
res = self.dbapi.get_efficacy_indicator_list(
self.context, filters={'action_plan_id': 2})
self.assertEqual([efficacy_indicator2['id']], [r.id for r in res])
res = self.dbapi.get_efficacy_indicator_list(
self.context, filters={'action_plan_uuid': action_plan['uuid']})
self.assertEqual(
sorted([efficacy_indicator1['id'], efficacy_indicator3['id']]),
sorted([r.id for r in res]))
def setUp(self):
super(TestActionObject, self).setUp()
p_action_notifications = mock.patch.object(
notifications, 'action_plan', autospec=True)
self.m_action_notifications = p_action_notifications.start()
self.addCleanup(p_action_notifications.stop)
self.m_send_update = self.m_action_notifications.send_update
self.fake_action_plan = utils.create_test_action_plan(
id=self.action_plan_id)
def test_get_action_plan_list(self):
uuids = []
for _ in range(1, 4):
action_plan = utils.create_test_action_plan(
uuid=w_utils.generate_uuid())
uuids.append(six.text_type(action_plan['uuid']))
action_plans = self.dbapi.get_action_plan_list(self.context)
action_plan_uuids = [ap.uuid for ap in action_plans]
self.assertEqual(sorted(uuids), sorted(action_plan_uuids))
for action_plan in action_plans:
self.assertIsNone(action_plan.audit)
self.assertIsNone(action_plan.strategy)
def test_get_efficacy_indicator_list(self):
uuids = []
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,
name="efficacy_indicator",
description="Test Indicator ")
uuids.append(six.text_type(efficacy_indicator['uuid']))
efficacy_indicators = self.dbapi.get_efficacy_indicator_list(
self.context)
efficacy_indicator_uuids = [ei.uuid for ei in efficacy_indicators]
self.assertEqual(sorted(uuids), sorted(efficacy_indicator_uuids))
for efficacy_indicator in efficacy_indicators:
self.assertIsNone(efficacy_indicator.action_plan)
def test_check_expired(self):
CONF.set_default('action_plan_expiry', 0,
group='watcher_decision_engine')
strategy_1 = utils.create_test_strategy(
uuid=common_utils.generate_uuid())
audit_1 = utils.create_test_audit(
uuid=common_utils.generate_uuid())
action_plan_1 = utils.create_test_action_plan(
state=objects.action_plan.State.RECOMMENDED,
uuid=common_utils.generate_uuid(),
audit_id=audit_1.id,
strategy_id=strategy_1.id)
self.state_manager.check_expired(self.context)
action_plan = objects.action_plan.ActionPlan.get_by_uuid(
self.context, action_plan_1.uuid)
self.assertEqual(objects.action_plan.State.SUPERSEDED,
action_plan.state)
def test_get_action_plan_list_eager(self):
_strategy = utils.get_test_strategy()
strategy = self.dbapi.create_strategy(_strategy)
_audit = utils.get_test_audit()
audit = self.dbapi.create_audit(_audit)
uuids = []
for _ in range(1, 4):
action_plan = utils.create_test_action_plan(
uuid=w_utils.generate_uuid())
uuids.append(six.text_type(action_plan['uuid']))
action_plans = self.dbapi.get_action_plan_list(self.context,
eager=True)
action_plan_map = {a.uuid: a for a in action_plans}
self.assertEqual(sorted(uuids), sorted(action_plan_map.keys()))
eager_action_plan = action_plan_map[action_plan.uuid]
self.assertEqual(strategy.as_dict(),
eager_action_plan.strategy.as_dict())
self.assertEqual(audit.as_dict(), eager_action_plan.audit.as_dict())
def _data_setup(self):
self.audit_template_name = "Audit Template"
self.audit_template = utils.create_test_audit_template(
name=self.audit_template_name, id=1, uuid=None)
self.audit = utils.create_test_audit(
audit_template_id=self.audit_template.id, id=1, uuid=None)
self.action_plan = utils.create_test_action_plan(
audit_id=self.audit.id, id=1, uuid=None)
with freezegun.freeze_time(self.FAKE_TODAY):
self.efficacy_indicator1 = utils.create_test_efficacy_indicator(
action_plan_id=self.action_plan.id, id=1, uuid=None,
name="efficacy_indicator1", description="Test Indicator 1")
with freezegun.freeze_time(self.FAKE_OLD_DATE):
self.efficacy_indicator2 = utils.create_test_efficacy_indicator(
action_plan_id=self.action_plan.id, id=2, uuid=None,
name="efficacy_indicator2", description="Test Indicator 2")
with freezegun.freeze_time(self.FAKE_OLDER_DATE):
self.efficacy_indicator3 = utils.create_test_efficacy_indicator(
action_plan_id=self.action_plan.id, id=3, uuid=None,
name="efficacy_indicator3", description="Test Indicator 3")
def test_update_action_plan(self):
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)
def test_get_action_plan_by_uuid(self):
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)
def test_update_action_plan_uuid(self):
action_plan = utils.create_test_action_plan()
self.assertRaises(exception.Invalid, self.dbapi.update_action_plan,
action_plan['id'], {'uuid': 'hello'})
def test_destroy_audit_that_referenced_by_action_plans(self):
audit = self._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,
self.dbapi.destroy_audit, audit['id'])
def test_destroy_action_plan(self):
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, self.context,
action_plan['id'])
def test_destroy_action_plan_that_referenced_by_actions(self):
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,
self.dbapi.destroy_action_plan, action_plan['id'])
def test_get_action_list_with_filters(self):
audit = utils.create_test_audit(uuid=w_utils.generate_uuid())
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 = utils.create_test_action(
id=1,
action_plan_id=action_plan['id'],
description='description action 1',
uuid=w_utils.generate_uuid(),
parents=None,
state=objects.action_plan.State.PENDING)
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 = utils.create_test_action(
id=3,
action_plan_id=action_plan['id'],
description='description action 3',
uuid=w_utils.generate_uuid(),
parents=[action2['uuid']],
state=objects.action_plan.State.ONGOING)
action4 = utils.create_test_action(
id=4,
action_plan_id=action_plan['id'],
description='description action 4',
uuid=w_utils.generate_uuid(),
parents=None,
state=objects.action_plan.State.ONGOING)
self.dbapi.soft_delete_action(action4['uuid'])
res = self.dbapi.get_action_list(
self.context, filters={'state': objects.action_plan.State.ONGOING})
self.assertEqual([action3['id']], [r.id for r in res])
res = self.dbapi.get_action_list(self.context,
filters={'state': 'bad-state'})
self.assertEqual([], [r.id for r in res])
res = self.dbapi.get_action_list(self.context,
filters={'action_plan_id': 2})
self.assertEqual([action2['id']], [r.id for r in res])
res = self.dbapi.get_action_list(
self.context, filters={'action_plan_uuid': action_plan['uuid']})
self.assertEqual(sorted([action1['id'], action3['id']]),
sorted([r.id for r in res]))
temp_context = self.context
temp_context.show_deleted = True
res = self.dbapi.get_action_list(
temp_context, filters={'action_plan_uuid': action_plan['uuid']})
self.assertEqual(sorted([action1['id'], action3['id'], action4['id']]),
sorted([r.id for r in res]))
res = self.dbapi.get_action_list(self.context,
filters={'audit_uuid': audit.uuid})
for action in res:
self.assertEqual(action_plan['id'], action.action_plan_id)
def setUp(self):
super(TestActionObject, self).setUp()
self.fake_action_plan = utils.create_test_action_plan(
id=self.action_plan_id)
def test_destroy_audit_that_referenced_by_action_plans(self):
audit = self._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, self.dbapi.destroy_audit,
audit['id'])
