Added goal+strategy ObjectField for AuditTemplate

In this changeset, I added the "goal" and the "strategy "ObjectField
which can either be loaded by setting the new "eager" parameter as True
or not loaded (as before) by setting it to False.
The advantage of introducing this eager parameter is that this way,
we can reduce to a minimum the overhead of DB queries whenever the
related goal is not actually needed.

Change-Id: I97418163f68aea2f1cda80be94e4035f0b3700ae
Partially-Implements: blueprint watcher-versioned-objects

watcher/objects/audit_template.py

@@ -49,7 +49,8 @@ provided as a list of key-value pairs.
 
 from watcher.common import exception
 from watcher.common import utils
-from watcher.db import api as dbapi
+from watcher.db import api as db_api
+from watcher import objects
 from watcher.objects import base
 from watcher.objects import fields as wfields
 
@@ -57,10 +58,12 @@ from watcher.objects import fields as wfields
 @base.WatcherObjectRegistry.register
 class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
                     base.WatcherObjectDictCompat):
-    # Version 1.0: Initial version
-    VERSION = '1.0'
 
-    dbapi = dbapi.get_instance()
+    # Version 1.0: Initial version
+    # Version 1.1: Added 'goal' and 'strategy' object field
+    VERSION = '1.1'
+
+    dbapi = db_api.get_instance()
 
     fields = {
         'id': wfields.IntegerField(),
@@ -70,10 +73,18 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         'scope': wfields.FlexibleListOfDictField(nullable=True),
         'goal_id': wfields.IntegerField(),
         'strategy_id': wfields.IntegerField(nullable=True),
+
+        'goal': wfields.ObjectField('Goal', nullable=True),
+        'strategy': wfields.ObjectField('Strategy', nullable=True),
+    }
+
+    object_fields = {
+        'goal': (objects.Goal, 'goal_id'),
+        'strategy': (objects.Strategy, 'strategy_id'),
     }
 
     @base.remotable_classmethod
-    def get(cls, context, audit_template_id):
+    def get(cls, context, audit_template_id, eager=False):
         """Find an audit template based on its id or uuid
 
         :param context: Security context. NOTE: This should only
@@ -83,17 +94,18 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
                         A context should be set when instantiating the
                         object, e.g.: AuditTemplate(context)
         :param audit_template_id: the id *or* uuid of a audit_template.
+        :param eager: Load object fields if True (Default: False)
         :returns: a :class:`AuditTemplate` object.
         """
         if utils.is_int_like(audit_template_id):
-            return cls.get_by_id(context, audit_template_id)
+            return cls.get_by_id(context, audit_template_id, eager=eager)
         elif utils.is_uuid_like(audit_template_id):
-            return cls.get_by_uuid(context, audit_template_id)
+            return cls.get_by_uuid(context, audit_template_id, eager=eager)
         else:
             raise exception.InvalidIdentity(identity=audit_template_id)
 
     @base.remotable_classmethod
-    def get_by_id(cls, context, audit_template_id):
+    def get_by_id(cls, context, audit_template_id, eager=False):
         """Find an audit template based on its integer id
 
         :param context: Security context. NOTE: This should only
@@ -103,17 +115,17 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
                         A context should be set when instantiating the
                         object, e.g.: AuditTemplate(context)
         :param audit_template_id: the id of a audit_template.
+        :param eager: Load object fields if True (Default: False)
         :returns: a :class:`AuditTemplate` object.
         """
         db_audit_template = cls.dbapi.get_audit_template_by_id(
-            context,
+            context, audit_template_id, eager=eager)
-            audit_template_id)
+        audit_template = cls._from_db_object(
-        audit_template = AuditTemplate._from_db_object(cls(context),
+            cls(context), db_audit_template, eager=eager)
-                                                       db_audit_template)
         return audit_template
 
     @base.remotable_classmethod
-    def get_by_uuid(cls, context, uuid):
+    def get_by_uuid(cls, context, uuid, eager=False):
         """Find an audit template based on uuid
 
         :param context: Security context. NOTE: This should only
@@ -123,29 +135,33 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
                         A context should be set when instantiating the
                         object, e.g.: AuditTemplate(context)
         :param uuid: the uuid of a audit_template.
+        :param eager: Load object fields if True (Default: False)
         :returns: a :class:`AuditTemplate` object.
         """
-        db_audit_template = cls.dbapi.get_audit_template_by_uuid(context, uuid)
+        db_audit_template = cls.dbapi.get_audit_template_by_uuid(
-        audit_template = AuditTemplate._from_db_object(cls(context),
+            context, uuid, eager=eager)
-                                                       db_audit_template)
+        audit_template = cls._from_db_object(
+            cls(context), db_audit_template, eager=eager)
         return audit_template
 
     @base.remotable_classmethod
-    def get_by_name(cls, context, name):
+    def get_by_name(cls, context, name, eager=False):
         """Find an audit template based on name
 
         :param name: the logical name of a audit_template.
         :param context: Security context
+        :param eager: Load object fields if True (Default: False)
         :returns: a :class:`AuditTemplate` object.
         """
-        db_audit_template = cls.dbapi.get_audit_template_by_name(context, name)
+        db_audit_template = cls.dbapi.get_audit_template_by_name(
-        audit_template = AuditTemplate._from_db_object(cls(context),
+            context, name, eager=eager)
-                                                       db_audit_template)
+        audit_template = cls._from_db_object(
+            cls(context), db_audit_template, eager=eager)
         return audit_template
 
     @base.remotable_classmethod
     def list(cls, context, filters=None, limit=None, marker=None,
-             sort_key=None, sort_dir=None):
+             sort_key=None, sort_dir=None, eager=False):
         """Return a list of :class:`AuditTemplate` objects.
 
         :param context: Security context. NOTE: This should only
@@ -159,6 +175,7 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         :param marker: pagination marker for large data sets.
         :param sort_key: column to sort results by.
         :param sort_dir: direction to sort. "asc" or "desc".
+        :param eager: Load object fields if True (Default: False)
         :returns: a list of :class:`AuditTemplate` object.
         """
         db_audit_templates = cls.dbapi.get_audit_template_list(
@@ -167,17 +184,23 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
             limit=limit,
             marker=marker,
             sort_key=sort_key,
-            sort_dir=sort_dir)
+            sort_dir=sort_dir,
+            eager=eager)
 
-        return [cls._from_db_object(cls(context), obj)
+        return [cls._from_db_object(cls(context), obj, eager=eager)
                 for obj in db_audit_templates]
 
     @base.remotable
     def create(self):
-        """Create a :class:`AuditTemplate` record in the DB"""
+        """Create a :class:`AuditTemplate` record in the DB
+
+        :returns: An :class:`AuditTemplate` object.
+        """
         values = self.obj_get_changes()
         db_audit_template = self.dbapi.create_audit_template(values)
-        self._from_db_object(self, db_audit_template)
+        # Note(v-francoise): Always load eagerly upon creation so we can send
+        # notifications containing information about the related relationships
+        self._from_db_object(self, db_audit_template, eager=True)
 
     def destroy(self):
         """Delete the :class:`AuditTemplate` from the DB"""
@@ -197,14 +220,15 @@ class AuditTemplate(base.WatcherPersistentObject, base.WatcherObject,
         self.obj_reset_changes()
 
     @base.remotable
-    def refresh(self):
+    def refresh(self, eager=False):
         """Loads updates for this :class:`AuditTemplate`.
 
         Loads a audit_template with the same uuid from the database and
         checks for updated attributes. Updates are applied from
         the loaded audit_template column by column, if there are any updates.
+        :param eager: Load object fields if True (Default: False)
         """
-        current = self.__class__.get_by_uuid(self._context, uuid=self.uuid)
+        current = self.get_by_uuid(self._context, uuid=self.uuid, eager=eager)
         self.obj_refresh(current)
 
     @base.remotable

watcher/tests/api/v1/test_audit_templates.py

@@ -305,6 +305,7 @@ class TestPatch(FunctionalTestWithSetup):
 
     def setUp(self):
         super(TestPatch, self).setUp()
+        obj_utils.create_test_goal(self.context)
         self.audit_template = obj_utils.create_test_audit_template(
             self.context, strategy_id=None)
 
@@ -598,6 +599,7 @@ class TestDelete(api_base.FunctionalTest):
 
     def setUp(self):
         super(TestDelete, self).setUp()
+        obj_utils.create_test_goal(self.context)
         self.audit_template = obj_utils.create_test_audit_template(
             self.context)
 
@@ -656,7 +658,7 @@ class TestDelete(api_base.FunctionalTest):
         self.assertTrue(response.json['error_message'])
 
 
-class TestAuaditTemplatePolicyEnforcement(api_base.FunctionalTest):
+class TestAuditTemplatePolicyEnforcement(api_base.FunctionalTest):
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
         self.policy.set_rules({
@@ -676,6 +678,7 @@ class TestAuaditTemplatePolicyEnforcement(api_base.FunctionalTest):
             expect_errors=True)
 
     def test_policy_disallow_get_one(self):
+        obj_utils.create_test_goal(self.context)
         audit_template = obj_utils.create_test_audit_template(self.context)
         self._common_policy_check(
             "audit_template:get", self.get_json,
@@ -689,6 +692,7 @@ class TestAuaditTemplatePolicyEnforcement(api_base.FunctionalTest):
             expect_errors=True)
 
     def test_policy_disallow_update(self):
+        obj_utils.create_test_goal(self.context)
         audit_template = obj_utils.create_test_audit_template(self.context)
         self._common_policy_check(
             "audit_template:update", self.patch_json,
@@ -713,6 +717,7 @@ class TestAuaditTemplatePolicyEnforcement(api_base.FunctionalTest):
             audit_template_dict, expect_errors=True)
 
     def test_policy_disallow_delete(self):
+        obj_utils.create_test_goal(self.context)
         audit_template = obj_utils.create_test_audit_template(self.context)
         self._common_policy_check(
             "audit_template:delete", self.delete,

watcher/tests/api/v1/test_audits.py

@@ -78,9 +78,9 @@ class TestListAudit(api_base.FunctionalTest):
 
     def setUp(self):
         super(TestListAudit, self).setUp()
-        obj_utils.create_test_audit_template(self.context)
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
+        obj_utils.create_test_audit_template(self.context)
 
     def test_empty(self):
         response = self.get_json('/audits')
@@ -249,6 +249,8 @@ class TestPatch(api_base.FunctionalTest):
 
     def setUp(self):
         super(TestPatch, self).setUp()
+        obj_utils.create_test_goal(self.context)
+        obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit_template(self.context)
         self.audit = obj_utils.create_test_audit(self.context, )
         p = mock.patch.object(db_api.BaseConnection, 'update_audit')
@@ -345,9 +347,9 @@ class TestPost(api_base.FunctionalTest):
 
     def setUp(self):
         super(TestPost, self).setUp()
-        obj_utils.create_test_audit_template(self.context)
         obj_utils.create_test_goal(self.context)
         obj_utils.create_test_strategy(self.context)
+        obj_utils.create_test_audit_template(self.context)
         p = mock.patch.object(db_api.BaseConnection, 'create_audit')
         self.mock_create_audit = p.start()
         self.mock_create_audit.side_effect = (
@@ -640,6 +642,8 @@ class TestDelete(api_base.FunctionalTest):
 
     def setUp(self):
         super(TestDelete, self).setUp()
+        obj_utils.create_test_goal(self.context)
+        obj_utils.create_test_strategy(self.context)
         obj_utils.create_test_audit_template(self.context)
         self.audit = obj_utils.create_test_audit(self.context)
         p = mock.patch.object(db_api.BaseConnection, 'update_audit')
@@ -677,7 +681,7 @@ class TestDelete(api_base.FunctionalTest):
         self.assertTrue(response.json['error_message'])
 
 
-class TestAuaditPolicyEnforcement(api_base.FunctionalTest):
+class TestAuditPolicyEnforcement(api_base.FunctionalTest):
 
     def _common_policy_check(self, rule, func, *arg, **kwarg):
         self.policy.set_rules({

watcher/tests/db/test_audit_template.py

@@ -225,6 +225,11 @@ class TestDbAuditTemplateFilters(base.DbTestCase):
 
 class DbAuditTemplateTestCase(base.DbTestCase):
 
+    def _create_test_goal(self, **kwargs):
+        goal = utils.get_test_goal(**kwargs)
+        self.dbapi.create_goal(goal)
+        return goal
+
     def _create_test_audit_template(self, **kwargs):
         audit_template = utils.get_test_audit_template(**kwargs)
         self.dbapi.create_audit_template(audit_template)
@@ -268,18 +273,19 @@ class DbAuditTemplateTestCase(base.DbTestCase):
             strategy.as_dict(), eager_audit_template.strategy.as_dict())
 
     def test_get_audit_template_list_with_filters(self):
+        goal = self._create_test_goal(name='DUMMY')
         audit_template1 = self._create_test_audit_template(
             id=1,
             uuid=w_utils.generate_uuid(),
             name='My Audit Template 1',
             description='Description of my audit template 1',
-            goal='DUMMY')
+            goal_id=goal['id'])
         audit_template2 = self._create_test_audit_template(
             id=2,
             uuid=w_utils.generate_uuid(),
             name='My Audit Template 2',
             description='Description of my audit template 2',
-            goal='DUMMY')
+            goal_id=goal['id'])
 
         res = self.dbapi.get_audit_template_list(
             self.context, filters={'name': 'My Audit Template 1'})

watcher/tests/db/test_purge.py

@@ -265,7 +265,7 @@ class TestPurgeCommand(base.DbTestCase):
         with freezegun.freeze_time(self.fake_today):
             # orphan audit template
             audit_template4 = obj_utils.create_test_audit_template(
-                self.context, goal_id=404,  # Does not exist
+                self.context, goal_id=self.goal2.id,  # Does not exist
                 name=self.generate_unique_name(prefix="Audit Template 4 "),
                 strategy_id=None, id=self._generate_id(),
                 uuid=utils.generate_uuid())
@@ -362,7 +362,7 @@ class TestPurgeCommand(base.DbTestCase):
         with freezegun.freeze_time(self.fake_today):
             # orphan audit template
             audit_template4 = obj_utils.create_test_audit_template(
-                self.context, goal_id=404,  # Does not exist
+                self.context, goal_id=self.goal2.id,  # Does not exist
                 name=self.generate_unique_name(prefix="Audit Template 4 "),
                 strategy_id=None, id=self._generate_id(),
                 uuid=utils.generate_uuid())

watcher/tests/db/utils.py

@@ -21,7 +21,7 @@ from watcher import objects
 
 
 def get_test_audit_template(**kwargs):
-    return {
+    audit_template_data = {
         'id': kwargs.get('id', 1),
         'uuid': kwargs.get('uuid', 'e74c40e0-d825-11e2-a28f-0800200c9a66'),
         'goal_id': kwargs.get('goal_id', 1),
@@ -34,6 +34,15 @@ def get_test_audit_template(**kwargs):
         'deleted_at': kwargs.get('deleted_at'),
     }
 
+    # ObjectField doesn't allow None nor dict, so if we want to simulate a
+    # non-eager object loading, the field should not be referenced at all.
+    if kwargs.get('goal'):
+        audit_template_data['goal'] = kwargs.get('goal')
+    if kwargs.get('strategy'):
+        audit_template_data['strategy'] = kwargs.get('strategy')
+
+    return audit_template_data
+
 
 def create_test_audit_template(**kwargs):
     """Create test audit template entry in DB and return AuditTemplate DB object.

watcher/tests/decision_engine/messaging/test_audit_endpoint.py

@@ -27,6 +27,7 @@ from watcher.tests.objects import utils as obj_utils
 class TestAuditEndpoint(base.DbTestCase):
     def setUp(self):
         super(TestAuditEndpoint, self).setUp()
+        self.goal = obj_utils.create_test_goal(self.context)
         self.audit_template = obj_utils.create_test_audit_template(
             self.context)
         self.audit = obj_utils.create_test_audit(

watcher/tests/objects/test_audit_template.py

@@ -17,6 +17,7 @@ import mock
 
 from watcher.common import exception
 from watcher.common import utils as w_utils
+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,135 +25,172 @@ from watcher.tests.db import utils
 
 class TestAuditTemplateObject(base.DbTestCase):
 
+    goal_id = 1
+
+    goal_data = utils.get_test_goal(
+        id=goal_id, uuid=w_utils.generate_uuid(), name="DUMMY")
+
+    scenarios = [
+        ('non_eager', dict(
+            eager=False,
+            fake_audit_template=utils.get_test_audit_template(
+                goal_id=goal_id))),
+        ('eager_with_non_eager_load', dict(
+            eager=True,
+            fake_audit_template=utils.get_test_audit_template(
+                goal_id=goal_id))),
+        ('eager_with_eager_load', dict(
+            eager=True,
+            fake_audit_template=utils.get_test_audit_template(
+                goal_id=goal_id, goal=goal_data))),
+    ]
+
     def setUp(self):
         super(TestAuditTemplateObject, self).setUp()
-        self.fake_audit_template = utils.get_test_audit_template()
+        self.fake_goal = utils.create_test_goal(**self.goal_data)
-        self.fake_goal1 = utils.create_test_goal(
-            id=1, uuid=w_utils.generate_uuid(), name="DUMMY")
-        self.fake_goal2 = utils.create_test_goal(
-            id=2, uuid=w_utils.generate_uuid(), name="BALANCE_LOAD")
 
-    def test_get_by_id(self):
+    def eager_load_audit_template_assert(self, audit_template, goal):
+        if self.eager:
+            self.assertIsNotNone(audit_template.goal)
+            fields_to_check = set(
+                super(objects.Goal, objects.Goal).fields
+            ).symmetric_difference(objects.Goal.fields)
+            db_data = {
+                k: v for k, v in goal.as_dict().items()
+                if k in fields_to_check}
+            object_data = {
+                k: v for k, v in audit_template.goal.as_dict().items()
+                if k in fields_to_check}
+            self.assertEqual(db_data, object_data)
+
+    @mock.patch.object(db_api.Connection, 'get_audit_template_by_id')
+    def test_get_by_id(self, mock_get_audit_template):
+        mock_get_audit_template.return_value = self.fake_audit_template
         audit_template_id = self.fake_audit_template['id']
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_id',
+        audit_template = objects.AuditTemplate.get(
-                               autospec=True) as mock_get_audit_template:
+            self.context, audit_template_id, eager=self.eager)
-            mock_get_audit_template.return_value = self.fake_audit_template
+        mock_get_audit_template.assert_called_once_with(
-            audit_template = objects.AuditTemplate.get(self.context,
+            self.context, audit_template_id, eager=self.eager)
-                                                       audit_template_id)
+        self.assertEqual(self.context, audit_template._context)
-            mock_get_audit_template.assert_called_once_with(
+        self.eager_load_audit_template_assert(audit_template, self.fake_goal)
-                self.context, audit_template_id)
-            self.assertEqual(self.context, audit_template._context)
 
-    def test_get_by_uuid(self):
+    @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
+    def test_get_by_uuid(self, mock_get_audit_template):
+        mock_get_audit_template.return_value = self.fake_audit_template
         uuid = self.fake_audit_template['uuid']
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_uuid',
+        audit_template = objects.AuditTemplate.get(
-                               autospec=True) as mock_get_audit_template:
+            self.context, uuid, eager=self.eager)
-            mock_get_audit_template.return_value = self.fake_audit_template
+        mock_get_audit_template.assert_called_once_with(
-            audit_template = objects.AuditTemplate.get(self.context, uuid)
+            self.context, uuid, eager=self.eager)
-            mock_get_audit_template.assert_called_once_with(self.context, uuid)
+        self.assertEqual(self.context, audit_template._context)
-            self.assertEqual(self.context, audit_template._context)
+        self.eager_load_audit_template_assert(audit_template, self.fake_goal)
 
-    def test_get_by_name(self):
+    @mock.patch.object(db_api.Connection, 'get_audit_template_by_name')
+    def test_get_by_name(self, mock_get_audit_template):
+        mock_get_audit_template.return_value = self.fake_audit_template
         name = self.fake_audit_template['name']
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_name',
+        audit_template = objects.AuditTemplate.get_by_name(
-                               autospec=True) as mock_get_audit_template:
+            self.context, name, eager=self.eager)
-            mock_get_audit_template.return_value = self.fake_audit_template
+        mock_get_audit_template.assert_called_once_with(
-            audit_template = objects.AuditTemplate.get_by_name(
+            self.context, name, eager=self.eager)
-                self.context,
+        self.assertEqual(self.context, audit_template._context)
-                name)
+        self.eager_load_audit_template_assert(audit_template, self.fake_goal)
-            mock_get_audit_template.assert_called_once_with(self.context, name)
-            self.assertEqual(self.context, audit_template._context)
 
     def test_get_bad_id_and_uuid(self):
         self.assertRaises(exception.InvalidIdentity,
                           objects.AuditTemplate.get,
-                          self.context, 'not-a-uuid')
+                          self.context, 'not-a-uuid', eager=self.eager)
 
-    def test_list(self):
+    @mock.patch.object(db_api.Connection, 'get_audit_template_list')
-        with mock.patch.object(self.dbapi, 'get_audit_template_list',
+    def test_list(self, mock_get_list):
-                               autospec=True) as mock_get_list:
+        mock_get_list.return_value = [self.fake_audit_template]
-            mock_get_list.return_value = [self.fake_audit_template]
+        audit_templates = objects.AuditTemplate.list(
-            audit_templates = objects.AuditTemplate.list(self.context)
+            self.context, eager=self.eager)
-            self.assertEqual(1, mock_get_list.call_count)
+        mock_get_list.assert_called_once_with(
-            self.assertEqual(1, len(audit_templates))
+            self.context, eager=self.eager, filters=None, limit=None,
-            self.assertIsInstance(audit_templates[0], objects.AuditTemplate)
+            marker=None, sort_dir=None, sort_key=None)
-            self.assertEqual(self.context, audit_templates[0]._context)
+        self.assertEqual(1, len(audit_templates))
+        self.assertIsInstance(audit_templates[0], objects.AuditTemplate)
+        self.assertEqual(self.context, audit_templates[0]._context)
+        for audit_template in audit_templates:
+            self.eager_load_audit_template_assert(
+                audit_template, self.fake_goal)
 
-    def test_create(self):
+    @mock.patch.object(db_api.Connection, 'update_audit_template')
-        with mock.patch.object(self.dbapi, 'create_audit_template',
+    @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
-                               autospec=True) as mock_create_audit_template:
+    def test_save(self, mock_get_audit_template, mock_update_audit_template):
-            mock_create_audit_template.return_value = self.fake_audit_template
+        mock_get_audit_template.return_value = self.fake_audit_template
-            audit_template = objects.AuditTemplate(self.context,
-                                                   **self.fake_audit_template)
-            audit_template.create()
-            mock_create_audit_template.assert_called_once_with(
-                self.fake_audit_template)
-            self.assertEqual(self.context, audit_template._context)
-
-    def test_destroy(self):
         uuid = self.fake_audit_template['uuid']
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_uuid',
+        audit_template = objects.AuditTemplate.get_by_uuid(
-                               autospec=True) as mock_get_audit_template:
+            self.context, uuid, eager=self.eager)
-            mock_get_audit_template.return_value = self.fake_audit_template
+        audit_template.goal_id = self.fake_goal.id
-            with mock.patch.object(self.dbapi, 'destroy_audit_template',
+        audit_template.save()
-                                   autospec=True) \
-                    as mock_destroy_audit_template:
-                audit_template = objects.AuditTemplate.get_by_uuid(
-                    self.context, uuid)
-                audit_template.destroy()
-                mock_get_audit_template.assert_called_once_with(
-                    self.context, uuid)
-                mock_destroy_audit_template.assert_called_once_with(uuid)
-                self.assertEqual(self.context, audit_template._context)
 
-    def test_save(self):
+        mock_get_audit_template.assert_called_once_with(
+            self.context, uuid, eager=self.eager)
+        mock_update_audit_template.assert_called_once_with(
+            uuid, {'goal_id': self.fake_goal.id})
+        self.assertEqual(self.context, audit_template._context)
+        self.eager_load_audit_template_assert(audit_template, self.fake_goal)
+
+    @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
+    def test_refresh(self, mock_get_audit_template):
+        returns = [dict(self.fake_audit_template, name="first name"),
+                   dict(self.fake_audit_template, name="second name")]
+        mock_get_audit_template.side_effect = returns
         uuid = self.fake_audit_template['uuid']
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_uuid',
+        expected = [mock.call(self.context, uuid, eager=self.eager),
-                               autospec=True) as mock_get_audit_template:
+                    mock.call(self.context, uuid, eager=self.eager)]
-            mock_get_audit_template.return_value = self.fake_audit_template
+        audit_template = objects.AuditTemplate.get(
-            with mock.patch.object(self.dbapi, 'update_audit_template',
+            self.context, uuid, eager=self.eager)
-                                   autospec=True) \
+        self.assertEqual("first name", audit_template.name)
-                    as mock_update_audit_template:
+        audit_template.refresh(eager=self.eager)
-                audit_template = objects.AuditTemplate.get_by_uuid(
+        self.assertEqual("second name", audit_template.name)
-                    self.context, uuid)
+        self.assertEqual(expected, mock_get_audit_template.call_args_list)
-                audit_template.goal_id = self.fake_goal1.id
+        self.assertEqual(self.context, audit_template._context)
-                audit_template.save()
+        self.eager_load_audit_template_assert(audit_template, self.fake_goal)
 
-                mock_get_audit_template.assert_called_once_with(
-                    self.context, uuid)
-                mock_update_audit_template.assert_called_once_with(
-                    uuid, {'goal_id': self.fake_goal1.id})
-                self.assertEqual(self.context, audit_template._context)
 
-    def test_refresh(self):
+class TestCreateDeleteAuditTemplateObject(base.DbTestCase):
+
+    def setUp(self):
+        super(TestCreateDeleteAuditTemplateObject, self).setUp()
+        self.fake_audit_template = utils.get_test_audit_template()
+
+    @mock.patch.object(db_api.Connection, 'create_audit_template')
+    def test_create(self, mock_create_audit_template):
+        goal = utils.create_test_goal()
+        self.fake_audit_template['goal_id'] = goal.id
+        mock_create_audit_template.return_value = self.fake_audit_template
+        audit_template = objects.AuditTemplate(
+            self.context, **self.fake_audit_template)
+        audit_template.create()
+        mock_create_audit_template.assert_called_once_with(
+            self.fake_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
         uuid = self.fake_audit_template['uuid']
-        returns = [dict(self.fake_audit_template,
+        audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid)
-                        goal_id=self.fake_goal1.id),
+        audit_template.soft_delete()
-                   dict(self.fake_audit_template, goal_id=self.fake_goal2.id)]
+        mock_get_audit_template.assert_called_once_with(
-        expected = [mock.call(self.context, uuid),
+            self.context, uuid, eager=False)
-                    mock.call(self.context, uuid)]
+        mock_soft_delete_audit_template.assert_called_once_with(uuid)
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_uuid',
+        self.assertEqual(self.context, audit_template._context)
-                               side_effect=returns,
-                               autospec=True) as mock_get_audit_template:
-            audit_template = objects.AuditTemplate.get(self.context, uuid)
-            self.assertEqual(1, audit_template.goal_id)
-            audit_template.refresh()
-            self.assertEqual(2, audit_template.goal_id)
-            self.assertEqual(expected, mock_get_audit_template.call_args_list)
-            self.assertEqual(self.context, audit_template._context)
 
-    def test_soft_delete(self):
+    @mock.patch.object(db_api.Connection, 'destroy_audit_template')
+    @mock.patch.object(db_api.Connection, 'get_audit_template_by_uuid')
+    def test_destroy(self, mock_get_audit_template,
+                     mock_destroy_audit_template):
+        mock_get_audit_template.return_value = self.fake_audit_template
         uuid = self.fake_audit_template['uuid']
-        with mock.patch.object(self.dbapi, 'get_audit_template_by_uuid',
+        audit_template = objects.AuditTemplate.get_by_uuid(self.context, uuid)
-                               autospec=True) as mock_get_audit_template:
+        audit_template.destroy()
-            mock_get_audit_template.return_value = self.fake_audit_template
+        mock_get_audit_template.assert_called_once_with(
-            with mock.patch.object(self.dbapi, 'soft_delete_audit_template',
+            self.context, uuid, eager=False)
-                                   autospec=True) \
+        mock_destroy_audit_template.assert_called_once_with(uuid)
-                    as mock_soft_delete_audit_template:
+        self.assertEqual(self.context, audit_template._context)
-                audit_template = objects.AuditTemplate.get_by_uuid(
-                    self.context, uuid)
-                audit_template.soft_delete()
-                mock_get_audit_template.assert_called_once_with(
-                    self.context, uuid)
-                mock_soft_delete_audit_template.assert_called_once_with(uuid)
-                self.assertEqual(self.context, audit_template._context)

watcher/tests/objects/test_objects.py

@@ -411,7 +411,7 @@ class TestObject(_LocalTest, _TestObject):
 expected_object_fingerprints = {
     'Goal': '1.0-93881622db05e7b67a65ca885b4a022e',
     'Strategy': '1.1-73f164491bdd4c034f48083a51bdeb7b',
-    'AuditTemplate': '1.0-7432ee4d3ce0c7cbb9d11a4565ee8eb6',
+    'AuditTemplate': '1.1-b291973ffc5efa2c61b24fe34fdccc0b',
     'Audit': '1.0-ebfc5360d019baf583a10a8a27071c97',
     'ActionPlan': '1.0-cc76fd7f0e8479aeff817dd266341de4',
     'Action': '1.0-a78f69c0da98e13e601f9646f6b2f883',