Support datastore version number for creating instance

* Support version number for datastore version flavor and volume type
  association commands.
* Support 'version_number' parameter for creating instance.

Story: 2008358
Task: 41264

Change-Id: I0e30194d65dcaa595b8927e2b9d5f8ec8c4300de

3 files changed, 76 insertions, 43 deletions

diff --git a/trove/tests/unittests/datastore/base.py b/trove/tests/unittests/datastore/base.py
index bf38c09a..f543b77f 100644
--- a/trove/tests/unittests/datastore/base.py
+++ b/trove/tests/unittests/datastore/base.py
@@ -41,15 +41,15 @@ class TestDatastoreBase(trove_testtools.TestCase):
 
         datastore_models.update_datastore_version(
             cls.ds_name, cls.ds_version_name, "mysql", "", "", "", True)
-        DatastoreVersionMetadata.add_datastore_version_flavor_association(
-            cls.ds_name, cls.ds_version_name, [cls.flavor_id])
-        DatastoreVersionMetadata.add_datastore_version_volume_type_association(
-            cls.ds_name, cls.ds_version_name, [cls.volume_type])
-
         cls.datastore_version = DatastoreVersion.load(cls.datastore,
                                                       cls.ds_version_name)
         cls.test_id = cls.datastore_version.id
 
+        DatastoreVersionMetadata.add_datastore_version_flavor_association(
+            cls.datastore_version.id, [cls.flavor_id])
+        DatastoreVersionMetadata.add_datastore_version_volume_type_association(
+            cls.datastore_version.id, [cls.volume_type])
+
         cls.cap1 = Capability.create(cls.capability_name,
                                      cls.capability_desc, True)
         cls.cap2 = Capability.create(
diff --git a/trove/tests/unittests/datastore/test_datastore_version_metadata.py b/trove/tests/unittests/datastore/test_datastore_version_metadata.py
index 2574ef10..964cab0d 100644
--- a/trove/tests/unittests/datastore/test_datastore_version_metadata.py
+++ b/trove/tests/unittests/datastore/test_datastore_version_metadata.py
@@ -57,48 +57,40 @@ class TestDatastoreVersionMetadata(TestDatastoreBase):
 
     def test_add_existing_flavor_associations(self):
         dsmetadata = datastore_models.DatastoreVersionMetadata
-        self.assertRaisesRegex(
+        self.assertRaises(
             exception.DatastoreFlavorAssociationAlreadyExists,
-            "Flavor %s is already associated with datastore %s version %s"
-            % (self.flavor_id, self.ds_name, self.ds_version_name),
             dsmetadata.add_datastore_version_flavor_association,
-            self.ds_name, self.ds_version_name, [self.flavor_id])
+            self.test_id, [self.flavor_id])
 
     def test_add_existing_volume_type_associations(self):
         dsmetadata = datastore_models.DatastoreVersionMetadata
         self.assertRaises(
             exception.DatastoreVolumeTypeAssociationAlreadyExists,
             dsmetadata.add_datastore_version_volume_type_association,
-            self.ds_name, self.ds_version_name, [self.volume_type])
+            self.test_id, [self.volume_type])
 
     def test_delete_nonexistent_flavor_mapping(self):
         dsmeta = datastore_models.DatastoreVersionMetadata
-        self.assertRaisesRegex(
+        self.assertRaises(
             exception.DatastoreFlavorAssociationNotFound,
-            "Flavor 2 is not supported for datastore %s version %s"
-            % (self.ds_name, self.ds_version_name),
             dsmeta.delete_datastore_version_flavor_association,
-            self.ds_name, self.ds_version_name, flavor_id=2)
+            self.test_id, flavor_id=2)
 
     def test_delete_nonexistent_volume_type_mapping(self):
         dsmeta = datastore_models.DatastoreVersionMetadata
         self.assertRaises(
             exception.DatastoreVolumeTypeAssociationNotFound,
             dsmeta.delete_datastore_version_volume_type_association,
-            self.ds_name, self.ds_version_name,
+            self.test_id,
             volume_type_name='some random thing')
 
     def test_delete_flavor_mapping(self):
         flavor_id = 2
         dsmetadata = datastore_models.DatastoreVersionMetadata
         dsmetadata.add_datastore_version_flavor_association(
-            self.ds_name,
-            self.ds_version_name,
-            [flavor_id])
+            self.test_id, [flavor_id])
         dsmetadata.delete_datastore_version_flavor_association(
-            self.ds_name,
-            self.ds_version_name,
-            flavor_id)
+            self.test_id, flavor_id)
         datastore = datastore_models.Datastore.load(self.ds_name)
         ds_version = datastore_models.DatastoreVersion.load(
             datastore,
@@ -108,27 +100,22 @@ class TestDatastoreVersionMetadata(TestDatastoreBase):
         self.assertTrue(mapping.deleted)
         # check update
         dsmetadata.add_datastore_version_flavor_association(
-            self.ds_name, self.ds_version_name, [flavor_id])
+            self.test_id, [flavor_id])
         mapping = datastore_models.DBDatastoreVersionMetadata.find_by(
             datastore_version_id=ds_version.id, value=flavor_id, key='flavor')
         self.assertFalse(mapping.deleted)
         # clear the mapping
         datastore_models.DatastoreVersionMetadata. \
-            delete_datastore_version_flavor_association(self.ds_name,
-                                                        self.ds_version_name,
+            delete_datastore_version_flavor_association(self.test_id,
                                                         flavor_id)
 
     def test_delete_volume_type_mapping(self):
         volume_type = 'this is bogus'
         dsmetadata = datastore_models.DatastoreVersionMetadata
         dsmetadata.add_datastore_version_volume_type_association(
-            self.ds_name,
-            self.ds_version_name,
-            [volume_type])
+            self.test_id, [volume_type])
         dsmetadata.delete_datastore_version_volume_type_association(
-            self.ds_name,
-            self.ds_version_name,
-            volume_type)
+            self.test_id, volume_type)
         datastore = datastore_models.Datastore.load(self.ds_name)
         ds_version = datastore_models.DatastoreVersion.load(
             datastore,
@@ -139,19 +126,17 @@ class TestDatastoreVersionMetadata(TestDatastoreBase):
         self.assertTrue(mapping.deleted)
         # check update
         dsmetadata.add_datastore_version_volume_type_association(
-            self.ds_name, self.ds_version_name, [volume_type])
+            self.test_id, [volume_type])
         mapping = datastore_models.DBDatastoreVersionMetadata.find_by(
             datastore_version_id=ds_version.id, value=volume_type,
             key='volume_type')
         self.assertFalse(mapping.deleted)
         # clear the mapping
         dsmetadata.delete_datastore_version_volume_type_association(
-            self.ds_name,
-            self.ds_version_name,
-            volume_type)
+            self.test_id, volume_type)
 
     @mock.patch.object(datastore_models.DatastoreVersionMetadata,
-                       '_datastore_version_find')
+                       'datastore_version_find')
     @mock.patch.object(datastore_models.DatastoreVersionMetadata,
                        'list_datastore_version_volume_type_associations')
     @mock.patch.object(clients, 'create_cinder_client')
@@ -179,7 +164,7 @@ class TestDatastoreVersionMetadata(TestDatastoreBase):
         mock_list.return_value = mock_trove_list_result
 
         return self.dsmetadata.allowed_datastore_version_volume_types(
-            None, 'ds', 'dsv')
+            None, self.random_uuid())
 
     def _assert_equal_types(self, test_dict, output_obj):
         self.assertEqual(test_dict.get('id'), output_obj.id)
diff --git a/trove/tests/unittests/instance/test_service.py b/trove/tests/unittests/instance/test_service.py
index 07444a4c..a38c62f5 100644
--- a/trove/tests/unittests/instance/test_service.py
+++ b/trove/tests/unittests/instance/test_service.py
@@ -13,7 +13,9 @@
 #    limitations under the License.
 from unittest import mock
 
+from trove.common import cfg
 from trove.common import clients
+from trove.common import exception
 from trove.datastore import models as ds_models
 from trove.instance import models as ins_models
 from trove.instance import service
@@ -21,6 +23,8 @@ from trove.instance import service_status as srvstatus
 from trove.tests.unittests import trove_testtools
 from trove.tests.unittests.util import util
 
+CONF = cfg.CONF
+
 
 class TestInstanceController(trove_testtools.TestCase):
     @classmethod
@@ -37,7 +41,14 @@ class TestInstanceController(trove_testtools.TestCase):
             1)
         ds_models.update_datastore_version(
             cls.ds_name, 'test_image_tags', 'mysql', '', ['trove', 'mysql'],
-            '', 1)
+            '', 1, version='test_image_tags version')
+        ds_models.update_datastore_version(
+            cls.ds_name, 'test_version', 'mysql', '', ['trove'], '', 1,
+            version='version 1')
+        ds_models.update_datastore_version(
+            cls.ds_name, 'test_version', 'mysql', '', ['trove'], '', 1,
+            version='version 2')
+
         cls.ds_version_imageid = ds_models.DatastoreVersion.load(
             cls.ds, 'test_image_id')
         cls.ds_version_imagetags = ds_models.DatastoreVersion.load(
@@ -61,19 +72,22 @@ class TestInstanceController(trove_testtools.TestCase):
     @mock.patch('trove.instance.models.Instance.create')
     def test_create_by_ds_version_image_tags(self, mock_model_create,
                                              mock_create_client):
+        image_id = self.random_uuid()
         mock_glance_client = mock.MagicMock()
-        mock_glance_client.images.list.return_value = [
-            {'id': self.random_uuid()}]
+        mock_glance_client.images.list.return_value = [{'id': image_id}]
         mock_create_client.return_value = mock_glance_client
 
+        name = self.random_name(name='instance',
+                                prefix='TestInstanceController')
+        flavor = self.random_uuid()
         body = {
             'instance': {
-                'name': self.random_name(name='instance',
-                                         prefix='TestInstanceController'),
-                'flavorRef': self.random_uuid(),
+                'name': name,
+                'flavorRef': flavor,
                 'datastore': {
                     'type': self.ds_name,
-                    'version': self.ds_version_imagetags.name
+                    'version': self.ds_version_imagetags.name,
+                    'version_number': self.ds_version_imagetags.version
                 }
             }
         }
@@ -85,6 +99,40 @@ class TestInstanceController(trove_testtools.TestCase):
             sort='created_at:desc', limit=1
         )
 
+        mock_model_create.assert_called_once_with(
+            mock.ANY, name, flavor, image_id,
+            [], [],
+            mock.ANY, mock.ANY,
+            None, None, None, [], None, None,
+            replica_count=None, volume_type=None, modules=None, locality=None,
+            region_name=CONF.service_credentials.region_name, access=None
+        )
+        args = mock_model_create.call_args[0]
+        actual_ds_version = args[7]
+        self.assertEqual(self.ds_version_imagetags.name,
+                         actual_ds_version.name)
+        self.assertEqual(self.ds_version_imagetags.version,
+                         actual_ds_version.version)
+
+    def test_create_multiple_versions(self):
+        body = {
+            'instance': {
+                'name': self.random_name(name='instance',
+                                         prefix='TestInstanceController'),
+                'flavorRef': self.random_uuid(),
+                'datastore': {
+                    'type': self.ds_name,
+                    'version': 'test_version'
+                }
+            }
+        }
+
+        self.assertRaises(
+            exception.DatastoreVersionsNoUniqueMatch,
+            self.controller.create,
+            mock.MagicMock(), body, mock.ANY
+        )
+
     @mock.patch.object(clients, 'create_nova_client',
                        return_value=mock.MagicMock())
     @mock.patch('trove.rpc.get_client')