Arnike/watcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fixed update of WatcherObject fields on update

Browse Source 
I this changeset, I fixed the issue whereby object auto fields are not
being updated within the WatcherObject after an update.

Change-Id: I7e65341b386a5c0c58c2109348e39e463cf2f668
Closes-Bug: #1641955
This commit is contained in:
Vincent Françoise
2016-11-15 17:19:43 +01:00
parent 3ebe8ab70f
commit 06682fe7c3
16 changed files with 505 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
watcher/tests/objects/test_action.py
View File

@@ -13,6 +13,9 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.common import exception
@@ -100,17 +103,24 @@ class TestActionObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_action_by_uuid')
def test_save(self, mock_get_action, mock_update_action):
mock_get_action.return_value = self.fake_action
fake_saved_action = self.fake_action.copy()
fake_saved_action['updated_at'] = datetime.datetime.utcnow()
mock_update_action.return_value = fake_saved_action
uuid = self.fake_action['uuid']
action = objects.Action.get_by_uuid(
self.context, uuid, eager=self.eager)
action.state = objects.action.State.SUCCEEDED
action.save()
expected_update_at = fake_saved_action['updated_at'].replace(
tzinfo=iso8601.iso8601.Utc())
mock_get_action.assert_called_once_with(
self.context, uuid, eager=self.eager)
mock_update_action.assert_called_once_with(
uuid, {'state': objects.action.State.SUCCEEDED})
self.assertEqual(self.context, action._context)
self.assertEqual(expected_update_at, action.updated_at)
@mock.patch.object(db_api.Connection, 'get_action_by_uuid')
def test_refresh(self, mock_get_action):
@@ -136,15 +146,18 @@ class TestCreateDeleteActionObject(base.DbTestCase):
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()
self.fake_action = utils.get_test_action(
created_at=datetime.datetime.utcnow())
@mock.patch.object(db_api.Connection, 'create_action')
def test_create(self, mock_create_action):
mock_create_action.return_value = self.fake_action
action = objects.Action(self.context, **self.fake_action)
action.create()
mock_create_action.assert_called_once_with(self.fake_action)
expected_action = self.fake_action.copy()
expected_action['created_at'] = expected_action['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
mock_create_action.assert_called_once_with(expected_action)
self.assertEqual(self.context, action._context)
@mock.patch.object(db_api.Connection, 'update_action')
@@ -153,6 +166,18 @@ class TestCreateDeleteActionObject(base.DbTestCase):
def test_soft_delete(self, mock_get_action,
mock_soft_delete_action, mock_update_action):
mock_get_action.return_value = self.fake_action
fake_deleted_action = self.fake_action.copy()
fake_deleted_action['deleted_at'] = datetime.datetime.utcnow()
mock_soft_delete_action.return_value = fake_deleted_action
mock_update_action.return_value = fake_deleted_action
expected_action = fake_deleted_action.copy()
expected_action['created_at'] = expected_action['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
expected_action['deleted_at'] = expected_action['deleted_at'].replace(
tzinfo=iso8601.iso8601.Utc())
del expected_action['action_plan']
uuid = self.fake_action['uuid']
action = objects.Action.get_by_uuid(self.context, uuid)
action.soft_delete()
@@ -162,6 +187,7 @@ class TestCreateDeleteActionObject(base.DbTestCase):
mock_update_action.assert_called_once_with(
uuid, {'state': objects.action.State.DELETED})
self.assertEqual(self.context, action._context)
self.assertEqual(expected_action, action.as_dict())
@mock.patch.object(db_api.Connection, 'destroy_action')
@mock.patch.object(db_api.Connection, 'get_action_by_uuid')

30
watcher/tests/objects/test_action_plan.py
View File

@@ -13,6 +13,9 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.common import exception
@@ -109,6 +112,9 @@ class TestActionPlanObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid')
def test_save(self, mock_get_action_plan, mock_update_action_plan):
mock_get_action_plan.return_value = self.fake_action_plan
fake_saved_action_plan = self.fake_action_plan.copy()
fake_saved_action_plan['deleted_at'] = datetime.datetime.utcnow()
mock_update_action_plan.return_value = fake_saved_action_plan
uuid = self.fake_action_plan['uuid']
action_plan = objects.ActionPlan.get_by_uuid(
self.context, uuid, eager=self.eager)
@@ -146,7 +152,8 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
super(TestCreateDeleteActionPlanObject, self).setUp()
self.fake_strategy = utils.create_test_strategy(name="DUMMY")
self.fake_audit = utils.create_test_audit()
self.fake_action_plan = utils.get_test_action_plan()
self.fake_action_plan = utils.get_test_action_plan(
created_at=datetime.datetime.utcnow())
@mock.patch.object(db_api.Connection, 'create_action_plan')
def test_create(self, mock_create_action_plan):
@@ -154,8 +161,10 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
action_plan = objects.ActionPlan(
self.context, **self.fake_action_plan)
action_plan.create()
mock_create_action_plan.assert_called_once_with(
self.fake_action_plan)
expected_action_plan = self.fake_action_plan.copy()
expected_action_plan['created_at'] = expected_action_plan[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
mock_create_action_plan.assert_called_once_with(expected_action_plan)
self.assertEqual(self.context, action_plan._context)
@mock.patch.multiple(
@@ -178,7 +187,20 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
m_get_efficacy_indicator_list = get_efficacy_indicator_list
m_soft_delete_efficacy_indicator = soft_delete_efficacy_indicator
m_update_action_plan = update_action_plan
m_get_action_plan.return_value = self.fake_action_plan
fake_deleted_action_plan = self.fake_action_plan.copy()
fake_deleted_action_plan['deleted_at'] = datetime.datetime.utcnow()
m_update_action_plan.return_value = fake_deleted_action_plan
m_soft_delete_action_plan.return_value = fake_deleted_action_plan
expected_action_plan = fake_deleted_action_plan.copy()
expected_action_plan['created_at'] = expected_action_plan[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
expected_action_plan['deleted_at'] = expected_action_plan[
'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc())
del expected_action_plan['audit']
del expected_action_plan['strategy']
m_get_efficacy_indicator_list.return_value = [efficacy_indicator]
action_plan = objects.ActionPlan.get_by_uuid(self.context, uuid)
action_plan.soft_delete()
@@ -193,7 +215,9 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
efficacy_indicator['uuid'])
m_update_action_plan.assert_called_once_with(
uuid, {'state': objects.action_plan.State.DELETED})
self.assertEqual(self.context, action_plan._context)
self.assertEqual(expected_action_plan, action_plan.as_dict())
@mock.patch.multiple(
db_api.Connection,

74
watcher/tests/objects/test_audit.py
View File

@@ -13,6 +13,9 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.common import exception
@@ -37,14 +40,18 @@ class TestAuditObject(base.DbTestCase):
('non_eager', dict(
eager=False,
fake_audit=utils.get_test_audit(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))),
('eager_with_non_eager_load', dict(
eager=True,
fake_audit=utils.get_test_audit(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))),
('eager_with_eager_load', dict(
eager=True,
fake_audit=utils.get_test_audit(goal_id=goal_id, goal=goal_data))),
fake_audit=utils.get_test_audit(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id, goal=goal_data))),
]
def setUp(self):
@@ -116,6 +123,17 @@ class TestAuditObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
def test_save(self, mock_get_audit, mock_update_audit):
mock_get_audit.return_value = self.fake_audit
fake_saved_audit = self.fake_audit.copy()
fake_saved_audit['state'] = objects.audit.State.SUCCEEDED
fake_saved_audit['updated_at'] = datetime.datetime.utcnow()
mock_update_audit.return_value = fake_saved_audit
expected_audit = fake_saved_audit.copy()
expected_audit['created_at'] = expected_audit['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
expected_audit['updated_at'] = expected_audit['updated_at'].replace(
tzinfo=iso8601.iso8601.Utc())
uuid = self.fake_audit['uuid']
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=self.eager)
audit.state = objects.audit.State.SUCCEEDED
@@ -129,6 +147,11 @@ class TestAuditObject(base.DbTestCase):
self.eager_load_audit_assert(audit, self.fake_goal)
self.m_send_update.assert_called_once_with(
self.context, audit, old_state=self.fake_audit['state'])
self.assertEqual(
{k: v for k, v in expected_audit.items()
if k not in audit.object_fields},
{k: v for k, v in audit.as_dict().items()
if k not in audit.object_fields})
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
def test_refresh(self, mock_get_audit):
@@ -160,14 +183,18 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
self.goal_id = 1
self.goal = utils.create_test_goal(id=self.goal_id, name="DUMMY")
self.fake_audit = utils.get_test_audit(goal_id=self.goal_id)
self.fake_audit = utils.get_test_audit(
goal_id=self.goal_id, created_at=datetime.datetime.utcnow())
@mock.patch.object(db_api.Connection, 'create_audit')
def test_create(self, mock_create_audit):
mock_create_audit.return_value = self.fake_audit
audit = objects.Audit(self.context, **self.fake_audit)
audit.create()
mock_create_audit.assert_called_once_with(self.fake_audit)
expected_audit = self.fake_audit.copy()
expected_audit['created_at'] = expected_audit['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
mock_create_audit.assert_called_once_with(expected_audit)
self.assertEqual(self.context, audit._context)
@mock.patch.object(db_api.Connection, 'update_audit')
@@ -176,13 +203,27 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
def test_soft_delete(self, mock_get_audit,
mock_soft_delete_audit, mock_update_audit):
mock_get_audit.return_value = self.fake_audit
fake_deleted_audit = self.fake_audit.copy()
fake_deleted_audit['deleted_at'] = datetime.datetime.utcnow()
mock_soft_delete_audit.return_value = fake_deleted_audit
mock_update_audit.return_value = fake_deleted_audit
expected_audit = fake_deleted_audit.copy()
expected_audit['created_at'] = expected_audit['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
expected_audit['deleted_at'] = expected_audit['deleted_at'].replace(
tzinfo=iso8601.iso8601.Utc())
del expected_audit['goal']
del expected_audit['strategy']
uuid = self.fake_audit['uuid']
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True)
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=False)
audit.soft_delete()
mock_get_audit.assert_called_once_with(self.context, uuid, eager=True)
mock_get_audit.assert_called_once_with(self.context, uuid, eager=False)
mock_soft_delete_audit.assert_called_once_with(uuid)
mock_update_audit.assert_called_once_with(uuid, {'state': 'DELETED'})
self.assertEqual(self.context, audit._context)
self.assertEqual(expected_audit, audit.as_dict())
@mock.patch.object(db_api.Connection, 'destroy_audit')
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
@@ -216,14 +257,17 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
self.m_notifier = self.m_get_notifier.return_value
self.addCleanup(p_get_notifier.stop)
@mock.patch.object(db_api.Connection, 'update_audit', mock.Mock())
@mock.patch.object(db_api.Connection, 'update_audit')
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
def test_send_update_notification(self, m_get_audit):
def test_send_update_notification(self, m_get_audit, m_update_audit):
fake_audit = utils.get_test_audit(
goal=self.fake_goal.as_dict(),
strategy_id=self.fake_strategy.id,
strategy=self.fake_strategy.as_dict())
m_get_audit.return_value = fake_audit
fake_saved_audit = self.fake_audit.copy()
fake_saved_audit['state'] = objects.audit.State.SUCCEEDED
m_update_audit.return_value = fake_saved_audit
uuid = fake_audit['uuid']
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True)
@@ -249,17 +293,25 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
self.assertEqual('audit.create',
self.m_notifier.info.call_args[1]['event_type'])
@mock.patch.object(db_api.Connection, 'soft_delete_audit', mock.Mock())
@mock.patch.object(db_api.Connection, 'update_audit', mock.Mock())
@mock.patch.object(db_api.Connection, 'update_audit')
@mock.patch.object(db_api.Connection, 'soft_delete_audit')
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
def test_send_delete_notification(self, m_get_audit):
def test_send_delete_notification(
self, m_get_audit, m_soft_delete_audit, m_update_audit):
fake_audit = utils.get_test_audit(
goal=self.fake_goal.as_dict(),
strategy_id=self.fake_strategy.id,
strategy=self.fake_strategy.as_dict())
m_get_audit.return_value = fake_audit
uuid = fake_audit['uuid']
fake_deleted_audit = self.fake_audit.copy()
fake_deleted_audit['deleted_at'] = datetime.datetime.utcnow()
expected_audit = fake_deleted_audit.copy()
expected_audit['deleted_at'] = expected_audit['deleted_at'].replace(
tzinfo=iso8601.iso8601.Utc())
m_soft_delete_audit.return_value = fake_deleted_audit
m_update_audit.return_value = fake_deleted_audit
uuid = fake_audit['uuid']
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True)
audit.soft_delete()

40
watcher/tests/objects/test_audit_template.py
View File

@@ -13,6 +13,9 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.common import exception
@@ -34,14 +37,17 @@ class TestAuditTemplateObject(base.DbTestCase):
('non_eager', dict(
eager=False,
fake_audit_template=utils.get_test_audit_template(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))),
('eager_with_non_eager_load', dict(
eager=True,
fake_audit_template=utils.get_test_audit_template(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))),
('eager_with_eager_load', dict(
eager=True,
fake_audit_template=utils.get_test_audit_template(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id, goal=goal_data))),
]
@@ -120,6 +126,9 @@ class TestAuditTemplateObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
def test_save(self, mock_get_audit_template, mock_update_audit_template):
mock_get_audit_template.return_value = self.fake_audit_template
fake_saved_audit_template = self.fake_audit_template.copy()
fake_saved_audit_template['updated_at'] = datetime.datetime.utcnow()
mock_update_audit_template.return_value = fake_saved_audit_template
uuid = self.fake_audit_template['uuid']
audit_template = objects.AuditTemplate.get_by_uuid(
self.context, uuid, eager=self.eager)
@@ -155,7 +164,8 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
def setUp(self):
super(TestCreateDeleteAuditTemplateObject, self).setUp()
self.fake_audit_template = utils.get_test_audit_template()
self.fake_audit_template = utils.get_test_audit_template(
created_at=datetime.datetime.utcnow())
@mock.patch.object(db_api.Connection, 'create_audit_template')
def test_create(self, mock_create_audit_template):
@@ -165,22 +175,38 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
audit_template = objects.AuditTemplate(
self.context, **self.fake_audit_template)
audit_template.create()
expected_audit_template = self.fake_audit_template.copy()
expected_audit_template['created_at'] = expected_audit_template[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
mock_create_audit_template.assert_called_once_with(
self.fake_audit_template)
expected_audit_template)
self.assertEqual(self.context, audit_template._context)
@mock.patch.object(db_api.Connection, 'soft_delete_audit_template')
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
def test_soft_delete(self, mock_get_audit_template,
mock_soft_delete_audit_template):
mock_get_audit_template.return_value = self.fake_audit_template
def test_soft_delete(self, m_get_audit_template,
m_soft_delete_audit_template):
m_get_audit_template.return_value = self.fake_audit_template
fake_deleted_audit_template = self.fake_audit_template.copy()
fake_deleted_audit_template['deleted_at'] = datetime.datetime.utcnow()
m_soft_delete_audit_template.return_value = fake_deleted_audit_template
expected_audit_template = fake_deleted_audit_template.copy()
expected_audit_template['created_at'] = expected_audit_template[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
expected_audit_template['deleted_at'] = expected_audit_template[
'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc())
del expected_audit_template['goal']
del expected_audit_template['strategy']
uuid = self.fake_audit_template['uuid']
audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid)
audit_template.soft_delete()
mock_get_audit_template.assert_called_once_with(
m_get_audit_template.assert_called_once_with(
self.context, uuid, eager=False)
mock_soft_delete_audit_template.assert_called_once_with(uuid)
m_soft_delete_audit_template.assert_called_once_with(uuid)
self.assertEqual(self.context, audit_template._context)
self.assertEqual(expected_audit_template, audit_template.as_dict())
@mock.patch.object(db_api.Connection, 'destroy_audit_template')
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')

191
watcher/tests/objects/test_goal.py
View File

@@ -13,8 +13,12 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.db.sqlalchemy import api as db_api
from watcher import objects
from watcher.tests.db import base
from watcher.tests.db import utils
@@ -24,115 +28,116 @@ class TestGoalObject(base.DbTestCase):
def setUp(self):
super(TestGoalObject, self).setUp()
self.fake_goal = utils.get_test_goal()
self.fake_goal = utils.get_test_goal(
created_at=datetime.datetime.utcnow())
def test_get_by_id(self):
@mock.patch.object(db_api.Connection, 'get_goal_by_id')
def test_get_by_id(self, mock_get_goal):
goal_id = self.fake_goal['id']
with mock.patch.object(self.dbapi, 'get_goal_by_id',
autospec=True) as mock_get_goal:
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get(self.context, goal_id)
mock_get_goal.assert_called_once_with(self.context, goal_id)
self.assertEqual(self.context, goal._context)
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get(self.context, goal_id)
mock_get_goal.assert_called_once_with(self.context, goal_id)
self.assertEqual(self.context, goal._context)
def test_get_by_uuid(self):
@mock.patch.object(db_api.Connection, 'get_goal_by_uuid')
def test_get_by_uuid(self, mock_get_goal):
uuid = self.fake_goal['uuid']
with mock.patch.object(self.dbapi, 'get_goal_by_uuid',
autospec=True) as mock_get_goal:
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get(self.context, uuid)
mock_get_goal.assert_called_once_with(self.context, uuid)
self.assertEqual(self.context, goal._context)
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get(self.context, uuid)
mock_get_goal.assert_called_once_with(self.context, uuid)
self.assertEqual(self.context, goal._context)
def test_get_by_name(self):
@mock.patch.object(db_api.Connection, 'get_goal_by_name')
def test_get_by_name(self, mock_get_goal):
name = self.fake_goal['name']
with mock.patch.object(self.dbapi, 'get_goal_by_name',
autospec=True) as mock_get_goal:
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get_by_name(
self.context,
name)
mock_get_goal.assert_called_once_with(self.context, name)
self.assertEqual(self.context, goal._context)
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get_by_name(self.context, name)
mock_get_goal.assert_called_once_with(self.context, name)
self.assertEqual(self.context, goal._context)
def test_list(self):
with mock.patch.object(self.dbapi, 'get_goal_list',
autospec=True) as mock_get_list:
mock_get_list.return_value = [self.fake_goal]
goals = objects.Goal.list(self.context)
self.assertEqual(1, mock_get_list.call_count)
self.assertEqual(1, len(goals))
self.assertIsInstance(goals[0], objects.Goal)
self.assertEqual(self.context, goals[0]._context)
@mock.patch.object(db_api.Connection, 'get_goal_list')
def test_list(self, mock_get_list):
mock_get_list.return_value = [self.fake_goal]
goals = objects.Goal.list(self.context)
self.assertEqual(1, mock_get_list.call_count)
self.assertEqual(1, len(goals))
self.assertIsInstance(goals[0], objects.Goal)
self.assertEqual(self.context, goals[0]._context)
def test_create(self):
with mock.patch.object(self.dbapi, 'create_goal',
autospec=True) as mock_create_goal:
mock_create_goal.return_value = self.fake_goal
goal = objects.Goal(self.context, **self.fake_goal)
goal.create()
mock_create_goal.assert_called_once_with(self.fake_goal)
self.assertEqual(self.context, goal._context)
@mock.patch.object(db_api.Connection, 'create_goal')
def test_create(self, mock_create_goal):
mock_create_goal.return_value = self.fake_goal
goal = objects.Goal(self.context, **self.fake_goal)
goal.create()
expected_goal = self.fake_goal.copy()
expected_goal['created_at'] = expected_goal['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
mock_create_goal.assert_called_once_with(expected_goal)
self.assertEqual(self.context, goal._context)
def test_destroy(self):
@mock.patch.object(db_api.Connection, 'destroy_goal')
@mock.patch.object(db_api.Connection, 'get_goal_by_id')
def test_destroy(self, mock_get_goal, mock_destroy_goal):
goal_id = self.fake_goal['id']
with mock.patch.object(self.dbapi, 'get_goal_by_id',
autospec=True) as mock_get_goal:
mock_get_goal.return_value = self.fake_goal
with mock.patch.object(self.dbapi, 'destroy_goal',
autospec=True) \
as mock_destroy_goal:
goal = objects.Goal.get_by_id(self.context, goal_id)
goal.destroy()
mock_get_goal.assert_called_once_with(
self.context, goal_id)
mock_destroy_goal.assert_called_once_with(goal_id)
self.assertEqual(self.context, goal._context)
mock_get_goal.return_value = self.fake_goal
goal = objects.Goal.get_by_id(self.context, goal_id)
goal.destroy()
mock_get_goal.assert_called_once_with(
self.context, goal_id)
mock_destroy_goal.assert_called_once_with(goal_id)
self.assertEqual(self.context, goal._context)
def test_save(self):
goal_id = self.fake_goal['id']
with mock.patch.object(self.dbapi, 'get_goal_by_id',
autospec=True) as mock_get_goal:
mock_get_goal.return_value = self.fake_goal
with mock.patch.object(self.dbapi, 'update_goal',
autospec=True) as mock_update_goal:
goal = objects.Goal.get_by_id(self.context, goal_id)
goal.display_name = 'DUMMY'
goal.save()
@mock.patch.object(db_api.Connection, 'update_goal')
@mock.patch.object(db_api.Connection, 'get_goal_by_uuid')
def test_save(self, mock_get_goal, mock_update_goal):
mock_get_goal.return_value = self.fake_goal
goal_uuid = self.fake_goal['uuid']
fake_saved_goal = self.fake_goal.copy()
fake_saved_goal['updated_at'] = datetime.datetime.utcnow()
mock_update_goal.return_value = fake_saved_goal
mock_get_goal.assert_called_once_with(self.context, goal_id)
mock_update_goal.assert_called_once_with(
goal_id, {'display_name': 'DUMMY'})
self.assertEqual(self.context, goal._context)
goal = objects.Goal.get_by_uuid(self.context, goal_uuid)
goal.display_name = 'DUMMY'
goal.save()
def test_refresh(self):
uuid = self.fake_goal['uuid']
mock_get_goal.assert_called_once_with(self.context, goal_uuid)
mock_update_goal.assert_called_once_with(
goal_uuid, {'display_name': 'DUMMY'})
self.assertEqual(self.context, goal._context)
@mock.patch.object(db_api.Connection, 'get_goal_by_uuid')
def test_refresh(self, mock_get_goal):
fake_goal2 = utils.get_test_goal(name="BALANCE_LOAD")
returns = [self.fake_goal, fake_goal2]
mock_get_goal.side_effect = returns
uuid = self.fake_goal['uuid']
expected = [mock.call(self.context, uuid),
mock.call(self.context, uuid)]
with mock.patch.object(self.dbapi, 'get_goal_by_uuid',
side_effect=returns,
autospec=True) as mock_get_goal:
goal = objects.Goal.get(self.context, uuid)
self.assertEqual("TEST", goal.name)
goal.refresh()
self.assertEqual("BALANCE_LOAD", goal.name)
self.assertEqual(expected, mock_get_goal.call_args_list)
self.assertEqual(self.context, goal._context)
goal = objects.Goal.get(self.context, uuid)
self.assertEqual("TEST", goal.name)
goal.refresh()
self.assertEqual("BALANCE_LOAD", goal.name)
self.assertEqual(expected, mock_get_goal.call_args_list)
self.assertEqual(self.context, goal._context)
@mock.patch.object(db_api.Connection, 'soft_delete_goal')
@mock.patch.object(db_api.Connection, 'get_goal_by_uuid')
def test_soft_delete(self, mock_get_goal, mock_soft_delete_goal):
mock_get_goal.return_value = self.fake_goal
fake_deleted_goal = self.fake_goal.copy()
fake_deleted_goal['deleted_at'] = datetime.datetime.utcnow()
mock_soft_delete_goal.return_value = fake_deleted_goal
expected_goal = fake_deleted_goal.copy()
expected_goal['created_at'] = expected_goal['created_at'].replace(
tzinfo=iso8601.iso8601.Utc())
expected_goal['deleted_at'] = expected_goal['deleted_at'].replace(
tzinfo=iso8601.iso8601.Utc())
def test_soft_delete(self):
uuid = self.fake_goal['uuid']
with mock.patch.object(self.dbapi, 'get_goal_by_uuid',
autospec=True) as mock_get_goal:
mock_get_goal.return_value = self.fake_goal
with mock.patch.object(self.dbapi, 'soft_delete_goal',
autospec=True) \
as mock_soft_delete_goal:
goal = objects.Goal.get_by_uuid(
self.context, uuid)
goal.soft_delete()
mock_get_goal.assert_called_once_with(
self.context, uuid)
mock_soft_delete_goal.assert_called_once_with(uuid)
self.assertEqual(self.context, goal._context)
goal = objects.Goal.get_by_uuid(self.context, uuid)
goal.soft_delete()
mock_get_goal.assert_called_once_with(self.context, uuid)
mock_soft_delete_goal.assert_called_once_with(uuid)
self.assertEqual(self.context, goal._context)
self.assertEqual(expected_goal, goal.as_dict())

210
watcher/tests/objects/test_scoring_engine.py
View File

@@ -13,7 +13,12 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.db.sqlalchemy import api as db_api
from watcher import objects
from watcher.tests.db import base
from watcher.tests.db import utils
@@ -23,126 +28,125 @@ class TestScoringEngineObject(base.DbTestCase):
def setUp(self):
super(TestScoringEngineObject, self).setUp()
self.fake_scoring_engine = utils.get_test_scoring_engine()
self.fake_scoring_engine = utils.get_test_scoring_engine(
created_at=datetime.datetime.utcnow())
def test_get_by_id(self):
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
def test_get_by_id(self, mock_get_scoring_engine):
scoring_engine_id = self.fake_scoring_engine['id']
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id',
autospec=True) as mock_get_scoring_engine:
mock_get_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine.get_by_id(
self.context, scoring_engine_id)
mock_get_scoring_engine.assert_called_once_with(self.context,
scoring_engine_id)
self.assertEqual(self.context, scoring_engine._context)
mock_get_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine.get_by_id(
self.context, scoring_engine_id)
mock_get_scoring_engine.assert_called_once_with(
self.context, scoring_engine_id)
self.assertEqual(self.context, scoring_engine._context)
def test_get_by_uuid(self):
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid')
def test_get_by_uuid(self, mock_get_scoring_engine):
se_uuid = self.fake_scoring_engine['uuid']
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_uuid',
autospec=True) as mock_get_scoring_engine:
mock_get_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine.get_by_uuid(
self.context, se_uuid)
mock_get_scoring_engine.assert_called_once_with(self.context,
se_uuid)
self.assertEqual(self.context, scoring_engine._context)
mock_get_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine.get_by_uuid(
self.context, se_uuid)
mock_get_scoring_engine.assert_called_once_with(
self.context, se_uuid)
self.assertEqual(self.context, scoring_engine._context)
def test_get_by_name(self):
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid')
def test_get_by_name(self, mock_get_scoring_engine):
scoring_engine_uuid = self.fake_scoring_engine['uuid']
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_uuid',
autospec=True) as mock_get_scoring_engine:
mock_get_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine.get(
self.context, scoring_engine_uuid)
mock_get_scoring_engine.assert_called_once_with(
self.context, scoring_engine_uuid)
self.assertEqual(self.context, scoring_engine._context)
mock_get_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine.get(
self.context, scoring_engine_uuid)
mock_get_scoring_engine.assert_called_once_with(
self.context, scoring_engine_uuid)
self.assertEqual(self.context, scoring_engine._context)
def test_list(self):
with mock.patch.object(self.dbapi, 'get_scoring_engine_list',
autospec=True) as mock_get_list:
mock_get_list.return_value = [self.fake_scoring_engine]
scoring_engines = objects.ScoringEngine.list(self.context)
self.assertEqual(1, mock_get_list.call_count, 1)
self.assertEqual(1, len(scoring_engines))
self.assertIsInstance(scoring_engines[0], objects.ScoringEngine)
self.assertEqual(self.context, scoring_engines[0]._context)
@mock.patch.object(db_api.Connection, 'get_scoring_engine_list')
def test_list(self, mock_get_list):
mock_get_list.return_value = [self.fake_scoring_engine]
scoring_engines = objects.ScoringEngine.list(self.context)
self.assertEqual(1, mock_get_list.call_count, 1)
self.assertEqual(1, len(scoring_engines))
self.assertIsInstance(scoring_engines[0], objects.ScoringEngine)
self.assertEqual(self.context, scoring_engines[0]._context)
def test_create(self):
with mock.patch.object(self.dbapi, 'create_scoring_engine',
autospec=True) as mock_create_scoring_engine:
mock_create_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine(
self.context, **self.fake_scoring_engine)
@mock.patch.object(db_api.Connection, 'create_scoring_engine')
def test_create(self, mock_create_scoring_engine):
mock_create_scoring_engine.return_value = self.fake_scoring_engine
scoring_engine = objects.ScoringEngine(
self.context, **self.fake_scoring_engine)
scoring_engine.create()
expected_scoring_engine = self.fake_scoring_engine.copy()
expected_scoring_engine['created_at'] = expected_scoring_engine[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
mock_create_scoring_engine.assert_called_once_with(
expected_scoring_engine)
self.assertEqual(self.context, scoring_engine._context)
scoring_engine.create()
mock_create_scoring_engine.assert_called_once_with(
self.fake_scoring_engine)
self.assertEqual(self.context, scoring_engine._context)
def test_destroy(self):
@mock.patch.object(db_api.Connection, 'destroy_scoring_engine')
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
def test_destroy(self, mock_get_scoring_engine,
mock_destroy_scoring_engine):
mock_get_scoring_engine.return_value = self.fake_scoring_engine
_id = self.fake_scoring_engine['id']
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id',
autospec=True) as mock_get_scoring_engine:
mock_get_scoring_engine.return_value = self.fake_scoring_engine
with mock.patch.object(
self.dbapi, 'destroy_scoring_engine',
autospec=True) as mock_destroy_scoring_engine:
scoring_engine = objects.ScoringEngine.get_by_id(
self.context, _id)
scoring_engine.destroy()
mock_get_scoring_engine.assert_called_once_with(
self.context, _id)
mock_destroy_scoring_engine.assert_called_once_with(_id)
self.assertEqual(self.context, scoring_engine._context)
scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
scoring_engine.destroy()
mock_get_scoring_engine.assert_called_once_with(self.context, _id)
mock_destroy_scoring_engine.assert_called_once_with(_id)
self.assertEqual(self.context, scoring_engine._context)
def test_save(self):
_id = self.fake_scoring_engine['id']
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id',
autospec=True) as mock_get_scoring_engine:
mock_get_scoring_engine.return_value = self.fake_scoring_engine
with mock.patch.object(
self.dbapi, 'update_scoring_engine',
autospec=True) as mock_update_scoring_engine:
scoring_engine = objects.ScoringEngine.get_by_id(
self.context, _id)
scoring_engine.description = 'UPDATED DESCRIPTION'
scoring_engine.save()
@mock.patch.object(db_api.Connection, 'update_scoring_engine')
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_uuid')
def test_save(self, mock_get_scoring_engine, mock_update_scoring_engine):
mock_get_scoring_engine.return_value = self.fake_scoring_engine
fake_saved_scoring_engine = self.fake_scoring_engine.copy()
fake_saved_scoring_engine['updated_at'] = datetime.datetime.utcnow()
mock_update_scoring_engine.return_value = fake_saved_scoring_engine
mock_get_scoring_engine.assert_called_once_with(
self.context, _id)
mock_update_scoring_engine.assert_called_once_with(
_id, {'description': 'UPDATED DESCRIPTION'})
self.assertEqual(self.context, scoring_engine._context)
uuid = self.fake_scoring_engine['uuid']
scoring_engine = objects.ScoringEngine.get_by_uuid(self.context, uuid)
scoring_engine.description = 'UPDATED DESCRIPTION'
scoring_engine.save()
def test_refresh(self):
_id = self.fake_scoring_engine['id']
mock_get_scoring_engine.assert_called_once_with(self.context, uuid)
mock_update_scoring_engine.assert_called_once_with(
uuid, {'description': 'UPDATED DESCRIPTION'})
self.assertEqual(self.context, scoring_engine._context)
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
def test_refresh(self, mock_get_scoring_engine):
returns = [
dict(self.fake_scoring_engine, description="first description"),
dict(self.fake_scoring_engine, description="second description")]
mock_get_scoring_engine.side_effect = returns
_id = self.fake_scoring_engine['id']
expected = [mock.call(self.context, _id),
mock.call(self.context, _id)]
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id',
side_effect=returns,
autospec=True) as mock_get_scoring_engine:
scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
self.assertEqual("first description", scoring_engine.description)
scoring_engine.refresh()
self.assertEqual("second description", scoring_engine.description)
self.assertEqual(expected, mock_get_scoring_engine.call_args_list)
self.assertEqual(self.context, scoring_engine._context)
scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
self.assertEqual("first description", scoring_engine.description)
scoring_engine.refresh()
self.assertEqual("second description", scoring_engine.description)
self.assertEqual(expected, mock_get_scoring_engine.call_args_list)
self.assertEqual(self.context, scoring_engine._context)
@mock.patch.object(db_api.Connection, 'soft_delete_scoring_engine')
@mock.patch.object(db_api.Connection, 'get_scoring_engine_by_id')
def test_soft_delete(self, mock_get_scoring_engine, mock_soft_delete):
mock_get_scoring_engine.return_value = self.fake_scoring_engine
fake_deleted_scoring_engine = self.fake_scoring_engine.copy()
fake_deleted_scoring_engine['deleted_at'] = datetime.datetime.utcnow()
mock_soft_delete.return_value = fake_deleted_scoring_engine
expected_scoring_engine = fake_deleted_scoring_engine.copy()
expected_scoring_engine['created_at'] = expected_scoring_engine[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
expected_scoring_engine['deleted_at'] = expected_scoring_engine[
'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc())
def test_soft_delete(self):
_id = self.fake_scoring_engine['id']
with mock.patch.object(self.dbapi, 'get_scoring_engine_by_id',
autospec=True) as mock_get_scoring_engine:
mock_get_scoring_engine.return_value = self.fake_scoring_engine
with mock.patch.object(self.dbapi, 'soft_delete_scoring_engine',
autospec=True) as mock_soft_delete:
scoring_engine = objects.ScoringEngine.get_by_id(
self.context, _id)
scoring_engine.soft_delete()
mock_get_scoring_engine.assert_called_once_with(
self.context, _id)
mock_soft_delete.assert_called_once_with(_id)
self.assertEqual(self.context, scoring_engine._context)
scoring_engine = objects.ScoringEngine.get_by_id(self.context, _id)
scoring_engine.soft_delete()
mock_get_scoring_engine.assert_called_once_with(self.context, _id)
mock_soft_delete.assert_called_once_with(_id)
self.assertEqual(self.context, scoring_engine._context)
self.assertEqual(expected_scoring_engine, scoring_engine.as_dict())

136
watcher/tests/objects/test_service.py
View File

@@ -13,8 +13,12 @@
# License for the specific language governing permissions and limitations
# under the License.
import datetime
import iso8601
import mock
from watcher.db.sqlalchemy import api as db_api
from watcher import objects
from watcher.tests.db import base
from watcher.tests.db import utils
@@ -24,81 +28,89 @@ class TestServiceObject(base.DbTestCase):
def setUp(self):
super(TestServiceObject, self).setUp()
self.fake_service = utils.get_test_service()
self.fake_service = utils.get_test_service(
created_at=datetime.datetime.utcnow())
def test_get_by_id(self):
@mock.patch.object(db_api.Connection, 'get_service_by_id')
def test_get_by_id(self, mock_get_service):
service_id = self.fake_service['id']
with mock.patch.object(self.dbapi, 'get_service_by_id',
autospec=True) as mock_get_service:
mock_get_service.return_value = self.fake_service
service = objects.Service.get(self.context, service_id)
mock_get_service.assert_called_once_with(self.context,
service_id)
self.assertEqual(self.context, service._context)
mock_get_service.return_value = self.fake_service
service = objects.Service.get(self.context, service_id)
mock_get_service.assert_called_once_with(self.context, service_id)
self.assertEqual(self.context, service._context)
def test_list(self):
with mock.patch.object(self.dbapi, 'get_service_list',
autospec=True) as mock_get_list:
mock_get_list.return_value = [self.fake_service]
services = objects.Service.list(self.context)
self.assertEqual(1, mock_get_list.call_count, 1)
self.assertEqual(1, len(services))
self.assertIsInstance(services[0], objects.Service)
self.assertEqual(self.context, services[0]._context)
@mock.patch.object(db_api.Connection, 'get_service_list')
def test_list(self, mock_get_list):
mock_get_list.return_value = [self.fake_service]
services = objects.Service.list(self.context)
self.assertEqual(1, mock_get_list.call_count, 1)
self.assertEqual(1, len(services))
self.assertIsInstance(services[0], objects.Service)
self.assertEqual(self.context, services[0]._context)
def test_create(self):
with mock.patch.object(self.dbapi, 'create_service',
autospec=True) as mock_create_service:
mock_create_service.return_value = self.fake_service
service = objects.Service(self.context, **self.fake_service)
@mock.patch.object(db_api.Connection, 'create_service')
def test_create(self, mock_create_service):
mock_create_service.return_value = self.fake_service
service = objects.Service(self.context, **self.fake_service)
fake_service = utils.get_test_service()
service.create()
expected_service = self.fake_service.copy()
expected_service['created_at'] = expected_service[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
service.create()
mock_create_service.assert_called_once_with(fake_service)
self.assertEqual(self.context, service._context)
mock_create_service.assert_called_once_with(expected_service)
self.assertEqual(self.context, service._context)
def test_save(self):
@mock.patch.object(db_api.Connection, 'update_service')
@mock.patch.object(db_api.Connection, 'get_service_by_id')
def test_save(self, mock_get_service, mock_update_service):
mock_get_service.return_value = self.fake_service
fake_saved_service = self.fake_service.copy()
fake_saved_service['updated_at'] = datetime.datetime.utcnow()
mock_update_service.return_value = fake_saved_service
_id = self.fake_service['id']
with mock.patch.object(self.dbapi, 'get_service_by_id',
autospec=True) as mock_get_service:
mock_get_service.return_value = self.fake_service
with mock.patch.object(self.dbapi, 'update_service',
autospec=True) as mock_update_service:
service = objects.Service.get(self.context, _id)
service.name = 'UPDATED NAME'
service.save()
service = objects.Service.get(self.context, _id)
service.name = 'UPDATED NAME'
service.save()
mock_get_service.assert_called_once_with(self.context, _id)
mock_update_service.assert_called_once_with(
_id, {'name': 'UPDATED NAME'})
self.assertEqual(self.context, service._context)
mock_get_service.assert_called_once_with(self.context, _id)
mock_update_service.assert_called_once_with(
_id, {'name': 'UPDATED NAME'})
self.assertEqual(self.context, service._context)
def test_refresh(self):
_id = self.fake_service['id']
@mock.patch.object(db_api.Connection, 'get_service_by_id')
def test_refresh(self, mock_get_service):
returns = [dict(self.fake_service, name="first name"),
dict(self.fake_service, name="second name")]
mock_get_service.side_effect = returns
_id = self.fake_service['id']
expected = [mock.call(self.context, _id),
mock.call(self.context, _id)]
with mock.patch.object(self.dbapi, 'get_service_by_id',
side_effect=returns,
autospec=True) as mock_get_service:
service = objects.Service.get(self.context, _id)
self.assertEqual("first name", service.name)
service.refresh()
self.assertEqual("second name", service.name)
self.assertEqual(expected, mock_get_service.call_args_list)
self.assertEqual(self.context, service._context)
service = objects.Service.get(self.context, _id)
self.assertEqual("first name", service.name)
service.refresh()
self.assertEqual("second name", service.name)
self.assertEqual(expected, mock_get_service.call_args_list)
self.assertEqual(self.context, service._context)
@mock.patch.object(db_api.Connection, 'soft_delete_service')
@mock.patch.object(db_api.Connection, 'get_service_by_id')
def test_soft_delete(self, mock_get_service, mock_soft_delete):
mock_get_service.return_value = self.fake_service
fake_deleted_service = self.fake_service.copy()
fake_deleted_service['deleted_at'] = datetime.datetime.utcnow()
mock_soft_delete.return_value = fake_deleted_service
expected_service = fake_deleted_service.copy()
expected_service['created_at'] = expected_service[
'created_at'].replace(tzinfo=iso8601.iso8601.Utc())
expected_service['deleted_at'] = expected_service[
'deleted_at'].replace(tzinfo=iso8601.iso8601.Utc())
def test_soft_delete(self):
_id = self.fake_service['id']
with mock.patch.object(self.dbapi, 'get_service_by_id',
autospec=True) as mock_get_service:
mock_get_service.return_value = self.fake_service
with mock.patch.object(self.dbapi, 'soft_delete_service',
autospec=True) as mock_soft_delete:
service = objects.Service.get(self.context, _id)
service.soft_delete()
mock_get_service.assert_called_once_with(self.context, _id)
mock_soft_delete.assert_called_once_with(_id)
self.assertEqual(self.context, service._context)
service = objects.Service.get(self.context, _id)
service.soft_delete()
mock_get_service.assert_called_once_with(self.context, _id)
mock_soft_delete.assert_called_once_with(_id)
self.assertEqual(self.context, service._context)
self.assertEqual(expected_service, service.as_dict())