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 = model_query(model, session=session)
query = add_identity_filter(query, id_) query = add_identity_filter(query, id_)
try: try:
query.one() row = query.one()
except exc.NoResultFound: except exc.NoResultFound:
raise exception.ResourceNotFound(name=model.__name__, id=id_) raise exception.ResourceNotFound(name=model.__name__, id=id_)
query.soft_delete() row.soft_delete(session)
return row
@staticmethod @staticmethod
def _destroy(model, id_): def _destroy(model, id_):
@@ -484,7 +486,7 @@ class Connection(api.BaseConnection):
def soft_delete_goal(self, goal_id): def soft_delete_goal(self, goal_id):
try: try:
self._soft_delete(models.Goal, goal_id) return self._soft_delete(models.Goal, goal_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.GoalNotFound(goal=goal_id) raise exception.GoalNotFound(goal=goal_id)
@@ -550,7 +552,7 @@ class Connection(api.BaseConnection):
def soft_delete_strategy(self, strategy_id): def soft_delete_strategy(self, strategy_id):
try: try:
self._soft_delete(models.Strategy, strategy_id) return self._soft_delete(models.Strategy, strategy_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.StrategyNotFound(strategy=strategy_id) raise exception.StrategyNotFound(strategy=strategy_id)
@@ -632,7 +634,7 @@ class Connection(api.BaseConnection):
def soft_delete_audit_template(self, audit_template_id): def soft_delete_audit_template(self, audit_template_id):
try: try:
self._soft_delete(models.AuditTemplate, audit_template_id) return self._soft_delete(models.AuditTemplate, audit_template_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.AuditTemplateNotFound( raise exception.AuditTemplateNotFound(
audit_template=audit_template_id) audit_template=audit_template_id)
@@ -717,7 +719,7 @@ class Connection(api.BaseConnection):
def soft_delete_audit(self, audit_id): def soft_delete_audit(self, audit_id):
try: try:
self._soft_delete(models.Audit, audit_id) return self._soft_delete(models.Audit, audit_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.AuditNotFound(audit=audit_id) raise exception.AuditNotFound(audit=audit_id)
@@ -793,17 +795,10 @@ class Connection(api.BaseConnection):
return ref return ref
def soft_delete_action(self, action_id): def soft_delete_action(self, action_id):
session = get_session() try:
with session.begin(): return self._soft_delete(models.Action, action_id)
query = model_query(models.Action, session=session) except exception.ResourceNotFound:
query = add_identity_filter(query, action_id) raise exception.ActionNotFound(action=action_id)
try:
query.one()
except exc.NoResultFound:
raise exception.ActionNotFound(action=action_id)
query.soft_delete()
# ### ACTION PLANS ### # # ### ACTION PLANS ### #
@@ -895,17 +890,10 @@ class Connection(api.BaseConnection):
return ref return ref
def soft_delete_action_plan(self, action_plan_id): def soft_delete_action_plan(self, action_plan_id):
session = get_session() try:
with session.begin(): return self._soft_delete(models.ActionPlan, action_plan_id)
query = model_query(models.ActionPlan, session=session) except exception.ResourceNotFound:
query = add_identity_filter(query, action_plan_id) raise exception.ActionPlanNotFound(action_plan=action_plan_id)
try:
query.one()
except exc.NoResultFound:
raise exception.ActionPlanNotFound(action_plan=action_plan_id)
query.soft_delete()
# ### EFFICACY INDICATORS ### # # ### EFFICACY INDICATORS ### #
@@ -973,7 +961,8 @@ class Connection(api.BaseConnection):
def soft_delete_efficacy_indicator(self, efficacy_indicator_id): def soft_delete_efficacy_indicator(self, efficacy_indicator_id):
try: try:
self._soft_delete(models.EfficacyIndicator, efficacy_indicator_id) return self._soft_delete(
models.EfficacyIndicator, efficacy_indicator_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.EfficacyIndicatorNotFound( raise exception.EfficacyIndicatorNotFound(
efficacy_indicator=efficacy_indicator_id) efficacy_indicator=efficacy_indicator_id)
@@ -1066,7 +1055,8 @@ class Connection(api.BaseConnection):
def soft_delete_scoring_engine(self, scoring_engine_id): def soft_delete_scoring_engine(self, scoring_engine_id):
try: try:
return self._soft_delete(models.ScoringEngine, scoring_engine_id) return self._soft_delete(
models.ScoringEngine, scoring_engine_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.ScoringEngineNotFound( raise exception.ScoringEngineNotFound(
scoring_engine=scoring_engine_id) scoring_engine=scoring_engine_id)
@@ -1131,6 +1121,6 @@ class Connection(api.BaseConnection):
def soft_delete_service(self, service_id): def soft_delete_service(self, service_id):
try: try:
self._soft_delete(models.Service, service_id) return self._soft_delete(models.Service, service_id)
except exception.ResourceNotFound: except exception.ResourceNotFound:
raise exception.ServiceNotFound(service=service_id) 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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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() self.obj_reset_changes()
@base.remotable @base.remotable
@@ -165,6 +166,9 @@ class Action(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable @base.remotable
def soft_delete(self): def soft_delete(self):
"""Soft Delete the Audit from the DB""" """Soft Delete the Audit from the DB"""
self.dbapi.soft_delete_action(self.uuid)
self.state = State.DELETED self.state = State.DELETED
self.save() 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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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() self.obj_reset_changes()
@base.remotable @base.remotable
@@ -253,6 +254,9 @@ class ActionPlan(base.WatcherPersistentObject, base.WatcherObject,
for related_efficacy_indicator in related_efficacy_indicators: for related_efficacy_indicator in related_efficacy_indicators:
related_efficacy_indicator.soft_delete() related_efficacy_indicator.soft_delete()
self.dbapi.soft_delete_action_plan(self.uuid)
self.state = State.DELETED self.state = State.DELETED
self.save() 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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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(): def _notify():
notifications.audit.send_update( notifications.audit.send_update(
@@ -280,9 +283,12 @@ class Audit(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable @base.remotable
def soft_delete(self): def soft_delete(self):
"""Soft Delete the Audit from the DB.""" """Soft Delete the Audit from the DB."""
self.dbapi.soft_delete_audit(self.uuid)
self.state = State.DELETED self.state = State.DELETED
self.save() 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(): def _notify():
notifications.audit.send_delete(self._context, self) 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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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() self.obj_reset_changes()
@base.remotable @base.remotable
@@ -234,4 +235,7 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable @base.remotable
def soft_delete(self): def soft_delete(self):
"""Soft Delete the :class:`AuditTemplate` from the DB""" """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 the loaded object column by column in comparison with the current
object. 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 if (self.obj_attr_is_set(field) and
self[field] != loaded_object[field]): self[field] != loaded_object[field]):
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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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() self.obj_reset_changes()
@base.remotable @base.remotable
@@ -169,4 +170,7 @@ class Goal(base.WatcherPersistentObject, base.WatcherObject,
@base.remotable @base.remotable
def soft_delete(self): def soft_delete(self):
"""Soft Delete the :class:`Goal` from the DB""" """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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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() self.obj_reset_changes()
def refresh(self): def refresh(self):
@@ -191,4 +192,7 @@ class ScoringEngine(base.WatcherPersistentObject, base.WatcherObject,
def soft_delete(self): def soft_delete(self):
"""Soft Delete the :class:`ScoringEngine` from the DB""" """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(). of self.what_changed().
""" """
updates = self.obj_get_changes() 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() self.obj_reset_changes()
def refresh(self): def refresh(self):
@@ -138,4 +139,7 @@ class Service(base.WatcherPersistentObject, base.WatcherObject,
def soft_delete(self): def soft_delete(self):
"""Soft Delete the :class:`Service` from the DB.""" """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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
import datetime
import iso8601
import mock import mock
from watcher.common import exception from watcher.common import exception
@@ -100,17 +103,24 @@ class TestActionObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_action_by_uuid') @mock.patch.object(db_api.Connection, 'get_action_by_uuid')
def test_save(self, mock_get_action, mock_update_action): def test_save(self, mock_get_action, mock_update_action):
mock_get_action.return_value = self.fake_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'] uuid = self.fake_action['uuid']
action = objects.Action.get_by_uuid( action = objects.Action.get_by_uuid(
self.context, uuid, eager=self.eager) self.context, uuid, eager=self.eager)
action.state = objects.action.State.SUCCEEDED action.state = objects.action.State.SUCCEEDED
action.save() action.save()
expected_update_at = fake_saved_action['updated_at'].replace(
tzinfo=iso8601.iso8601.Utc())
mock_get_action.assert_called_once_with( mock_get_action.assert_called_once_with(
self.context, uuid, eager=self.eager) self.context, uuid, eager=self.eager)
mock_update_action.assert_called_once_with( mock_update_action.assert_called_once_with(
uuid, {'state': objects.action.State.SUCCEEDED}) uuid, {'state': objects.action.State.SUCCEEDED})
self.assertEqual(self.context, action._context) self.assertEqual(self.context, action._context)
self.assertEqual(expected_update_at, action.updated_at)
@mock.patch.object(db_api.Connection, 'get_action_by_uuid') @mock.patch.object(db_api.Connection, 'get_action_by_uuid')
def test_refresh(self, mock_get_action): 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_strategy = utils.create_test_strategy(name="DUMMY")
self.fake_audit = utils.create_test_audit() self.fake_audit = utils.create_test_audit()
self.fake_action_plan = utils.create_test_action_plan() 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') @mock.patch.object(db_api.Connection, 'create_action')
def test_create(self, mock_create_action): def test_create(self, mock_create_action):
mock_create_action.return_value = self.fake_action mock_create_action.return_value = self.fake_action
action = objects.Action(self.context, **self.fake_action) action = objects.Action(self.context, **self.fake_action)
action.create() action.create()
expected_action = self.fake_action.copy()
mock_create_action.assert_called_once_with(self.fake_action) 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) self.assertEqual(self.context, action._context)
@mock.patch.object(db_api.Connection, 'update_action') @mock.patch.object(db_api.Connection, 'update_action')
@@ -153,6 +166,18 @@ class TestCreateDeleteActionObject(base.DbTestCase):
def test_soft_delete(self, mock_get_action, def test_soft_delete(self, mock_get_action,
mock_soft_delete_action, mock_update_action): mock_soft_delete_action, mock_update_action):
mock_get_action.return_value = self.fake_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'] uuid = self.fake_action['uuid']
action = objects.Action.get_by_uuid(self.context, uuid) action = objects.Action.get_by_uuid(self.context, uuid)
action.soft_delete() action.soft_delete()
@@ -162,6 +187,7 @@ class TestCreateDeleteActionObject(base.DbTestCase):
mock_update_action.assert_called_once_with( mock_update_action.assert_called_once_with(
uuid, {'state': objects.action.State.DELETED}) uuid, {'state': objects.action.State.DELETED})
self.assertEqual(self.context, action._context) 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, 'destroy_action')
@mock.patch.object(db_api.Connection, 'get_action_by_uuid') @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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
import datetime
import iso8601
import mock import mock
from watcher.common import exception from watcher.common import exception
@@ -109,6 +112,9 @@ class TestActionPlanObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid') @mock.patch.object(db_api.Connection, 'get_action_plan_by_uuid')
def test_save(self, mock_get_action_plan, mock_update_action_plan): def test_save(self, mock_get_action_plan, mock_update_action_plan):
mock_get_action_plan.return_value = self.fake_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'] uuid = self.fake_action_plan['uuid']
action_plan = objects.ActionPlan.get_by_uuid( action_plan = objects.ActionPlan.get_by_uuid(
self.context, uuid, eager=self.eager) self.context, uuid, eager=self.eager)
@@ -146,7 +152,8 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
super(TestCreateDeleteActionPlanObject, self).setUp() super(TestCreateDeleteActionPlanObject, self).setUp()
self.fake_strategy = utils.create_test_strategy(name="DUMMY") self.fake_strategy = utils.create_test_strategy(name="DUMMY")
self.fake_audit = utils.create_test_audit() 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') @mock.patch.object(db_api.Connection, 'create_action_plan')
def test_create(self, mock_create_action_plan): def test_create(self, mock_create_action_plan):
@@ -154,8 +161,10 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
action_plan = objects.ActionPlan( action_plan = objects.ActionPlan(
self.context, **self.fake_action_plan) self.context, **self.fake_action_plan)
action_plan.create() action_plan.create()
mock_create_action_plan.assert_called_once_with( expected_action_plan = self.fake_action_plan.copy()
self.fake_action_plan) 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) self.assertEqual(self.context, action_plan._context)
@mock.patch.multiple( @mock.patch.multiple(
@@ -178,7 +187,20 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
m_get_efficacy_indicator_list = get_efficacy_indicator_list m_get_efficacy_indicator_list = get_efficacy_indicator_list
m_soft_delete_efficacy_indicator = soft_delete_efficacy_indicator m_soft_delete_efficacy_indicator = soft_delete_efficacy_indicator
m_update_action_plan = update_action_plan m_update_action_plan = update_action_plan
m_get_action_plan.return_value = self.fake_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] m_get_efficacy_indicator_list.return_value = [efficacy_indicator]
action_plan = objects.ActionPlan.get_by_uuid(self.context, uuid) action_plan = objects.ActionPlan.get_by_uuid(self.context, uuid)
action_plan.soft_delete() action_plan.soft_delete()
@@ -193,7 +215,9 @@ class TestCreateDeleteActionPlanObject(base.DbTestCase):
efficacy_indicator['uuid']) efficacy_indicator['uuid'])
m_update_action_plan.assert_called_once_with( m_update_action_plan.assert_called_once_with(
uuid, {'state': objects.action_plan.State.DELETED}) uuid, {'state': objects.action_plan.State.DELETED})
self.assertEqual(self.context, action_plan._context) self.assertEqual(self.context, action_plan._context)
self.assertEqual(expected_action_plan, action_plan.as_dict())
@mock.patch.multiple( @mock.patch.multiple(
db_api.Connection, 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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
import datetime
import iso8601
import mock import mock
from watcher.common import exception from watcher.common import exception
@@ -37,14 +40,18 @@ class TestAuditObject(base.DbTestCase):
('non_eager', dict( ('non_eager', dict(
eager=False, eager=False,
fake_audit=utils.get_test_audit( fake_audit=utils.get_test_audit(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))), goal_id=goal_id))),
('eager_with_non_eager_load', dict( ('eager_with_non_eager_load', dict(
eager=True, eager=True,
fake_audit=utils.get_test_audit( fake_audit=utils.get_test_audit(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))), goal_id=goal_id))),
('eager_with_eager_load', dict( ('eager_with_eager_load', dict(
eager=True, 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): def setUp(self):
@@ -116,6 +123,17 @@ class TestAuditObject(base.DbTestCase):
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid') @mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
def test_save(self, mock_get_audit, mock_update_audit): def test_save(self, mock_get_audit, mock_update_audit):
mock_get_audit.return_value = self.fake_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'] uuid = self.fake_audit['uuid']
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=self.eager) audit = objects.Audit.get_by_uuid(self.context, uuid, eager=self.eager)
audit.state = objects.audit.State.SUCCEEDED audit.state = objects.audit.State.SUCCEEDED
@@ -129,6 +147,11 @@ class TestAuditObject(base.DbTestCase):
self.eager_load_audit_assert(audit, self.fake_goal) self.eager_load_audit_assert(audit, self.fake_goal)
self.m_send_update.assert_called_once_with( self.m_send_update.assert_called_once_with(
self.context, audit, old_state=self.fake_audit['state']) 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') @mock.patch.object(db_api.Connection, 'get_audit_by_uuid')
def test_refresh(self, mock_get_audit): def test_refresh(self, mock_get_audit):
@@ -160,14 +183,18 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
self.goal_id = 1 self.goal_id = 1
self.goal = utils.create_test_goal(id=self.goal_id, name="DUMMY") 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') @mock.patch.object(db_api.Connection, 'create_audit')
def test_create(self, mock_create_audit): def test_create(self, mock_create_audit):
mock_create_audit.return_value = self.fake_audit mock_create_audit.return_value = self.fake_audit
audit = objects.Audit(self.context, **self.fake_audit) audit = objects.Audit(self.context, **self.fake_audit)
audit.create() 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) self.assertEqual(self.context, audit._context)
@mock.patch.object(db_api.Connection, 'update_audit') @mock.patch.object(db_api.Connection, 'update_audit')
@@ -176,13 +203,27 @@ class TestCreateDeleteAuditObject(base.DbTestCase):
def test_soft_delete(self, mock_get_audit, def test_soft_delete(self, mock_get_audit,
mock_soft_delete_audit, mock_update_audit): mock_soft_delete_audit, mock_update_audit):
mock_get_audit.return_value = self.fake_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'] 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() 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_soft_delete_audit.assert_called_once_with(uuid)
mock_update_audit.assert_called_once_with(uuid, {'state': 'DELETED'}) mock_update_audit.assert_called_once_with(uuid, {'state': 'DELETED'})
self.assertEqual(self.context, audit._context) 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, 'destroy_audit')
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid') @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.m_notifier = self.m_get_notifier.return_value
self.addCleanup(p_get_notifier.stop) 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') @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( fake_audit = utils.get_test_audit(
goal=self.fake_goal.as_dict(), goal=self.fake_goal.as_dict(),
strategy_id=self.fake_strategy.id, strategy_id=self.fake_strategy.id,
strategy=self.fake_strategy.as_dict()) strategy=self.fake_strategy.as_dict())
m_get_audit.return_value = fake_audit 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'] uuid = fake_audit['uuid']
audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True) audit = objects.Audit.get_by_uuid(self.context, uuid, eager=True)
@@ -249,17 +293,25 @@ class TestAuditObjectSendNotifications(base.DbTestCase):
self.assertEqual('audit.create', self.assertEqual('audit.create',
self.m_notifier.info.call_args[1]['event_type']) 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.patch.object(db_api.Connection, 'update_audit', mock.Mock()) @mock.patch.object(db_api.Connection, 'soft_delete_audit')
@mock.patch.object(db_api.Connection, 'get_audit_by_uuid') @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( fake_audit = utils.get_test_audit(
goal=self.fake_goal.as_dict(), goal=self.fake_goal.as_dict(),
strategy_id=self.fake_strategy.id, strategy_id=self.fake_strategy.id,
strategy=self.fake_strategy.as_dict()) strategy=self.fake_strategy.as_dict())
m_get_audit.return_value = fake_audit 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 = objects.Audit.get_by_uuid(self.context, uuid, eager=True)
audit.soft_delete() 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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
import datetime
import iso8601
import mock import mock
from watcher.common import exception from watcher.common import exception
@@ -34,14 +37,17 @@ class TestAuditTemplateObject(base.DbTestCase):
('non_eager', dict( ('non_eager', dict(
eager=False, eager=False,
fake_audit_template=utils.get_test_audit_template( fake_audit_template=utils.get_test_audit_template(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))), goal_id=goal_id))),
('eager_with_non_eager_load', dict( ('eager_with_non_eager_load', dict(
eager=True, eager=True,
fake_audit_template=utils.get_test_audit_template( fake_audit_template=utils.get_test_audit_template(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id))), goal_id=goal_id))),
('eager_with_eager_load', dict( ('eager_with_eager_load', dict(
eager=True, eager=True,
fake_audit_template=utils.get_test_audit_template( fake_audit_template=utils.get_test_audit_template(
created_at=datetime.datetime.utcnow(),
goal_id=goal_id, goal=goal_data))), 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') @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
def test_save(self, mock_get_audit_template, mock_update_audit_template): def test_save(self, mock_get_audit_template, mock_update_audit_template):
mock_get_audit_template.return_value = self.fake_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'] uuid = self.fake_audit_template['uuid']
audit_template = objects.AuditTemplate.get_by_uuid( audit_template = objects.AuditTemplate.get_by_uuid(
self.context, uuid, eager=self.eager) self.context, uuid, eager=self.eager)
@@ -155,7 +164,8 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
def setUp(self): def setUp(self):
super(TestCreateDeleteAuditTemplateObject, self).setUp() 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') @mock.patch.object(db_api.Connection, 'create_audit_template')
def test_create(self, mock_create_audit_template): def test_create(self, mock_create_audit_template):
@@ -165,22 +175,38 @@ class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
audit_template = objects.AuditTemplate( audit_template = objects.AuditTemplate(
self.context, **self.fake_audit_template) self.context, **self.fake_audit_template)
audit_template.create() 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( mock_create_audit_template.assert_called_once_with(
self.fake_audit_template) expected_audit_template)
self.assertEqual(self.context, audit_template._context) self.assertEqual(self.context, audit_template._context)
@mock.patch.object(db_api.Connection, 'soft_delete_audit_template') @mock.patch.object(db_api.Connection, 'soft_delete_audit_template')
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid') @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
def test_soft_delete(self, mock_get_audit_template, def test_soft_delete(self, m_get_audit_template,
mock_soft_delete_audit_template): m_soft_delete_audit_template):
mock_get_audit_template.return_value = self.fake_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'] uuid = self.fake_audit_template['uuid']
audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid) audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid)
audit_template.soft_delete() 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) 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(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, 'destroy_audit_template')
@mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid') @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 # License for the specific language governing permissions and limitations
# under the License. # under the License.
import datetime
import iso8601
import mock import mock
from watcher.db.sqlalchemy import api as db_api
from watcher import objects from watcher import objects
from watcher.tests.db import base from watcher.tests.db import base
from watcher.tests.db import utils from watcher.tests.db import utils
@@ -24,115 +28,116 @@ class TestGoalObject(base.DbTestCase):
def setUp(self): def setUp(self):
super(TestGoalObject, self).setUp() 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'] goal_id = self.fake_goal['id']
with mock.patch.object(self.dbapi, 'get_goal_by_id', mock_get_goal.return_value = self.fake_goal
autospec=True) as mock_get_goal: goal = objects.Goal.get(self.context, goal_id)
mock_get_goal.return_value = self.fake_goal mock_get_goal.assert_called_once_with(self.context, goal_id)
goal = objects.Goal.get(self.context, goal_id) self.assertEqual(self.context, goal._context)
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'] uuid = self.fake_goal['uuid']
with mock.patch.object(self.dbapi, 'get_goal_by_uuid', mock_get_goal.return_value = self.fake_goal
autospec=True) as mock_get_goal: goal = objects.Goal.get(self.context, uuid)
mock_get_goal.return_value = self.fake_goal mock_get_goal.assert_called_once_with(self.context, uuid)
goal = objects.Goal.get(self.context, uuid) self.assertEqual(self.context, goal._context)
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'] name = self.fake_goal['name']
with mock.patch.object(self.dbapi, 'get_goal_by_name', mock_get_goal.return_value = self.fake_goal
autospec=True) as mock_get_goal: goal = objects.Goal.get_by_name(self.context, name)
mock_get_goal.return_value = self.fake_goal mock_get_goal.assert_called_once_with(self.context, name)
goal = objects.Goal.get_by_name( self.assertEqual(self.context, goal._context)
self.context,
name)
mock_get_goal.assert_called_once_with(self.context, name)
self.assertEqual(self.context, goal._context)
def test_list(self): @mock.patch.object(db_api.Connection, 'get_goal_list')
with mock.patch.object(self.dbapi, 'get_goal_list', def test_list(self, mock_get_list):
autospec=True) as mock_get_list: mock_get_list.return_value = [self.fake_goal]
mock_get_list.return_value = [self.fake_goal] goals = objects.Goal.list(self.context)
goals = objects.Goal.list(self.context) self.assertEqual(1, mock_get_list.call_count)
self.assertEqual(1, mock_get_list.call_count) self.assertEqual(1, len(goals))
self.assertEqual(1, len(goals)) self.assertIsInstance(goals[0], objects.Goal)
self.assertIsInstance(goals[0], objects.Goal) self.assertEqual(self.context, goals[0]._context)
self.assertEqual(self.context, goals[0]._context)
def test_create(self): @mock.patch.object(db_api.Connection, 'create_goal')
with mock.patch.object(self.dbapi, 'create_goal', def test_create(self, mock_create_goal):
autospec=True) as mock_create_goal: mock_create_goal.return_value = self.fake_goal
mock_create_goal.return_value = self.fake_goal goal = objects.Goal(self.context, **self.fake_goal)
goal = objects.Goal(self.context, **self.fake_goal) goal.create()
goal.create() expected_goal = self.fake_goal.copy()
mock_create_goal.assert_called_once_with(self.fake_goal) expected_goal['created_at'] = expected_goal['created_at'].replace(
self.assertEqual(self.context, goal._context) 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'] goal_id = self.fake_goal['id']
with mock.patch.object(self.dbapi, 'get_goal_by_id', mock_get_goal.return_value = self.fake_goal
autospec=True) as mock_get_goal: goal = objects.Goal.get_by_id(self.context, goal_id)
mock_get_goal.return_value = self.fake_goal goal.destroy()
with mock.patch.object(self.dbapi, 'destroy_goal', mock_get_goal.assert_called_once_with(
autospec=True) \ self.context, goal_id)
as mock_destroy_goal: mock_destroy_goal.assert_called_once_with(goal_id)
goal = objects.Goal.get_by_id(self.context, goal_id) self.assertEqual(self.context, goal._context)
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): @mock.patch.object(db_api.Connection, 'update_goal')
goal_id = self.fake_goal['id'] @mock.patch.object(db_api.Connection, 'get_goal_by_uuid')
with mock.patch.object(self.dbapi, 'get_goal_by_id', def test_save(self, mock_get_goal, mock_update_goal):
autospec=True) as mock_get_goal: mock_get_goal.return_value = self.fake_goal
mock_get_goal.return_value = self.fake_goal goal_uuid = self.fake_goal['uuid']
with mock.patch.object(self.dbapi, 'update_goal', fake_saved_goal = self.fake_goal.copy()
autospec=True) as mock_update_goal: fake_saved_goal['updated_at'] = datetime.datetime.utcnow()
goal = objects.Goal.get_by_id(self.context, goal_id) mock_update_goal.return_value = fake_saved_goal
goal.display_name = 'DUMMY'
goal.save()
mock_get_goal.assert_called_once_with(self.context, goal_id) goal = objects.Goal.get_by_uuid(self.context, goal_uuid)
mock_update_goal.assert_called_once_with( goal.display_name = 'DUMMY'
goal_id, {'display_name': 'DUMMY'}) goal.save()
self.assertEqual(self.context, goal._context)
def test_refresh(self): mock_get_goal.assert_called_once_with(self.context, goal_uuid)
uuid = self.fake_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") fake_goal2 = utils.get_test_goal(name="BALANCE_LOAD")
returns = [self.fake_goal, fake_goal2] returns = [self.fake_goal, fake_goal2]
mock_get_goal.side_effect = returns
uuid = self.fake_goal['uuid']
expected = [mock.call(self.context, uuid), expected = [mock.call(self.context, uuid),
mock.call(self.context, uuid)] mock.call(self.context, uuid)]
with mock.patch.object(self.dbapi, 'get_goal_by_uuid', goal = objects.Goal.get(self.context, uuid)
side_effect=returns, self.assertEqual("TEST", goal.name)
autospec=True) as mock_get_goal: goal.refresh()
goal = objects.Goal.get(self.context, uuid) self.assertEqual("BALANCE_LOAD", goal.name)
self.assertEqual("TEST", goal.name) self.assertEqual(expected, mock_get_goal.call_args_list)
goal.refresh() self.assertEqual(self.context, goal._context)
self.assertEqual("BALANCE_LOAD", goal.name)
self.assertEqual(expected, mock_get_goal.call_args_list) @mock.patch.object(db_api.Connection, 'soft_delete_goal')
self.assertEqual(self.context, goal._context) @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'] uuid = self.fake_goal['uuid']
with mock.patch.object(self.dbapi, 'get_goal_by_uuid', goal = objects.Goal.get_by_uuid(self.context, uuid)
autospec=True) as mock_get_goal: goal.soft_delete()
mock_get_goal.return_value = self.fake_goal mock_get_goal.assert_called_once_with(self.context, uuid)
with mock.patch.object(self.dbapi, 'soft_delete_goal', mock_soft_delete_goal.assert_called_once_with(uuid)
autospec=True) \ self.assertEqual(self.context, goal._context)
as mock_soft_delete_goal: self.assertEqual(expected_goal, goal.as_dict())
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)

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

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

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

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