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

52
watcher/db/sqlalchemy/api.py
View File

@@ -291,11 +291,13 @@ class Connection(api.BaseConnection):
query = model_query(model, session=session)
query = add_identity_filter(query, id_)
try:
query.one()
row = query.one()
except exc.NoResultFound:
raise exception.ResourceNotFound(name=model.__name__, id=id_)
query.soft_delete()
row.soft_delete(session)
return row
@staticmethod
def _destroy(model, id_):
@@ -484,7 +486,7 @@ class Connection(api.BaseConnection):
def soft_delete_goal(self, goal_id):
try:
self._soft_delete(models.Goal, goal_id)
return self._soft_delete(models.Goal, goal_id)
except exception.ResourceNotFound:
raise exception.GoalNotFound(goal=goal_id)
@@ -550,7 +552,7 @@ class Connection(api.BaseConnection):
def soft_delete_strategy(self, strategy_id):
try:
self._soft_delete(models.Strategy, strategy_id)
return self._soft_delete(models.Strategy, strategy_id)
except exception.ResourceNotFound:
raise exception.StrategyNotFound(strategy=strategy_id)
@@ -632,7 +634,7 @@ class Connection(api.BaseConnection):
def soft_delete_audit_template(self, audit_template_id):
try:
self._soft_delete(models.AuditTemplate, audit_template_id)
return self._soft_delete(models.AuditTemplate, audit_template_id)
except exception.ResourceNotFound:
raise exception.AuditTemplateNotFound(
audit_template=audit_template_id)
@@ -717,7 +719,7 @@ class Connection(api.BaseConnection):
def soft_delete_audit(self, audit_id):
try:
self._soft_delete(models.Audit, audit_id)
return self._soft_delete(models.Audit, audit_id)
except exception.ResourceNotFound:
raise exception.AuditNotFound(audit=audit_id)
@@ -793,17 +795,10 @@ class Connection(api.BaseConnection):
return ref
def soft_delete_action(self, action_id):
session = get_session()
with session.begin():
query = model_query(models.Action, session=session)
query = add_identity_filter(query, action_id)
try:
query.one()
except exc.NoResultFound:
raise exception.ActionNotFound(action=action_id)
query.soft_delete()
try:
return self._soft_delete(models.Action, action_id)
except exception.ResourceNotFound:
raise exception.ActionNotFound(action=action_id)
# ### ACTION PLANS ### #
@@ -895,17 +890,10 @@ class Connection(api.BaseConnection):
return ref
def soft_delete_action_plan(self, action_plan_id):
session = get_session()
with session.begin():
query = model_query(models.ActionPlan, session=session)
query = add_identity_filter(query, action_plan_id)
try:
query.one()
except exc.NoResultFound:
raise exception.ActionPlanNotFound(action_plan=action_plan_id)
query.soft_delete()
try:
return self._soft_delete(models.ActionPlan, action_plan_id)
except exception.ResourceNotFound:
raise exception.ActionPlanNotFound(action_plan=action_plan_id)
# ### EFFICACY INDICATORS ### #
@@ -973,7 +961,8 @@ class Connection(api.BaseConnection):
def soft_delete_efficacy_indicator(self, efficacy_indicator_id):
try:
self._soft_delete(models.EfficacyIndicator, efficacy_indicator_id)
return self._soft_delete(
models.EfficacyIndicator, efficacy_indicator_id)
except exception.ResourceNotFound:
raise exception.EfficacyIndicatorNotFound(
efficacy_indicator=efficacy_indicator_id)
@@ -1066,7 +1055,8 @@ class Connection(api.BaseConnection):
def soft_delete_scoring_engine(self, scoring_engine_id):
try:
return self._soft_delete(models.ScoringEngine, scoring_engine_id)
return self._soft_delete(
models.ScoringEngine, scoring_engine_id)
except exception.ResourceNotFound:
raise exception.ScoringEngineNotFound(
scoring_engine=scoring_engine_id)
@@ -1131,6 +1121,6 @@ class Connection(api.BaseConnection):
def soft_delete_service(self, service_id):
try:
self._soft_delete(models.Service, service_id)
return self._soft_delete(models.Service, service_id)
except exception.ResourceNotFound:
raise exception.ServiceNotFound(service=service_id)

10
watcher/objects/action.py
View File

@@ -146,8 +146,9 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_action(self.uuid, updates)
db_obj = self.dbapi.update_action(self.uuid, updates)
obj = self._from_db_object(self, db_obj, eager=False)
self.obj_refresh(obj)
self.obj_reset_changes()
@base.remotable
@@ -165,6 +166,9 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable
def soft_delete(self):
"""Soft Delete the Audit from the DB"""
self.dbapi.soft_delete_action(self.uuid)
self.state = State.DELETED
self.save()
db_obj = self.dbapi.soft_delete_action(self.uuid)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)

10
watcher/objects/action_plan.py
View File

@@ -218,8 +218,9 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_action_plan(self.uuid, updates)
db_obj = self.dbapi.update_action_plan(self.uuid, updates)
obj = self._from_db_object(self, db_obj, eager=False)
self.obj_refresh(obj)
self.obj_reset_changes()
@base.remotable
@@ -253,6 +254,9 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
for related_efficacy_indicator in related_efficacy_indicators:
related_efficacy_indicator.soft_delete()
self.dbapi.soft_delete_action_plan(self.uuid)
self.state = State.DELETED
self.save()
db_obj = self.dbapi.soft_delete_action_plan(self.uuid)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)

10
watcher/objects/audit.py
View File

@@ -255,7 +255,10 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_audit(self.uuid, updates)
db_obj = self.dbapi.update_audit(self.uuid, updates)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)
def _notify():
notifications.audit.send_update(
@@ -280,9 +283,12 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable
def soft_delete(self):
"""Soft Delete the Audit from the DB."""
self.dbapi.soft_delete_audit(self.uuid)
self.state = State.DELETED
self.save()
db_obj = self.dbapi.soft_delete_audit(self.uuid)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)
def _notify():
notifications.audit.send_delete(self._context, self)

10
watcher/objects/audit_template.py
View File

@@ -215,8 +215,9 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_audit_template(self.uuid, updates)
db_obj = self.dbapi.update_audit_template(self.uuid, updates)
obj = self._from_db_object(self, db_obj, eager=False)
self.obj_refresh(obj)
self.obj_reset_changes()
@base.remotable
@@ -234,4 +235,7 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable
def soft_delete(self):
"""Soft Delete the :class:`AuditTemplate` from the DB"""
self.dbapi.soft_delete_audit_template(self.uuid)
db_obj = self.dbapi.soft_delete_audit_template(self.uuid)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)

4
watcher/objects/base.py
View File

@@ -123,7 +123,9 @@ class WatcherPersistentObject(object):
the loaded object column by column in comparison with the current
object.
"""
for field in self.fields:
fields = (field for field in self.fields
if field not in self.object_fields)
for field in fields:
if (self.obj_attr_is_set(field) and
self[field] != loaded_object[field]):
self[field] = loaded_object[field]

10
watcher/objects/goal.py
View File

@@ -151,8 +151,9 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_goal(self.id, updates)
db_obj = self.dbapi.update_goal(self.uuid, updates)
obj = self._from_db_object(self, db_obj, eager=False)
self.obj_refresh(obj)
self.obj_reset_changes()
@base.remotable
@@ -169,4 +170,7 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable
def soft_delete(self):
"""Soft Delete the :class:`Goal` from the DB"""
self.dbapi.soft_delete_goal(self.uuid)
db_obj = self.dbapi.soft_delete_goal(self.uuid)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)

10
watcher/objects/scoring_engine.py
View File

@@ -175,8 +175,9 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_scoring_engine(self.id, updates)
db_obj = self.dbapi.update_scoring_engine(self.uuid, updates)
obj = self._from_db_object(self, db_obj, eager=False)
self.obj_refresh(obj)
self.obj_reset_changes()
def refresh(self):
@@ -191,4 +192,7 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
def soft_delete(self):
"""Soft Delete the :class:`ScoringEngine` from the DB"""
self.dbapi.soft_delete_scoring_engine(self.id)
db_obj = self.dbapi.soft_delete_scoring_engine(self.id)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)

10
watcher/objects/service.py
View File

@@ -119,8 +119,9 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
of self.what_changed().
"""
updates = self.obj_get_changes()
self.dbapi.update_service(self.id, updates)
db_obj = self.dbapi.update_service(self.id, updates)
obj = self._from_db_object(self, db_obj, eager=False)
self.obj_refresh(obj)
self.obj_reset_changes()
def refresh(self):
@@ -138,4 +139,7 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
def soft_delete(self):
"""Soft Delete the :class:`Service` from the DB."""
self.dbapi.soft_delete_service(self.id)
db_obj = self.dbapi.soft_delete_service(self.id)
obj = self._from_db_object(
self.__class__(self._context), db_obj, eager=False)
self.obj_refresh(obj)

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())