Refactor OS::Trove::Instance resource tests

Refactor trove instance tests and rename os_database
module to actual name "instance".

Change-Id: Ie84a0f32f8228b7fe83e1a4945512c3440d9e45c

2 files changed, 228 insertions, 410 deletions

diff --git a/heat/engine/resources/openstack/trove/os_database.py b/heat/engine/resources/openstack/trove/instance.py
index b0f94a8f1..eb5a875a4 100644
--- a/heat/engine/resources/openstack/trove/os_database.py
+++ b/heat/engine/resources/openstack/trove/instance.py
@@ -27,7 +27,7 @@ from heat.engine import support
 LOG = logging.getLogger(__name__)
 
 
-class OSDBInstance(resource.Resource):
+class Instance(resource.Resource):
     """OpenStack cloud database instance resource.
 
     Trove is Database as a Service for OpenStack. It's designed to run entirely
@@ -293,7 +293,7 @@ class OSDBInstance(resource.Resource):
     entity = 'instances'
 
     def __init__(self, name, json_snippet, stack):
-        super(OSDBInstance, self).__init__(name, json_snippet, stack)
+        super(Instance, self).__init__(name, json_snippet, stack)
         self._href = None
         self._dbinstance = None
 
@@ -617,7 +617,7 @@ class OSDBInstance(resource.Resource):
 
     def validate(self):
         """Validate any of the provided params."""
-        res = super(OSDBInstance, self).validate()
+        res = super(Instance, self).validate()
         if res:
             return res
 
@@ -684,5 +684,5 @@ class OSDBInstance(resource.Resource):
 
 def resource_mapping():
     return {
-        'OS::Trove::Instance': OSDBInstance,
+        'OS::Trove::Instance': Instance,
     }
diff --git a/heat/tests/openstack/trove/test_os_database.py b/heat/tests/openstack/trove/test_instance.py
index 094e90e91..9836a00c5 100644
--- a/heat/tests/openstack/trove/test_os_database.py
+++ b/heat/tests/openstack/trove/test_instance.py
@@ -14,6 +14,7 @@
 import uuid
 
 import mock
+from oslo_config import cfg
 import six
 from troveclient import exceptions as troveexc
 from troveclient.v1 import users
@@ -24,7 +25,7 @@ from heat.engine.clients.os import neutron
 from heat.engine.clients.os import nova
 from heat.engine.clients.os import trove
 from heat.engine import resource
-from heat.engine.resources.openstack.trove import os_database
+from heat.engine.resources.openstack.trove import instance as dbinstance
 from heat.engine import rsrc_defn
 from heat.engine import scheduler
 from heat.engine import stack as parser
@@ -71,6 +72,20 @@ resources:
           fixed_ip: 1.2.3.4
 '''
 
+db_template_with_replication = '''
+heat_template_version: 2013-05-23
+description: MySQL instance running on openstack DBaaS cloud
+resources:
+  MySqlCloudDB:
+    type: OS::Trove::Instance
+    properties:
+      name: test
+      flavor: 1GB
+      size: 30
+      replica_of: 0e642916-dd64-43b3-933f-ff34fff69a7f
+      replica_count: 2
+'''
+
 
 class FakeDBInstance(object):
     def __init__(self):
@@ -97,61 +112,35 @@ class FakeVersion(object):
         self.name = name
 
 
-class OSDBInstanceTest(common.HeatTestCase):
+class InstanceTest(common.HeatTestCase):
+
     def setUp(self):
-        super(OSDBInstanceTest, self).setUp()
-        self.fc = self.m.CreateMockAnything()
-        self.nova = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(trove.TroveClientPlugin, '_create')
+        super(InstanceTest, self).setUp()
+        self.fc = mock.MagicMock()
+        self.nova = mock.Mock()
+        self.client = mock.Mock()
+        self.patchobject(trove.TroveClientPlugin, '_create',
+                         return_value=self.client)
         self.stub_TroveFlavorConstraint_validate()
         self.patchobject(resource.Resource, 'is_using_neutron',
                          return_value=True)
-
-    def _setup_test_clouddbinstance(self, name, t):
+        self.flavor_resolve = self.patchobject(trove.TroveClientPlugin,
+                                               'find_flavor_by_name_or_id',
+                                               return_value=1)
+        self.fake_instance = FakeDBInstance()
+        self.client.instances.create.return_value = self.fake_instance
+        self.client.instances.get.return_value = self.fake_instance
+
+    def _setup_test_instance(self, name, t, rsrc_name='MySqlCloudDB'):
         stack_name = '%s_stack' % name
         template = tmpl.Template(t)
         self.stack = parser.Stack(utils.dummy_context(),
                                   stack_name,
                                   template,
                                   stack_id=str(uuid.uuid4()))
-
-        instance = os_database.OSDBInstance(
-            '%s_name' % name,
-            template.resource_definitions(self.stack)['MySqlCloudDB'],
-            self.stack)
-        return instance
-
-    def _stubout_common_create(self):
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.flavors = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(trove.TroveClientPlugin,
-                               'find_flavor_by_name_or_id')
-        trove.TroveClientPlugin.find_flavor_by_name_or_id('1GB').AndReturn(1)
-        self.fc.instances = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.instances, 'create')
-        self.m.StubOutWithMock(self.fc.instances, 'get')
-
-    def _stubout_create(self, instance, fake_dbinstance):
-        self._stubout_common_create()
-        users = [{"name": "testuser", "password": "pass", "host": "%",
-                  "databases": [{"name": "validdb"}]}]
-        databases = [{"collate": "utf8_general_ci",
-                      "character_set": "utf8",
-                      "name": "validdb"}]
-        self.fc.instances.create('test', 1, volume={'size': 30},
-                                 databases=databases,
-                                 users=users,
-                                 restorePoint=None,
-                                 availability_zone=None,
-                                 datastore="SomeDStype",
-                                 datastore_version="MariaDB-5.5",
-                                 nics=[],
-                                 replica_of=None,
-                                 replica_count=None
-                                 ).AndReturn(fake_dbinstance)
-
-    def _stubout_check_create_complete(self, fake_dbinstance):
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(fake_dbinstance)
+        rsrc = self.stack[rsrc_name]
+        rsrc.resource_id = '12345'
+        return rsrc
 
     def _stubout_validate(self, instance, neutron=None,
                           mock_net_constraint=False,
@@ -159,34 +148,23 @@ class OSDBInstanceTest(common.HeatTestCase):
         if mock_net_constraint:
             self.stub_NetworkConstraint_validate()
 
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.datastore_versions = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.datastore_versions, 'list')
-        self.fc.datastore_versions.list(instance.properties['datastore_type']
-                                        ).AndReturn([FakeVersion()])
+        self.client.datastore_versions.list.return_value = [FakeVersion()]
 
         if neutron is not None:
-            self.m.StubOutWithMock(instance, 'is_using_neutron')
-            instance.is_using_neutron().AndReturn(bool(neutron))
+            instance.is_using_neutron = mock.Mock(return_value=bool(neutron))
             if with_port:
                 self.stub_PortConstraint_validate()
-        self.m.ReplayAll()
 
-    def test_osdatabase_create(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_create(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_create', t)
-        self._stubout_create(instance, fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.m.ReplayAll()
+        instance = self._setup_test_instance('dbinstance_create', t)
         scheduler.TaskRunner(instance.create)()
         self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
         self.assertEqual('instances', instance.entity)
-        self.m.VerifyAll()
 
     def test_create_failed(self):
         t = template_format.parse(db_template)
-        osdb_res = self._setup_test_clouddbinstance('dbinstance_create', t)
+        osdb_res = self._setup_test_instance('dbinstance_create', t)
 
         trove_mock = mock.Mock()
         self.patchobject(osdb_res, 'client', return_value=trove_mock)
@@ -227,233 +205,151 @@ class OSDBInstanceTest(common.HeatTestCase):
                                 mock_input)
         self.assertIn(error_string, six.text_type(exc))
 
-    def test_osdatabase_restore_point(self):
-        fake_dbinstance = FakeDBInstance()
+    def _create_failed_bad_status(self, status, error_message):
+        t = template_format.parse(db_template)
+        bad_instance = mock.Mock()
+        bad_instance.status = status
+        self.client.instances.get.return_value = bad_instance
+        instance = self._setup_test_instance('test_bad_statuses', t)
+        ex = self.assertRaises(exception.ResourceInError,
+                               instance.check_create_complete,
+                               self.fake_instance.id)
+        self.assertIn(error_message, six.text_type(ex))
+
+    def test_create_failed_status_error(self):
+        self._create_failed_bad_status(
+            'ERROR', 'Went to status ERROR due to "The last operation for '
+                     'the database instance failed due to an error."')
+
+    def test_create_failed_status_failed(self):
+        self._create_failed_bad_status(
+            'FAILED', 'Went to status FAILED due to "The database instance '
+                      'was created, but heat failed to set up the datastore. '
+                      'If a database instance is in the FAILED state, it '
+                      'should be deleted and a new one should be created."')
+
+    def test_instance_restore_point(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['restore_point'] = "1234"
-        instance = self._setup_test_clouddbinstance('dbinstance_create', t)
-
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.flavors = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.flavors, "get")
-        self.fc.flavors.get(u'1GB').AndRaise(troveexc.NotFound())
-        self.m.StubOutWithMock(self.fc.flavors, "find")
-        self.fc.flavors.find(name=u'1GB').AndReturn(FakeFlavor(1, '1GB'))
-        self.fc.instances = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.instances, 'create')
+        instance = self._setup_test_instance('dbinstance_create', t)
+
+        self.client.flavors.get.side_effect = [troveexc.NotFound()]
+        self.client.flavors.find.return_value = FakeFlavor(1, '1GB')
+
+        scheduler.TaskRunner(instance.create)()
+        self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
+
         users = [{"name": "testuser", "password": "pass", "host": "%",
                   "databases": [{"name": "validdb"}]}]
         databases = [{"collate": "utf8_general_ci",
                       "character_set": "utf8",
                       "name": "validdb"}]
-        self.fc.instances.create('test', 1, volume={'size': 30},
-                                 databases=databases,
-                                 users=users,
-                                 restorePoint={"backupRef": "1234"},
-                                 availability_zone=None,
-                                 datastore="SomeDStype",
-                                 datastore_version="MariaDB-5.5",
-                                 nics=[],
-                                 replica_of=None,
-                                 replica_count=None
-                                 ).AndReturn(fake_dbinstance)
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(fake_dbinstance)
-        self.m.ReplayAll()
-
-        scheduler.TaskRunner(instance.create)()
-        self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
-        self.m.VerifyAll()
+        self.client.instances.create.assert_called_once_with(
+            'test', 1, volume={'size': 30}, databases=databases, users=users,
+            restorePoint={"backupRef": "1234"}, availability_zone=None,
+            datastore="SomeDStype", datastore_version="MariaDB-5.5", nics=[],
+            replica_of=None, replica_count=None)
 
-    def test_osdatabase_create_overlimit(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_create_overlimit(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_create', t)
-
-        self._stubout_create(instance, fake_dbinstance)
+        instance = self._setup_test_instance('dbinstance_create', t)
 
         # Simulate an OverLimit exception
-        self.fc.instances.get(fake_dbinstance.id).AndRaise(
-            troveexc.RequestEntityTooLarge)
-
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(
-            fake_dbinstance)
-
-        self.m.ReplayAll()
+        self.client.instances.get.side_effect = [
+            troveexc.RequestEntityTooLarge(), self.fake_instance]
 
         scheduler.TaskRunner(instance.create)()
         self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
-        self.m.VerifyAll()
 
-    def test_osdatabase_create_fails(self):
-        fake_dbinstance = FakeDBInstance()
-        fake_dbinstance.status = 'ERROR'
+    def test_instance_create_fails(self):
+        cfg.CONF.set_override('action_retry_limit', 0, enforce_type=True)
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_create', t)
-        self._stubout_create(instance, fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.m.ReplayAll()
+        instance = self._setup_test_instance('dbinstance_create', t)
+        self.fake_instance.status = 'ERROR'
         self.assertRaises(exception.ResourceFailure,
                           scheduler.TaskRunner(instance.create))
-        self.m.VerifyAll()
+        # return previous status
+        self.fake_instance.status = 'ACTIVE'
 
     def _get_db_instance(self):
-        fake_dbinstance = FakeDBInstance()
         t = template_format.parse(db_template)
-        res = self._setup_test_clouddbinstance('trove_check', t)
-        res.client = mock.Mock()
-        res.client().instances.get.return_value = fake_dbinstance
+        res = self._setup_test_instance('trove_check', t)
         res.flavor = 'Foo Flavor'
         res.volume = 'Foo Volume'
         res.datastore_type = 'Foo Type'
         res.datastore_version = 'Foo Version'
-        return (res, fake_dbinstance)
+        return res
 
-    def test_osdatabase_check(self):
-        (res, fake_instance) = self._get_db_instance()
+    def test_instance_check(self):
+        res = self._get_db_instance()
         scheduler.TaskRunner(res.check)()
         self.assertEqual((res.CHECK, res.COMPLETE), res.state)
 
-    def test_osdatabase_check_not_active(self):
-        (res, fake_instance) = self._get_db_instance()
-        fake_instance.status = 'FOOBAR'
+    def test_instance_check_not_active(self):
+        res = self._get_db_instance()
+        self.fake_instance.status = 'FOOBAR'
 
         exc = self.assertRaises(exception.ResourceFailure,
                                 scheduler.TaskRunner(res.check))
         self.assertIn('FOOBAR', six.text_type(exc))
         self.assertEqual((res.CHECK, res.FAILED), res.state)
+        # return previous status
+        self.fake_instance.status = 'ACTIVE'
 
-    def test_osdatabase_delete(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_delete(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_del', t)
-        self._stubout_create(instance, fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(fake_dbinstance)
-        self.m.StubOutWithMock(fake_dbinstance, 'delete')
-        fake_dbinstance.delete().AndReturn(None)
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(None)
-        self.fc.instances.get(fake_dbinstance.id).AndRaise(
-            troveexc.NotFound(404))
-
-        self.m.ReplayAll()
+        instance = self._setup_test_instance('dbinstance_del', t)
+        self.client.instances.get.side_effect = [self.fake_instance,
+                                                 troveexc.NotFound(404)]
 
         scheduler.TaskRunner(instance.create)()
         scheduler.TaskRunner(instance.delete)()
-        self.m.VerifyAll()
 
-    def test_osdatabase_delete_overlimit(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_delete_overlimit(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_del', t)
-        self._stubout_create(instance, fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-
-        # delete call
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(fake_dbinstance)
-        self.m.StubOutWithMock(fake_dbinstance, 'delete')
-        fake_dbinstance.delete().AndReturn(None)
+        instance = self._setup_test_instance('dbinstance_del', t)
 
         # Simulate an OverLimit exception
-        self.fc.instances.get(fake_dbinstance.id).AndRaise(
-            troveexc.RequestEntityTooLarge)
-        self.fc.instances.get(fake_dbinstance.id).AndReturn(None)
-        self.fc.instances.get(fake_dbinstance.id).AndRaise(
-            troveexc.NotFound(404))
-
-        self.m.ReplayAll()
+        self.client.instances.get.side_effect = [
+            troveexc.RequestEntityTooLarge(), self.fake_instance,
+            troveexc.NotFound(404)]
 
         scheduler.TaskRunner(instance.create)()
         scheduler.TaskRunner(instance.delete)()
-        self.m.VerifyAll()
 
-    def test_osdatabase_delete_resource_none(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_delete_resource_none(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_del', t)
-        self._stubout_create(instance, fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.m.ReplayAll()
+        instance = self._setup_test_instance('dbinstance_del', t)
         scheduler.TaskRunner(instance.create)()
         instance.resource_id = None
         scheduler.TaskRunner(instance.delete)()
         self.assertIsNone(instance.resource_id)
-        self.m.VerifyAll()
 
-    def test_osdatabase_resource_not_found(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_resource_not_found(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_del', t)
-        self._stubout_create(instance, fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-
-        self.fc.instances.get(fake_dbinstance.id).AndRaise(
-            troveexc.NotFound(404))
-
-        self.m.ReplayAll()
-
+        instance = self._setup_test_instance('dbinstance_del', t)
+        self.client.instances.get.side_effect = [self.fake_instance,
+                                                 troveexc.NotFound(404)]
         scheduler.TaskRunner(instance.create)()
         scheduler.TaskRunner(instance.delete)()
-        self.m.VerifyAll()
 
-    def test_osdatabase_invalid_attribute(self):
+    def test_instance_attributes(self):
+        fake_instance = FakeDBInstance()
+        self.client.instances.create.return_value = fake_instance
+        self.client.instances.get.return_value = fake_instance
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance("db_invalid_attrib", t)
-        attrib = instance._resolve_attribute("invalid_attrib")
-        self.assertIsNone(attrib)
-        self.m.VerifyAll()
+        instance = self._setup_test_instance('attr_test', t)
+        self.assertEqual("testhost", instance.FnGetAtt('hostname'))
+        self.assertEqual("https://adga23dd432a.rackspacecloud.com/132345245",
+                         instance.FnGetAtt('href'))
 
-    def test_osdatabase_get_hostname(self):
-        fake_dbinstance = FakeDBInstance()
-        t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        instance.resource_id = 12345
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.instances = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.instances, 'get')
-        self.fc.instances.get(12345).AndReturn(fake_dbinstance)
-        self.m.ReplayAll()
-        attrib = instance._resolve_attribute('hostname')
-        self.assertEqual(fake_dbinstance.hostname, attrib)
-        self.m.VerifyAll()
-
-    def test_osdatabase_get_href(self):
-        fake_dbinstance = FakeDBInstance()
-        t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        instance.resource_id = 12345
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.instances = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.instances, 'get')
-        self.fc.instances.get(12345).AndReturn(fake_dbinstance)
-        self.m.ReplayAll()
-        attrib = instance._resolve_attribute('href')
-        self.assertEqual(fake_dbinstance.links[0]['href'], attrib)
-        self.m.VerifyAll()
-
-    def test_osdatabase_get_href_links_none(self):
-        fake_dbinstance = FakeDBInstance()
-        fake_dbinstance.links = None
-        t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        instance.resource_id = 12345
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.instances = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.instances, 'get')
-        self.fc.instances.get(12345).AndReturn(fake_dbinstance)
-        self.m.ReplayAll()
-        attrib = instance._resolve_attribute('href')
-        self.assertIsNone(attrib)
-        self.m.VerifyAll()
-
-    def test_osdatabase_prop_validation_success(self):
+    def test_instance_validation_success(self):
         t = template_format.parse(db_template)
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
-        ret = instance.validate()
-        self.assertIsNone(ret)
-        self.m.VerifyAll()
+        self.assertIsNone(instance.validate())
 
-    def test_osdatabase_prop_validation_invaliddb(self):
+    def test_instance_validation_invalid_db(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['databases'] = [
             {"name": "onedb"}]
@@ -461,12 +357,15 @@ class OSDBInstanceTest(common.HeatTestCase):
             {"name": "testuser",
              "password": "pass",
              "databases": ["invaliddb"]}]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
-        self.assertRaises(exception.StackValidationFailed, instance.validate)
-        self.m.VerifyAll()
+        ex = self.assertRaises(exception.StackValidationFailed,
+                               instance.validate)
+        self.assertEqual("Database ['invaliddb'] specified for user does not "
+                         "exist in databases for resource MySqlCloudDB.",
+                         six.text_type(ex))
 
-    def test_osdatabase_prop_validation_db_name_hyphens(self):
+    def test_instance_validation_db_name_hyphens(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['databases'] = [
             {"name": "-foo-bar-"}]
@@ -474,71 +373,72 @@ class OSDBInstanceTest(common.HeatTestCase):
             {"name": "testuser",
              "password": "pass",
              "databases": ["-foo-bar-"]}]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
         self.assertIsNone(instance.validate())
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_users_none(self):
+    def test_instance_validation_users_none(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['users'] = []
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
-        ret = instance.validate()
-        self.assertIsNone(ret)
-        self.m.VerifyAll()
+        self.assertIsNone(instance.validate())
 
-    def test_osdatabase_prop_validation_databases_none(self):
+    def test_instance_validation_databases_none(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['databases'] = []
         t['Resources']['MySqlCloudDB']['Properties']['users'] = [
             {"name": "testuser",
              "password": "pass",
              "databases": ["invaliddb"]}]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
-        self.assertRaises(exception.StackValidationFailed, instance.validate)
-        self.m.VerifyAll()
+        ex = self.assertRaises(exception.StackValidationFailed,
+                               instance.validate)
+        self.assertEqual('Databases property is required if users property '
+                         'is provided for resource MySqlCloudDB.',
+                         six.text_type(ex))
 
-    def test_osdatabase_prop_validation_user_no_db(self):
+    def test_instance_validation_user_no_db(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['databases'] = [
             {"name": "validdb"}]
         t['Resources']['MySqlCloudDB']['Properties']['users'] = [
             {"name": "testuser", "password": "pass", "databases": []}]
 
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        self.assertRaises(exception.StackValidationFailed, instance.validate)
-        self.m.VerifyAll()
+        instance = self._setup_test_instance('dbinstance_test', t)
+        ex = self.assertRaises(exception.StackValidationFailed,
+                               instance.validate)
+        self.assertEqual('Property error: '
+                         'Resources.MySqlCloudDB.Properties.'
+                         'users[0].databases: length (0) is out of range '
+                         '(min: 1, max: None)', six.text_type(ex))
 
-    def test_osdatabase_prop_validation_no_datastore_yes_version(self):
+    def test_instance_validation_no_datastore_yes_version(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties'].pop('datastore_type')
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         ex = self.assertRaises(exception.StackValidationFailed,
                                instance.validate)
         exp_msg = "Not allowed - datastore_version without datastore_type."
         self.assertEqual(exp_msg, six.text_type(ex))
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_no_dsversion(self):
+    def test_instance_validation_no_ds_version(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties'][
             'datastore_type'] = 'mysql'
         t['Resources']['MySqlCloudDB']['Properties'].pop('datastore_version')
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
-
         self.assertIsNone(instance.validate())
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_wrong_dsversion(self):
+    def test_instance_validation_wrong_dsversion(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties'][
             'datastore_type'] = 'mysql'
         t['Resources']['MySqlCloudDB']['Properties'][
             'datastore_version'] = 'SomeVersion'
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance)
 
         ex = self.assertRaises(exception.StackValidationFailed,
@@ -547,33 +447,25 @@ class OSDBInstanceTest(common.HeatTestCase):
                         "mysql is not valid. "
                         "Allowed versions are MariaDB-5.5.")
         self.assertEqual(expected_msg, six.text_type(ex))
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_implicit_version(self):
+    def test_instance_validation_implicit_version(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties'][
             'datastore_type'] = 'mysql'
         t['Resources']['MySqlCloudDB']['Properties'].pop('datastore_version')
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        trove.TroveClientPlugin._create().AndReturn(self.fc)
-        self.fc.datastore_versions = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.fc.datastore_versions, 'list')
-        self.fc.datastore_versions.list(
-            instance.properties['datastore_type']
-        ).AndReturn([FakeVersion(), FakeVersion('MariaDB-5.0')])
-        self.m.ReplayAll()
-
+        instance = self._setup_test_instance('dbinstance_test', t)
+        self.client.datastore_versions.list.return_value = [
+            FakeVersion(), FakeVersion('MariaDB-5.0')]
         self.assertIsNone(instance.validate())
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_net_with_port_fail(self):
+    def test_instance_validation_net_with_port_fail(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['networks'] = [
             {
                 "port": "someportuuid",
                 "network": "somenetuuid"
             }]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance, neutron=True,
                                mock_net_constraint=True)
 
@@ -581,177 +473,103 @@ class OSDBInstanceTest(common.HeatTestCase):
             exception.StackValidationFailed, instance.validate)
         self.assertEqual('Either network or port must be provided.',
                          six.text_type(ex))
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_no_net_no_port_fail(self):
+    def test_instance_validation_no_net_no_port_fail(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['networks'] = [
             {
                 "fixed_ip": "1.2.3.4"
             }]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance, neutron=True, with_port=False)
 
         ex = self.assertRaises(
             exception.StackValidationFailed, instance.validate)
         self.assertEqual('Either network or port must be provided.',
                          six.text_type(ex))
-        self.m.VerifyAll()
 
-    def test_osdatabase_prop_validation_nic_port_on_novanet_fails(self):
+    def test_instance_validation_nic_port_on_novanet_fails(self):
         t = template_format.parse(db_template)
         t['Resources']['MySqlCloudDB']['Properties']['networks'] = [
             {
                 "port": "someportuuid",
             }]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self._stubout_validate(instance, neutron=False)
 
         ex = self.assertRaises(
             exception.StackValidationFailed, instance.validate)
         self.assertEqual('Can not use port property on Nova-network.',
                          six.text_type(ex))
-        self.m.VerifyAll()
 
-    def test_osdatabase_create_with_port(self):
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_create_with_port(self):
         t = template_format.parse(db_template_with_nics)
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        self._stubout_common_create()
-        self.m.StubOutWithMock(neutron.NeutronClientPlugin,
-                               'find_resourceid_by_name_or_id')
-        neutron.NeutronClientPlugin.find_resourceid_by_name_or_id(
-            'port',
-            instance.properties.get(
-                'networks')[0]['port']).AndReturn('someportid')
-
-        self.fc.instances.create('test', 1, volume={'size': 30},
-                                 databases=[],
-                                 users=[],
-                                 restorePoint=None,
-                                 availability_zone=None,
-                                 datastore=None,
-                                 datastore_version=None,
-                                 nics=[{'port-id': 'someportid',
-                                        'v4-fixed-ip': '1.2.3.4'}],
-                                 replica_of=None,
-                                 replica_count=None
-                                 ).AndReturn(fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
+        instance = self._setup_test_instance('dbinstance_test', t)
+        self.patchobject(neutron.NeutronClientPlugin,
+                         'find_resourceid_by_name_or_id',
+                         return_value='someportid')
         self.stub_PortConstraint_validate()
-        self.m.ReplayAll()
 
         scheduler.TaskRunner(instance.create)()
         self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
-        self.m.VerifyAll()
-
-    def test_osdatabase_create_with_net_id(self):
+        self.client.instances.create.assert_called_once_with(
+            'test', 1, volume={'size': 30}, databases=[], users=[],
+            restorePoint=None, availability_zone=None, datastore=None,
+            datastore_version=None, nics=[{'port-id': 'someportid',
+                                           'v4-fixed-ip': '1.2.3.4'}],
+            replica_of=None, replica_count=None)
+
+    def test_instance_create_with_net_id(self):
         net_id = '034aa4d5-0f36-4127-8481-5caa5bfc9403'
-        fake_dbinstance = FakeDBInstance()
         t = template_format.parse(db_template_with_nics)
         t['resources']['MySqlCloudDB']['properties']['networks'] = [
             {'network': net_id}]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self.stub_NetworkConstraint_validate()
-        self._stubout_common_create()
-        self.m.StubOutWithMock(neutron.NeutronClientPlugin,
-                               'find_resourceid_by_name_or_id')
-        neutron.NeutronClientPlugin.find_resourceid_by_name_or_id(
-            'network',
-            instance.properties.get(
-                'networks')[0]['network']).AndReturn(net_id)
-        self.fc.instances.create('test', 1, volume={'size': 30},
-                                 databases=[],
-                                 users=[],
-                                 restorePoint=None,
-                                 availability_zone=None,
-                                 datastore=None,
-                                 datastore_version=None,
-                                 nics=[{'net-id': net_id}],
-                                 replica_of=None,
-                                 replica_count=None
-                                 ).AndReturn(fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.m.ReplayAll()
-
+        self.patchobject(neutron.NeutronClientPlugin,
+                         'find_resourceid_by_name_or_id',
+                         return_value=net_id)
         scheduler.TaskRunner(instance.create)()
         self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
-        self.m.VerifyAll()
+        self.client.instances.create.assert_called_once_with(
+            'test', 1, volume={'size': 30}, databases=[], users=[],
+            restorePoint=None, availability_zone=None, datastore=None,
+            datastore_version=None, nics=[{'net-id': net_id}], replica_of=None,
+            replica_count=None)
 
-    def test_osdatabase_create_with_net_name(self):
-
-        class FakeNet(object):
-            id = 'somenetid'
-
-        fake_dbinstance = FakeDBInstance()
+    def test_instance_create_with_net_name(self):
         t = template_format.parse(db_template_with_nics)
         t['resources']['MySqlCloudDB']['properties']['networks'] = [
             {'network': 'somenetname'}]
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
+        instance = self._setup_test_instance('dbinstance_test', t)
         self.stub_NetworkConstraint_validate()
-        self._stubout_common_create()
         self.patchobject(instance, 'is_using_neutron', return_value=False)
-        self.m.StubOutWithMock(nova.NovaClientPlugin, '_create')
-        nova.NovaClientPlugin._create().AndReturn(self.nova)
-        self.nova.networks = self.m.CreateMockAnything()
-        self.m.StubOutWithMock(self.nova.networks, 'find')
-        self.nova.networks.find(label='somenetname').AndReturn(FakeNet())
-        self.fc.instances.create('test', 1, volume={'size': 30},
-                                 databases=[],
-                                 users=[],
-                                 restorePoint=None,
-                                 availability_zone=None,
-                                 datastore=None,
-                                 datastore_version=None,
-                                 nics=[{'net-id': 'somenetid'}],
-                                 replica_of=None,
-                                 replica_count=None
-                                 ).AndReturn(fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.m.ReplayAll()
+        novaclient = mock.Mock()
+        self.patchobject(nova.NovaClientPlugin, '_create',
+                         return_value=novaclient)
+        fake_net = mock.Mock()
+        fake_net.id = 'somenetid'
+        novaclient.networks.find.return_value = fake_net
 
         scheduler.TaskRunner(instance.create)()
         self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
-        self.m.VerifyAll()
-
-    def test_osdatabase_create_with_replication(self):
-
-        db_template_with_replication = '''
-        heat_template_version: 2013-05-23
-        description: MySQL instance running on openstack DBaaS cloud
-        resources:
-          MySqlCloudDB:
-            type: OS::Trove::Instance
-            properties:
-              name: test
-              flavor: 1GB
-              size: 30
-              replica_of: 0e642916-dd64-43b3-933f-ff34fff69a7f
-              replica_count: 2
-        '''
-
-        fake_dbinstance = FakeDBInstance()
+        self.client.instances.create.assert_called_once_with(
+            'test', 1, volume={'size': 30}, databases=[], users=[],
+            restorePoint=None, availability_zone=None, datastore=None,
+            datastore_version=None, nics=[{'net-id': 'somenetid'}],
+            replica_of=None, replica_count=None)
+
+    def test_instance_create_with_replication(self):
         t = template_format.parse(db_template_with_replication)
-        instance = self._setup_test_clouddbinstance('dbinstance_test', t)
-        self._stubout_common_create()
-        self.fc.instances.create('test', 1, volume={'size': 30},
-                                 databases=[],
-                                 users=[],
-                                 restorePoint=None,
-                                 availability_zone=None,
-                                 datastore=None,
-                                 datastore_version=None,
-                                 nics=[],
-                                 replica_of=("0e642916-dd64-43b3-933f-"
-                                             "ff34fff69a7f"),
-                                 replica_count=2
-                                 ).AndReturn(fake_dbinstance)
-        self._stubout_check_create_complete(fake_dbinstance)
-        self.m.ReplayAll()
+        instance = self._setup_test_instance('dbinstance_test', t)
 
         scheduler.TaskRunner(instance.create)()
         self.assertEqual((instance.CREATE, instance.COMPLETE), instance.state)
-        self.m.VerifyAll()
+        self.client.instances.create.assert_called_once_with(
+            'test', 1, volume={'size': 30}, databases=[], users=[],
+            restorePoint=None, availability_zone=None, datastore=None,
+            datastore_version=None, nics=[],
+            replica_of="0e642916-dd64-43b3-933f-ff34fff69a7f", replica_count=2)
 
 
 @mock.patch.object(resource.Resource, "client_plugin")
@@ -787,18 +605,18 @@ class InstanceUpdateTests(common.HeatTestCase):
             ]
         }
         self._rdef = rsrc_defn.ResourceDefinition('test',
-                                                  os_database.OSDBInstance,
+                                                  dbinstance.Instance,
                                                   properties=testprops)
 
     def test_handle_no_update(self, mock_client, mock_plugin):
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertEqual({}, trove.handle_update(None, None, {}))
 
     def test_handle_update_name(self, mock_client, mock_plugin):
         prop_diff = {
             "name": "changed"
         }
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertEqual(prop_diff, trove.handle_update(None, None, prop_diff))
 
     def test_handle_update_databases(self, mock_client, mock_plugin):
@@ -815,7 +633,7 @@ class InstanceUpdateTests(common.HeatTestCase):
         mbiff = mock.Mock(name='biff')
         mbiff.name = 'biff'
         mget.return_value = [mbar, mbiff]
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         expected = {
             'databases': [
                 {'character_set': 'ascii', 'name': 'bar'},
@@ -841,7 +659,7 @@ class InstanceUpdateTests(common.HeatTestCase):
         mdel = mock.Mock(name='deleted')
         mdel.name = 'deleted'
         uget.list.return_value = [mbaz, mdel]
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         expected = {
             'users': [{
                 'databases': ['bar', 'biff'],
@@ -863,7 +681,7 @@ class InstanceUpdateTests(common.HeatTestCase):
             "flavor": "changed"
         }
         mock_plugin().get_flavor_id.return_value = 1234
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         expected = {
             "flavor": 1234
         }
@@ -873,20 +691,20 @@ class InstanceUpdateTests(common.HeatTestCase):
         prop_diff = {
             "size": 42
         }
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         expected = {
             "size": 42
         }
         self.assertEqual(expected, trove.handle_update(None, None, prop_diff))
 
     def test_check_complete_none(self, mock_client, mock_plugin):
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertTrue(trove.check_update_complete({}))
 
     def test_check_complete_error(self, mock_client, mock_plugin):
         mock_instance = mock.Mock(status="ERROR")
         mock_client().instances.get.return_value = mock_instance
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         exc = self.assertRaises(exception.ResourceInError,
                                 trove.check_update_complete,
                                 {"foo": "bar"})
@@ -898,7 +716,7 @@ class InstanceUpdateTests(common.HeatTestCase):
         mock_client().instances.get.return_value = mock_instance
         mock_plugin().is_client_exception.return_value = True
         mock_plugin().is_over_limit.side_effect = [True, False]
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         with mock.patch.object(trove, "_update_flavor") as mupdate:
             mupdate.side_effect = [Exception("test"),
                                    Exception("No change was requested "
@@ -912,14 +730,14 @@ class InstanceUpdateTests(common.HeatTestCase):
         mock_instance = mock.Mock(status="RESIZING")
         mock_client().instances.get.return_value = mock_instance
         updates = {"foo": "bar"}
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertFalse(trove.check_update_complete(updates))
 
     def test_check_complete_name(self, mock_client, mock_plugin):
         mock_instance = mock.Mock(status="ACTIVE", name="mock_instance")
         mock_client().instances.get.return_value = mock_instance
         updates = {"name": "changed"}
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertFalse(trove.check_update_complete(updates))
         mock_instance.name = "changed"
         self.assertTrue(trove.check_update_complete(updates))
@@ -935,7 +753,7 @@ class InstanceUpdateTests(common.HeatTestCase):
                 {'ACTION': 'CREATE', 'name': 'baz'},
                 {'ACTION': 'DELETE', 'name': 'biff'}
             ]}
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertTrue(trove.check_update_complete(updates))
         mcreate = mock_client().databases.create
         mdelete = mock_client().databases.delete
@@ -968,7 +786,7 @@ class InstanceUpdateTests(common.HeatTestCase):
                 'ACTION': 'DELETE',
                 'name': 'deleted'
             }]}
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertTrue(trove.check_update_complete(updates))
         create_calls = [
             mock.call(mock_instance, [{'password': 'password',
@@ -999,7 +817,7 @@ class InstanceUpdateTests(common.HeatTestCase):
         updates = {
             "flavor": 1234
         }
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertFalse(trove.check_update_complete(updates))
         mock_instance.status = "RESIZING"
         self.assertFalse(trove.check_update_complete(updates))
@@ -1014,7 +832,7 @@ class InstanceUpdateTests(common.HeatTestCase):
         updates = {
             "size": 42
         }
-        trove = os_database.OSDBInstance('test', self._rdef, self._stack)
+        trove = dbinstance.Instance('test', self._rdef, self._stack)
         self.assertFalse(trove.check_update_complete(updates))
         mock_instance.status = "RESIZING"
         self.assertFalse(trove.check_update_complete(updates))