Merge "Use constants for microversion values"

cinder/api/common.py

@@ -24,6 +24,7 @@ from oslo_log import log as logging
 from six.moves import urllib
 import webob
 
+from cinder.api import microversions as mv
 from cinder.common import constants
 from cinder import exception
 from cinder.i18n import _
@@ -66,8 +67,6 @@ CONF.register_opts(api_common_opts)
 
 LOG = logging.getLogger(__name__)
 _FILTERS_COLLECTION = None
-FILTERING_VERSION = '3.31'
-LIKE_FILTER_VERSION = '3.34'
 
 ATTRIBUTE_CONVERTERS = {'name~': 'display_name~',
                         'description~': 'display_description~'}
@@ -492,9 +491,9 @@ def process_general_filtering(resource):
             req_version = kwargs.get('req_version')
             filters = kwargs.get('filters')
             context = kwargs.get('context')
-            if req_version.matches(FILTERING_VERSION):
+            if req_version.matches(mv.RESOURCE_FILTER):
                 support_like = False
-                if req_version.matches(LIKE_FILTER_VERSION):
+                if req_version.matches(mv.LIKE_FILTER):
                     support_like = True
                 reject_invalid_filters(context, filters,
                                        resource, support_like)

cinder/api/contrib/admin_actions.py

@@ -20,6 +20,7 @@ from webob import exc
 
 from cinder.api import common
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder import backup
 from cinder import db
@@ -245,7 +246,8 @@ class VolumeAdminController(AdminController):
         volume = self._get(context, id)
         params = body['os-migrate_volume']
 
-        cluster_name, host = common.get_cluster_host(req, params, '3.16')
+        cluster_name, host = common.get_cluster_host(req, params,
+                                                     mv.VOLUME_MIGRATE_CLUSTER)
         force_host_copy = utils.get_bool_param('force_host_copy', params)
         lock_volume = utils.get_bool_param('lock_volume', params)
         self.volume_api.migrate_volume(context, volume, host, cluster_name,

cinder/api/contrib/backups.py

@@ -23,6 +23,7 @@ from webob import exc
 
 from cinder.api import common
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.views import backups as backup_views
 from cinder import backup as backupAPI
@@ -151,8 +152,8 @@ class BackupsController(wsgi.Controller):
         incremental = backup.get('incremental', False)
         force = backup.get('force', False)
         snapshot_id = backup.get('snapshot_id', None)
-        metadata = backup.get(
+        metadata = backup.get('metadata', None) if req_version.matches(
-            'metadata', None) if req_version.matches("3.43") else None
+            mv.BACKUP_METADATA) else None
         LOG.info("Creating backup of volume %(volume_id)s in container"
                  " %(container)s",
                  {'volume_id': volume_id, 'container': container},

cinder/api/contrib/resource_common_manage.py

@@ -15,6 +15,7 @@
 import oslo_messaging as messaging
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder import exception
 from cinder.i18n import _
 
@@ -23,7 +24,8 @@ def get_manageable_resources(req, is_detail, function_get_manageable,
                              view_builder):
     context = req.environ['cinder.context']
     params = req.params.copy()
-    cluster_name, host = common.get_cluster_host(req, params, '3.17')
+    cluster_name, host = common.get_cluster_host(
+        req, params, mv.MANAGE_EXISTING_CLUSTER)
     marker, limit, offset = common.get_pagination_params(params)
     sort_keys, sort_dirs = common.get_sort_params(params,
                                                   default_key='reference')

cinder/api/contrib/scheduler_stats.py

@@ -16,14 +16,12 @@
 
 from cinder.api import common
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.views import scheduler_stats as scheduler_stats_view
 from cinder.scheduler import rpcapi
 from cinder import utils
 
-GET_POOL_NAME_FILTER_MICRO_VERSION = '3.28'
-GET_POOL_VOLUME_TYPE_FILTER_MICRO_VERSION = '3.35'
-
 
 def authorize(context, action_name):
     action = 'scheduler_stats:%s' % action_name
@@ -42,7 +40,7 @@ class SchedulerStatsController(wsgi.Controller):
     @common.process_general_filtering('pool')
     def _process_pool_filtering(self, context=None, filters=None,
                                 req_version=None):
-        if not req_version.matches(GET_POOL_NAME_FILTER_MICRO_VERSION):
+        if not req_version.matches(mv.POOL_FILTER):
             filters.clear()
 
     def get_pools(self, req):
@@ -60,7 +58,7 @@ class SchedulerStatsController(wsgi.Controller):
                                      filters=filters,
                                      req_version=req_version)
 
-        if not req_version.matches(GET_POOL_VOLUME_TYPE_FILTER_MICRO_VERSION):
+        if not req_version.matches(mv.POOL_TYPE_FILTER):
             filters.pop('volume_type', None)
 
         pools = self.scheduler_api.get_pools(context, filters=filters)

cinder/api/contrib/services.py

@@ -22,6 +22,7 @@ import webob.exc
 
 from cinder.api import common
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.backup import rpcapi as backup_rpcapi
 from cinder.common import constants
@@ -94,8 +95,8 @@ class ServiceController(wsgi.Controller):
                           'status': active, 'state': art,
                           'updated_at': updated_at}
 
-            # On V3.7 we added cluster support
+            # On CLUSTER_SUPPORT we added cluster support
-            if req.api_version_request.matches('3.7'):
+            if req.api_version_request.matches(mv.CLUSTER_SUPPORT):
                 ret_fields['cluster'] = svc.cluster_name
 
             if detailed:
@@ -125,20 +126,23 @@ class ServiceController(wsgi.Controller):
             raise exception.InvalidInput(ex.msg)
 
     def _freeze(self, context, req, body):
-        cluster_name, host = common.get_cluster_host(req, body, '3.26')
+        cluster_name, host = common.get_cluster_host(
+            req, body, mv.REPLICATION_CLUSTER)
         return self._volume_api_proxy(self.volume_api.freeze_host, context,
                                       host, cluster_name)
 
     def _thaw(self, context, req, body):
-        cluster_name, host = common.get_cluster_host(req, body, '3.26')
+        cluster_name, host = common.get_cluster_host(
+            req, body, mv.REPLICATION_CLUSTER)
         return self._volume_api_proxy(self.volume_api.thaw_host, context,
                                       host, cluster_name)
 
     def _failover(self, context, req, body, clustered):
         # We set version to None to always get the cluster name from the body,
-        # to False when we don't want to get it, and '3.26' when we only want
+        # to False when we don't want to get it, and REPLICATION_CLUSTER  when
-        # it if the requested version is 3.26 or higher.
+        # we only want it if the requested version is REPLICATION_CLUSTER  or
-        version = '3.26' if clustered else False
+        # higher.
+        version = mv.REPLICATION_CLUSTER if clustered else False
         cluster_name, host = common.get_cluster_host(req, body, version)
         self._volume_api_proxy(self.volume_api.failover, context, host,
                                cluster_name, body.get('backend_id'))
@@ -221,7 +225,7 @@ class ServiceController(wsgi.Controller):
         context = req.environ['cinder.context']
         authorize(context, action='update')
 
-        support_dynamic_log = req.api_version_request.matches('3.32')
+        support_dynamic_log = req.api_version_request.matches(mv.LOG_LEVEL)
 
         ext_loaded = self.ext_mgr.is_loaded('os-extended-services')
         ret_val = {}
@@ -240,7 +244,8 @@ class ServiceController(wsgi.Controller):
             return self._thaw(context, req, body)
         elif id == "failover_host":
             return self._failover(context, req, body, False)
-        elif req.api_version_request.matches('3.26') and id == 'failover':
+        elif (req.api_version_request.matches(mv.REPLICATION_CLUSTER) and
+              id == 'failover'):
             return self._failover(context, req, body, True)
         elif support_dynamic_log and id == 'set-log':
             return self._set_log(context, body)

cinder/api/contrib/used_limits.py

@@ -13,6 +13,7 @@
 #    under the License.
 
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder import quota
 
@@ -32,7 +33,8 @@ class UsedLimitsController(wsgi.Controller):
 
             # TODO(wangxiyuan): Support "tenant_id" here to keep the backwards
             # compatibility. Remove it once we drop all support for "tenant".
-            if req_version.matches(None, "3.38") or not context.is_admin:
+            if (req_version.matches(None, mv.GROUP_REPLICATION) or
+                    not context.is_admin):
                 params.pop('project_id', None)
                 params.pop('tenant_id', None)
             project_id = params.get(

cinder/api/contrib/volume_actions.py

@@ -22,7 +22,7 @@ from six.moves import http_client
 import webob
 
 from cinder.api import extensions
-from cinder.api.openstack import api_version_request
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder import exception
 from cinder.i18n import _
@@ -271,7 +271,8 @@ class VolumeActionsController(wsgi.Controller):
 
             image_metadata['cinder_encryption_key_id'] = encryption_key_id
 
-        if req_version >= api_version_request.APIVersionRequest('3.1'):
+        if req_version >= mv.get_api_version(
+                mv.UPLOAD_IMAGE_PARAMS):
 
             image_metadata['visibility'] = params.get('visibility', 'private')
             image_metadata['protected'] = params.get('protected', 'False')
@@ -321,7 +322,8 @@ class VolumeActionsController(wsgi.Controller):
             raise webob.exc.HTTPBadRequest(explanation=msg)
 
         try:
-            if req_version.matches("3.42") and volume.status in ['in-use']:
+            if (req_version.matches(mv.VOLUME_EXTEND_INUSE) and
+                    volume.status in ['in-use']):
                 self.volume_api.extend_attached_volume(context, volume, size)
             else:
                 self.volume_api.extend(context, volume, size)

cinder/api/contrib/volume_manage.py

@@ -18,6 +18,7 @@ from six.moves import http_client
 from cinder.api import common
 from cinder.api.contrib import resource_common_manage
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v2.views import volumes as volume_views
 from cinder.api.views import manageable_volumes as list_manageable_view
@@ -110,7 +111,8 @@ class VolumeManageController(wsgi.Controller):
         if 'ref' not in volume:
             raise exception.MissingRequired(element='ref')
 
-        cluster_name, host = common.get_cluster_host(req, volume, '3.16')
+        cluster_name, host = common.get_cluster_host(
+            req, volume, mv.VOLUME_MIGRATE_CLUSTER)
 
         LOG.debug('Manage volume request body: %s', body)
 

cinder/api/microversions.py

@@ -0,0 +1,172 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""API Microversion definitions.
+
+All new microversions should have a constant added here to be used throughout
+the code instead of the specific version number. Until patches land, it's
+common to end up with merge conflicts with other microversion changes. Merge
+conflicts will be easier to handle via the microversion constants defined here
+as the version number will only need to be changed in a single location.
+
+Actual version numbers should be used:
+
+  * In this file
+  * In cinder/api/openstack/rest_api_version_history.rst
+  * In cinder/api/openstack/api_version_request.py
+  * In release notes describing the new functionality
+  * In updates to api-ref
+
+Nearly all microversion changes should include changes to all of those
+locations. Make sure to add relevant documentation, and make sure that
+documentation includes the final version number used.
+"""
+
+from cinder.api.openstack import api_version_request as api_version
+from cinder import exception
+
+
+# Add new constants here for each new microversion.
+
+BASE_VERSION = '3.0'
+
+UPLOAD_IMAGE_PARAMS = '3.1'
+
+VOLUME_LIST_BOOTABLE = '3.2'
+
+MESSAGES = '3.3'
+
+VOLUME_LIST_GLANCE_METADATA = '3.4'
+
+MESSAGES_PAGINATION = '3.5'
+
+CG_UPDATE_BLANK_PROPERTIES = '3.6'
+
+CLUSTER_SUPPORT = '3.7'
+
+MANAGE_EXISTING_LIST = '3.8'
+
+BACKUP_UPDATE = '3.9'
+
+VOLUME_LIST_GROUP = '3.10'
+
+GROUP_TYPE = '3.11'
+
+VOLUME_SUMMARY = '3.12'
+
+GROUP_VOLUME = '3.13'
+
+GROUP_SNAPSHOTS = '3.14'
+
+ETAGS = '3.15'
+
+VOLUME_MIGRATE_CLUSTER = '3.16'
+
+MANAGE_EXISTING_CLUSTER = '3.17'
+
+BACKUP_PROJECT = '3.18'
+
+GROUP_SNAPSHOT_RESET_STATUS = '3.19'
+
+GROUP_VOLUME_RESET_STATUS = '3.20'
+
+VOLUME_DETAIL_PROVIDER_ID = '3.21'
+
+SNAPSHOT_LIST_METADATA_FILTER = '3.22'
+
+VOLUME_DELETE_FORCE = '3.23'
+
+WORKERS_CLEANUP = '3.24'
+
+GROUP_VOLUME_LIST = '3.25'
+
+REPLICATION_CLUSTER = '3.26'
+
+NEW_ATTACH = '3.27'
+
+POOL_FILTER = '3.28'
+
+GROUP_SNAPSHOT_PAGINATION = '3.29'
+
+SNAPSHOT_SORT = '3.30'
+
+RESOURCE_FILTER = '3.31'
+
+LOG_LEVEL = '3.32'
+
+RESOURCE_FILTER_CONFIG = '3.33'
+
+LIKE_FILTER = '3.34'
+
+POOL_TYPE_FILTER = '3.35'
+
+VOLUME_SUMMARY_METADATA = '3.36'
+
+BACKUP_SORT_NAME = '3.37'
+
+GROUP_REPLICATION = '3.38'
+
+LIMITS_ADMIN_FILTER = '3.39'
+
+VOLUME_REVERT = '3.40'
+
+SNAPSHOT_LIST_USER_ID = '3.41'
+
+VOLUME_EXTEND_INUSE = '3.42'
+
+BACKUP_METADATA = '3.43'
+
+NEW_ATTACH_COMPLETION = '3.44'
+
+
+def get_mv_header(version):
+    """Gets a formatted HTTP microversion header.
+
+    :param version: The microversion needed.
+    :return: A tuple containing the microversion header with the
+             requested version value.
+    """
+    return {'OpenStack-API-Version':
+            'volume %s' % version}
+
+
+def get_api_version(version):
+    """Gets a ``APIVersionRequest`` instance.
+
+    :param version: The microversion needed.
+    :return: The ``APIVersionRequest`` instance.
+    """
+    return api_version.APIVersionRequest(version)
+
+
+def get_prior_version(version):
+    """Gets the microversion before the given version.
+
+    Mostly useful for testing boundaries. This gets the microversion defined
+    just prior to the given version.
+
+    :param version: The version of interest.
+    :return: The version just prior to the given version.
+    """
+    parts = version.split('.')
+
+    if len(parts) != 2 or parts[0] != '3':
+        raise exception.InvalidInput(reason='Version %s is not a valid '
+                                     'microversion format.' % version)
+
+    minor = int(parts[1]) - 1
+
+    if minor < 0:
+        # What's your problem? Are you trying to be difficult?
+        minor = 0
+
+    return '%s.%s' % (parts[0], minor)

cinder/api/openstack/api_version_request.py

@@ -116,6 +116,7 @@ REST_API_VERSION_HISTORY = """
 _MIN_API_VERSION = "3.0"
 _MAX_API_VERSION = "3.44"
 _LEGACY_API_VERSION2 = "2.0"
+UPDATED = "2017-09-19T20:18:14Z"
 
 
 # NOTE(cyeoh): min and max versions declared as functions so we can

cinder/api/v2/volumes.py

@@ -95,7 +95,7 @@ class VolumeController(wsgi.Controller):
         filters = params
 
         # NOTE(wanghao): Always removing glance_metadata since we support it
-        # only in API version >= 3.4.
+        # only in API version >= VOLUME_LIST_GLANCE_METADATA.
         filters.pop('glance_metadata', None)
         utils.remove_invalid_filter_options(context,
                                             filters,

cinder/api/v3/attachments.py

@@ -16,6 +16,7 @@ from oslo_log import log as logging
 import webob
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import attachments as attachment_views
 from cinder import exception
@@ -26,8 +27,6 @@ from cinder.volume import api as volume_api
 
 
 LOG = logging.getLogger(__name__)
-API_VERSION = '3.27'
-ATTACHMENT_COMPLETION_VERSION = '3.44'
 
 
 class AttachmentsController(wsgi.Controller):
@@ -43,20 +42,20 @@ class AttachmentsController(wsgi.Controller):
         self.ext_mgr = ext_mgr
         super(AttachmentsController, self).__init__()
 
-    @wsgi.Controller.api_version(API_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH)
     def show(self, req, id):
         """Return data about the given attachment."""
         context = req.environ['cinder.context']
         attachment = objects.VolumeAttachment.get_by_id(context, id)
         return attachment_views.ViewBuilder.detail(attachment)
 
-    @wsgi.Controller.api_version(API_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH)
     def index(self, req):
         """Return a summary list of attachments."""
         attachments = self._items(req)
         return attachment_views.ViewBuilder.list(attachments)
 
-    @wsgi.Controller.api_version(API_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH)
     def detail(self, req):
         """Return a detailed list of attachments."""
         attachments = self._items(req)
@@ -94,7 +93,7 @@ class AttachmentsController(wsgi.Controller):
                 marker=marker, limit=limit, offset=offset, sort_keys=sort_keys,
                 sort_direction=sort_dirs)
 
-    @wsgi.Controller.api_version(API_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH)
     @wsgi.response(202)
     def create(self, req, body):
         """Create an attachment.
@@ -192,7 +191,7 @@ class AttachmentsController(wsgi.Controller):
                 raise webob.exc.HTTPInternalServerError(explanation=err_msg)
         return attachment_views.ViewBuilder.detail(attachment_ref)
 
-    @wsgi.Controller.api_version(API_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH)
     def update(self, req, id, body):
         """Update an attachment record.
 
@@ -252,7 +251,7 @@ class AttachmentsController(wsgi.Controller):
         # or a dict?
         return attachment_views.ViewBuilder.detail(attachment_ref)
 
-    @wsgi.Controller.api_version(API_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH)
     def delete(self, req, id):
         """Delete an attachment.
 
@@ -268,7 +267,7 @@ class AttachmentsController(wsgi.Controller):
         return attachment_views.ViewBuilder.list(attachments)
 
     @wsgi.response(202)
-    @wsgi.Controller.api_version(ATTACHMENT_COMPLETION_VERSION)
+    @wsgi.Controller.api_version(mv.NEW_ATTACH_COMPLETION)
     @wsgi.action('os-complete')
     def complete(self, req, id, body):
         """Mark a volume attachment process as completed (in-use)."""

cinder/api/v3/backups.py

@@ -19,22 +19,20 @@ from oslo_log import log as logging
 from webob import exc
 
 from cinder.api.contrib import backups as backups_v2
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.backup import api as backup_api
 from cinder import exception
 from cinder.i18n import _
 
 
-BACKUP_UPDATE_MICRO_VERSION = '3.9'
-BACKUP_TENANT_MICRO_VERSION = '3.18'
-
 LOG = logging.getLogger(__name__)
 
 
 class BackupsController(backups_v2.BackupsController):
     """The backups API controller for the OpenStack API V3."""
 
-    @wsgi.Controller.api_version(BACKUP_UPDATE_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.BACKUP_UPDATE)
     def update(self, req, id, body):
         """Update a backup."""
         context = req.environ['cinder.context']
@@ -50,7 +48,8 @@ class BackupsController(backups_v2.BackupsController):
         if 'description' in backup_update:
             update_dict['display_description'] = (
                 backup_update.pop('description'))
-        if req_version.matches('3.43') and 'metadata' in backup_update:
+        if (req_version.matches(
+                mv.BACKUP_METADATA) and 'metadata' in backup_update):
             update_dict['metadata'] = backup_update.pop('metadata')
         # Check no unsupported fields.
         if backup_update:
@@ -77,7 +76,7 @@ class BackupsController(backups_v2.BackupsController):
         req.cache_db_backup(backup)
 
         resp_backup = self._view_builder.detail(req, backup)
-        if req_version.matches(BACKUP_TENANT_MICRO_VERSION):
+        if req_version.matches(mv.BACKUP_PROJECT):
             try:
                 backup_api.check_policy(context, 'backup_project_attribute')
                 self._add_backup_project_attribute(req, resp_backup['backup'])
@@ -90,7 +89,7 @@ class BackupsController(backups_v2.BackupsController):
         context = req.environ['cinder.context']
         req_version = req.api_version_request
 
-        if req_version.matches(BACKUP_TENANT_MICRO_VERSION):
+        if req_version.matches(mv.BACKUP_PROJECT):
             try:
                 backup_api.check_policy(context, 'backup_project_attribute')
                 for bak in resp_backup['backups']:
@@ -100,7 +99,7 @@ class BackupsController(backups_v2.BackupsController):
         return resp_backup
 
     def _convert_sort_name(self, req_version, sort_keys):
-        if req_version.matches("3.37") and 'name' in sort_keys:
+        if req_version.matches(mv.BACKUP_SORT_NAME) and 'name' in sort_keys:
             sort_keys[sort_keys.index('name')] = 'display_name'
 
 

cinder/api/v3/clusters.py

@@ -13,6 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import clusters as clusters_view
 from cinder import exception
@@ -21,10 +22,6 @@ from cinder import objects
 from cinder import utils
 
 
-CLUSTER_MICRO_VERSION = '3.7'
-REPLICATION_DATA_MICRO_VERSION = '3.26'
-
-
 class ClusterController(wsgi.Controller):
     allowed_list_keys = {'name', 'binary', 'is_up', 'disabled', 'num_hosts',
                          'num_down_hosts', 'binary', 'replication_status',
@@ -33,7 +30,7 @@ class ClusterController(wsgi.Controller):
 
     policy_checker = wsgi.Controller.get_policy_checker('clusters')
 
-    @wsgi.Controller.api_version(CLUSTER_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.CLUSTER_SUPPORT)
     def show(self, req, id, binary='cinder-volume'):
         """Return data for a given cluster name with optional binary."""
         # Let the wsgi middleware convert NotAuthorized exceptions
@@ -42,10 +39,10 @@ class ClusterController(wsgi.Controller):
         cluster = objects.Cluster.get_by_id(context, None, binary=binary,
                                             name=id, services_summary=True)
         replication_data = req.api_version_request.matches(
-            REPLICATION_DATA_MICRO_VERSION)
+            mv.REPLICATION_CLUSTER)
         return clusters_view.ViewBuilder.detail(cluster, replication_data)
 
-    @wsgi.Controller.api_version(CLUSTER_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.CLUSTER_SUPPORT)
     def index(self, req):
         """Return a non detailed list of all existing clusters.
 
@@ -53,7 +50,7 @@ class ClusterController(wsgi.Controller):
         """
         return self._get_clusters(req, detail=False)
 
-    @wsgi.Controller.api_version(CLUSTER_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.CLUSTER_SUPPORT)
     def detail(self, req):
         """Return a detailed list of all existing clusters.
 
@@ -65,7 +62,7 @@ class ClusterController(wsgi.Controller):
         # Let the wsgi middleware convert NotAuthorized exceptions
         context = self.policy_checker(req, 'get_all')
         replication_data = req.api_version_request.matches(
-            REPLICATION_DATA_MICRO_VERSION)
+            mv.REPLICATION_CLUSTER)
         filters = dict(req.GET)
         allowed = self.allowed_list_keys
         if not replication_data:
@@ -89,7 +86,7 @@ class ClusterController(wsgi.Controller):
         return clusters_view.ViewBuilder.list(clusters, detail,
                                               replication_data)
 
-    @wsgi.Controller.api_version(CLUSTER_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.CLUSTER_SUPPORT)
     def update(self, req, id, body):
         """Enable/Disable scheduling for a cluster."""
         # NOTE(geguileo): This method tries to be consistent with services
@@ -123,7 +120,7 @@ class ClusterController(wsgi.Controller):
 
         # We return summary data plus the disabled reason
         replication_data = req.api_version_request.matches(
-            REPLICATION_DATA_MICRO_VERSION)
+            mv.REPLICATION_CLUSTER)
         ret_val = clusters_view.ViewBuilder.summary(cluster, replication_data)
         ret_val['cluster']['disabled_reason'] = disabled_reason
 

cinder/api/v3/consistencygroups.py

@@ -19,6 +19,7 @@ import webob
 from webob import exc
 
 from cinder.api.contrib import consistencygroups as cg_v2
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.i18n import _
 
@@ -30,7 +31,8 @@ class ConsistencyGroupsController(cg_v2.ConsistencyGroupsController):
 
     def _check_update_parameters_v3(self, req, name, description, add_volumes,
                                     remove_volumes):
-        allow_empty = req.api_version_request.matches('3.6', None)
+        allow_empty = req.api_version_request.matches(
+            mv.CG_UPDATE_BLANK_PROPERTIES, None)
         if allow_empty:
             if (name is None and description is None
                     and not add_volumes and not remove_volumes):

cinder/api/v3/group_snapshots.py

@@ -22,6 +22,7 @@ import webob
 from webob import exc
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import group_snapshots as group_snapshot_views
 from cinder import exception
@@ -32,8 +33,6 @@ from cinder.volume import group_types
 
 LOG = logging.getLogger(__name__)
 
-GROUP_SNAPSHOT_API_VERSION = '3.14'
-
 
 class GroupSnapshotsController(wsgi.Controller):
     """The group_snapshots API controller for the OpenStack API."""
@@ -52,7 +51,7 @@ class GroupSnapshotsController(wsgi.Controller):
                    % {'group_type': group_type_id})
             raise exc.HTTPBadRequest(explanation=msg)
 
-    @wsgi.Controller.api_version(GROUP_SNAPSHOT_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOTS)
     def show(self, req, id):
         """Return data about the given group_snapshot."""
         LOG.debug('show called for member %s', id)
@@ -66,7 +65,7 @@ class GroupSnapshotsController(wsgi.Controller):
 
         return self._view_builder.detail(req, group_snapshot)
 
-    @wsgi.Controller.api_version(GROUP_SNAPSHOT_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOTS)
     def delete(self, req, id):
         """Delete a group_snapshot."""
         LOG.debug('delete called for member %s', id)
@@ -93,12 +92,12 @@ class GroupSnapshotsController(wsgi.Controller):
 
         return webob.Response(status_int=http_client.ACCEPTED)
 
-    @wsgi.Controller.api_version(GROUP_SNAPSHOT_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOTS)
     def index(self, req):
         """Returns a summary list of group_snapshots."""
         return self._get_group_snapshots(req, is_detail=False)
 
-    @wsgi.Controller.api_version(GROUP_SNAPSHOT_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOTS)
     def detail(self, req):
         """Returns a detailed list of group_snapshots."""
         return self._get_group_snapshots(req, is_detail=True)
@@ -109,14 +108,14 @@ class GroupSnapshotsController(wsgi.Controller):
         context = req.environ['cinder.context']
         req_version = req.api_version_request
         filters = marker = limit = offset = sort_keys = sort_dirs = None
-        if req_version.matches("3.29"):
+        if req_version.matches(mv.GROUP_SNAPSHOT_PAGINATION):
             filters = req.params.copy()
             marker, limit, offset = common.get_pagination_params(filters)
             sort_keys, sort_dirs = common.get_sort_params(filters)
 
-        if req_version.matches(common.FILTERING_VERSION):
+        if req_version.matches(mv.RESOURCE_FILTER):
             support_like = (True if req_version.matches(
-                common.LIKE_FILTER_VERSION) else False)
+                mv.LIKE_FILTER) else False)
             common.reject_invalid_filters(context, filters, 'group_snapshot',
                                           support_like)
 
@@ -145,7 +144,7 @@ class GroupSnapshotsController(wsgi.Controller):
         group_snapshots['group_snapshots'] = new_group_snapshots
         return group_snapshots
 
-    @wsgi.Controller.api_version(GROUP_SNAPSHOT_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOTS)
     @wsgi.response(http_client.ACCEPTED)
     def create(self, req, body):
         """Create a new group_snapshot."""
@@ -183,7 +182,7 @@ class GroupSnapshotsController(wsgi.Controller):
 
         return retval
 
-    @wsgi.Controller.api_version('3.19')
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOT_RESET_STATUS)
     @wsgi.action("reset_status")
     def reset_status(self, req, id, body):
         return self._reset_status(req, id, body)

cinder/api/v3/group_specs.py

@@ -18,6 +18,7 @@ from six.moves import http_client
 import webob
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder import db
 from cinder import exception
@@ -51,7 +52,7 @@ class GroupTypeSpecsController(wsgi.Controller):
         except exception.GroupTypeNotFound as ex:
             raise webob.exc.HTTPNotFound(explanation=ex.msg)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def index(self, req, group_type_id):
         """Returns the list of group specs for a given group type."""
         context = req.environ['cinder.context']
@@ -59,7 +60,7 @@ class GroupTypeSpecsController(wsgi.Controller):
         self._check_type(context, group_type_id)
         return self._get_group_specs(context, group_type_id)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     @wsgi.response(http_client.ACCEPTED)
     def create(self, req, group_type_id, body=None):
         context = req.environ['cinder.context']
@@ -80,7 +81,7 @@ class GroupTypeSpecsController(wsgi.Controller):
                       notifier_info)
         return body
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def update(self, req, group_type_id, id, body=None):
         context = req.environ['cinder.context']
         self._check_policy(context)
@@ -108,7 +109,7 @@ class GroupTypeSpecsController(wsgi.Controller):
                       notifier_info)
         return body
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def show(self, req, group_type_id, id):
         """Return a single extra spec item."""
         context = req.environ['cinder.context']
@@ -123,7 +124,7 @@ class GroupTypeSpecsController(wsgi.Controller):
                     "%(id)s.") % ({'type_id': group_type_id, 'id': id})
             raise webob.exc.HTTPNotFound(explanation=msg)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def delete(self, req, group_type_id, id):
         """Deletes an existing group spec."""
         context = req.environ['cinder.context']

cinder/api/v3/group_types.py

@@ -21,6 +21,7 @@ import webob
 from webob import exc
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import group_types as views_types
 from cinder import exception
@@ -55,7 +56,7 @@ class GroupTypesController(wsgi.Controller):
         payload = dict(group_types=group_type)
         rpc.get_notifier('groupType').info(context, method, payload)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     @wsgi.response(http_client.ACCEPTED)
     def create(self, req, body):
         """Creates a new group type."""
@@ -103,7 +104,7 @@ class GroupTypesController(wsgi.Controller):
 
         return self._view_builder.show(req, grp_type)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def update(self, req, id, body):
         # Update description for a given group type.
         context = req.environ['cinder.context']
@@ -163,7 +164,7 @@ class GroupTypesController(wsgi.Controller):
 
         return self._view_builder.show(req, grp_type)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def delete(self, req, id):
         """Deletes an existing group type."""
         context = req.environ['cinder.context']
@@ -186,14 +187,14 @@ class GroupTypesController(wsgi.Controller):
 
         return webob.Response(status_int=http_client.ACCEPTED)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def index(self, req):
         """Returns the list of group types."""
         limited_types = self._get_group_types(req)
         req.cache_resource(limited_types, name='group_types')
         return self._view_builder.index(req, limited_types)
 
-    @wsgi.Controller.api_version('3.11')
+    @wsgi.Controller.api_version(mv.GROUP_TYPE)
     def show(self, req, id):
         """Return a single group type item."""
         context = req.environ['cinder.context']

cinder/api/v3/groups.py

@@ -22,6 +22,7 @@ import webob
 from webob import exc
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import groups as views_groups
 from cinder import exception
@@ -32,10 +33,6 @@ from cinder.volume import group_types
 
 LOG = logging.getLogger(__name__)
 
-GROUP_API_VERSION = '3.13'
-GROUP_CREATE_FROM_SRC_API_VERSION = '3.14'
-GROUP_REPLICATION_API_VERSION = '3.38'
-
 
 class GroupsController(wsgi.Controller):
     """The groups API controller for the OpenStack API."""
@@ -53,7 +50,7 @@ class GroupsController(wsgi.Controller):
                     "CG APIs.") % {'group_type': group_type_id}
             raise exc.HTTPBadRequest(explanation=msg)
 
-    @wsgi.Controller.api_version(GROUP_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME)
     def show(self, req, id):
         """Return data about the given group."""
         LOG.debug('show called for member %s', id)
@@ -68,7 +65,7 @@ class GroupsController(wsgi.Controller):
 
         return self._view_builder.detail(req, group)
 
-    @wsgi.Controller.api_version('3.20')
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME_RESET_STATUS)
     @wsgi.action("reset_status")
     def reset_status(self, req, id, body):
         return self._reset_status(req, id, body)
@@ -109,7 +106,7 @@ class GroupsController(wsgi.Controller):
             raise exc.HTTPBadRequest(explanation=error.msg)
         return webob.Response(status_int=http_client.ACCEPTED)
 
-    @wsgi.Controller.api_version(GROUP_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME)
     @wsgi.action("delete")
     def delete_group(self, req, id, body):
         return self._delete(req, id, body)
@@ -150,12 +147,12 @@ class GroupsController(wsgi.Controller):
 
         return webob.Response(status_int=http_client.ACCEPTED)
 
-    @wsgi.Controller.api_version(GROUP_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME)
     def index(self, req):
         """Returns a summary list of groups."""
         return self._get_groups(req, is_detail=False)
 
-    @wsgi.Controller.api_version(GROUP_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME)
     def detail(self, req):
         """Returns a detailed list of groups."""
         return self._get_groups(req, is_detail=True)
@@ -169,9 +166,9 @@ class GroupsController(wsgi.Controller):
         sort_keys, sort_dirs = common.get_sort_params(filters)
 
         filters.pop('list_volume', None)
-        if api_version.matches(common.FILTERING_VERSION):
+        if api_version.matches(mv.RESOURCE_FILTER):
             support_like = (True if api_version.matches(
-                common.LIKE_FILTER_VERSION) else False)
+                mv.LIKE_FILTER) else False)
             common.reject_invalid_filters(context, filters, 'group',
                                           support_like)
 
@@ -197,7 +194,7 @@ class GroupsController(wsgi.Controller):
                 req, new_groups)
         return groups
 
-    @wsgi.Controller.api_version(GROUP_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME)
     @wsgi.response(http_client.ACCEPTED)
     def create(self, req, body):
         """Create a new group."""
@@ -243,7 +240,7 @@ class GroupsController(wsgi.Controller):
         retval = self._view_builder.summary(req, new_group)
         return retval
 
-    @wsgi.Controller.api_version(GROUP_CREATE_FROM_SRC_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_SNAPSHOTS)
     @wsgi.action("create-from-src")
     @wsgi.response(http_client.ACCEPTED)
     def create_from_src(self, req, body):
@@ -308,7 +305,7 @@ class GroupsController(wsgi.Controller):
         retval = self._view_builder.summary(req, new_group)
         return retval
 
-    @wsgi.Controller.api_version(GROUP_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_VOLUME)
     def update(self, req, id, body):
         """Update the group.
 
@@ -373,7 +370,7 @@ class GroupsController(wsgi.Controller):
 
         return webob.Response(status_int=http_client.ACCEPTED)
 
-    @wsgi.Controller.api_version(GROUP_REPLICATION_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_REPLICATION)
     @wsgi.action("enable_replication")
     def enable_replication(self, req, id, body):
         """Enables replications for a group."""
@@ -397,7 +394,7 @@ class GroupsController(wsgi.Controller):
 
         return webob.Response(status_int=202)
 
-    @wsgi.Controller.api_version(GROUP_REPLICATION_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_REPLICATION)
     @wsgi.action("disable_replication")
     def disable_replication(self, req, id, body):
         """Disables replications for a group."""
@@ -421,7 +418,7 @@ class GroupsController(wsgi.Controller):
 
         return webob.Response(status_int=202)
 
-    @wsgi.Controller.api_version(GROUP_REPLICATION_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_REPLICATION)
     @wsgi.action("failover_replication")
     def failover_replication(self, req, id, body):
         """Fails over replications for a group."""
@@ -457,7 +454,7 @@ class GroupsController(wsgi.Controller):
 
         return webob.Response(status_int=202)
 
-    @wsgi.Controller.api_version(GROUP_REPLICATION_API_VERSION)
+    @wsgi.Controller.api_version(mv.GROUP_REPLICATION)
     @wsgi.action("list_replication_targets")
     def list_replication_targets(self, req, id, body):
         """List replication targets for a group."""

cinder/api/v3/limits.py

@@ -13,6 +13,7 @@
 
 """The limits V3 api."""
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v2 import limits as limits_v2
 from cinder.api.views import limits as limits_views
@@ -32,7 +33,8 @@ class LimitsController(limits_v2.LimitsController):
 
         # TODO(wangxiyuan): Support "tenant_id" here to keep the backwards
         # compatibility. Remove it once we drop all support for "tenant".
-        if req_version.matches(None, "3.38") or not context.is_admin:
+        if req_version.matches(None,
+                               mv.GROUP_REPLICATION) or not context.is_admin:
             params.pop('project_id', None)
             params.pop('tenant_id', None)
         project_id = params.get(

cinder/api/v3/messages.py

@@ -17,6 +17,7 @@ from six.moves import http_client
 import webob
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import messages as messages_view
 from cinder.message import api as message_api
@@ -25,9 +26,6 @@ from cinder.message import message_field
 import cinder.policy
 
 
-MESSAGES_BASE_MICRO_VERSION = '3.3'
-
-
 def check_policy(context, action, target_obj=None):
     target = {
         'project_id': context.project_id,
@@ -62,7 +60,7 @@ class MessagesController(wsgi.Controller):
                 message_field.translate_action(message['action_id']),
                 message_field.translate_detail(message['detail_id']))
 
-    @wsgi.Controller.api_version(MESSAGES_BASE_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.MESSAGES)
     def show(self, req, id):
         """Return the given message."""
         context = req.environ['cinder.context']
@@ -75,7 +73,7 @@ class MessagesController(wsgi.Controller):
         self._build_user_message(message)
         return self._view_builder.detail(req, message)
 
-    @wsgi.Controller.api_version(MESSAGES_BASE_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.MESSAGES)
     def delete(self, req, id):
         """Delete a message."""
         context = req.environ['cinder.context']
@@ -87,7 +85,7 @@ class MessagesController(wsgi.Controller):
 
         return webob.Response(status_int=http_client.NO_CONTENT)
 
-    @wsgi.Controller.api_version(MESSAGES_BASE_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.MESSAGES)
     def index(self, req):
         """Returns a list of messages, transformed through view builder."""
         context = req.environ['cinder.context']
@@ -100,14 +98,14 @@ class MessagesController(wsgi.Controller):
         sort_keys = None
         sort_dirs = None
 
-        if api_version.matches("3.5"):
+        if api_version.matches(mv.MESSAGES_PAGINATION):
             filters = req.params.copy()
             marker, limit, offset = common.get_pagination_params(filters)
             sort_keys, sort_dirs = common.get_sort_params(filters)
 
-        if api_version.matches(common.FILTERING_VERSION):
+        if api_version.matches(mv.RESOURCE_FILTER):
             support_like = (True if api_version.matches(
-                common.LIKE_FILTER_VERSION) else False)
+                mv.LIKE_FILTER) else False)
             common.reject_invalid_filters(context, filters, 'message',
                                           support_like)
 

cinder/api/v3/resource_common_manage.py

@@ -15,6 +15,7 @@
 
 from cinder.api import common
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder import exception
 from cinder.i18n import _
@@ -41,13 +42,14 @@ class ManageResource(object):
             raise exception.VersionNotFoundForAPIMethod(version=version)
 
     def _get_resources(self, req, is_detail):
-        self._ensure_min_version(req, '3.8')
+        self._ensure_min_version(req, mv.MANAGE_EXISTING_LIST)
 
         context = req.environ['cinder.context']
         self._authorizer(context)
 
         params = req.params.copy()
-        cluster_name, host = common.get_cluster_host(req, params, '3.17')
+        cluster_name, host = common.get_cluster_host(
+            req, params, mv.MANAGE_EXISTING_CLUSTER)
         marker, limit, offset = common.get_pagination_params(params)
         sort_keys, sort_dirs = common.get_sort_params(params,
                                                       default_key='reference')

cinder/api/v3/resource_filters.py

@@ -13,13 +13,11 @@
 """The resource filters api."""
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import resource_filters as filter_views
 
 
-FILTER_API_VERSION = '3.33'
-
-
 class ResourceFiltersController(wsgi.Controller):
     """The resource filter API controller for the OpenStack API."""
 
@@ -30,7 +28,7 @@ class ResourceFiltersController(wsgi.Controller):
         self.ext_mgr = ext_mgr
         super(ResourceFiltersController, self).__init__()
 
-    @wsgi.Controller.api_version(FILTER_API_VERSION)
+    @wsgi.Controller.api_version(mv.RESOURCE_FILTER_CONFIG)
     def index(self, req):
         """Return a list of resource filters."""
         resource = req.params.get('resource', None)

cinder/api/v3/snapshot_manage.py

@@ -15,6 +15,7 @@
 from six.moves import http_client
 
 from cinder.api.contrib import snapshot_manage as snapshot_manage_v2
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3 import resource_common_manage as common
 
@@ -27,7 +28,7 @@ class SnapshotManageController(common.ManageResource,
 
     @wsgi.response(http_client.ACCEPTED)
     def create(self, req, body):
-        self._ensure_min_version(req, "3.8")
+        self._ensure_min_version(req, mv.MANAGE_EXISTING_LIST)
         return super(SnapshotManageController, self).create(req, body)
 
 

cinder/api/v3/snapshots.py

@@ -20,6 +20,7 @@ import ast
 from oslo_log import log as logging
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v2 import snapshots as snapshots_v2
 from cinder.api.v3.views import snapshots as snapshot_views
@@ -56,9 +57,10 @@ class SnapshotsController(snapshots_v2.SnapshotsController):
                                     req_version=None):
         """Formats allowed filters"""
 
-        # if the max version is less than or same as 3.21
+        # if the max version is less than SNAPSHOT_LIST_METADATA_FILTER
         # metadata based filtering is not supported
-        if req_version.matches(None, "3.21"):
+        if req_version.matches(
+                None, mv.get_prior_version(mv.SNAPSHOT_LIST_METADATA_FILTER)):
             filters.pop('metadata', None)
 
         # Filter out invalid options
@@ -84,7 +86,7 @@ class SnapshotsController(snapshots_v2.SnapshotsController):
         self._format_snapshot_filter_options(search_opts)
 
         req_version = req.api_version_request
-        if req_version.matches("3.30", None) and 'name' in sort_keys:
+        if req_version.matches(mv.SNAPSHOT_SORT, None) and 'name' in sort_keys:
             sort_keys[sort_keys.index('name')] = 'display_name'
 
         # NOTE(thingee): v3 API allows name instead of display_name

cinder/api/v3/views/groups.py

@@ -14,6 +14,7 @@
 #    under the License.
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder import utils
 
 
@@ -60,20 +61,21 @@ class ViewBuilder(common.ViewBuilder):
 
         req_version = request.api_version_request
         # Add group_snapshot_id and source_group_id if min version is greater
-        # than or equal to 3.14.
+        # than or equal to GROUP_SNAPSHOTS.
-        if req_version.matches("3.14", None):
+        if req_version.matches(mv.GROUP_SNAPSHOTS, None):
             group_ref['group']['group_snapshot_id'] = group.group_snapshot_id
             group_ref['group']['source_group_id'] = group.source_group_id
 
-        # Add volumes if min version is greater than or equal to 3.25.
+        # Add volumes if min version is greater than or equal to
-        if req_version.matches("3.25", None):
+        # GROUP_VOLUME_LIST.
+        if req_version.matches(mv.GROUP_VOLUME_LIST, None):
             if utils.get_bool_param('list_volume', request.params):
                 group_ref['group']['volumes'] = [volume.id
                                                  for volume in group.volumes]
 
         # Add replication_status if min version is greater than or equal
-        # to 3.38.
+        # to GROUP_REPLICATION.
-        if req_version.matches("3.38", None):
+        if req_version.matches(mv.GROUP_REPLICATION, None):
             group_ref['group']['replication_status'] = group.replication_status
 
         return group_ref

cinder/api/v3/views/snapshots.py

@@ -13,6 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from cinder.api import microversions as mv
 from cinder.api.views import snapshots as views_v2
 
 
@@ -25,10 +26,10 @@ class ViewBuilder(views_v2.ViewBuilder):
 
         req_version = request.api_version_request
         # Add group_snapshot_id if min version is greater than or equal
-        # to 3.14.
+        # to GROUP_SNAPSHOTS.
-        if req_version.matches("3.14", None):
+        if req_version.matches(mv.GROUP_SNAPSHOTS, None):
             snapshot_ref['snapshot']['group_snapshot_id'] = (
                 snapshot.get('group_snapshot_id'))
-        if req_version.matches("3.41", None):
+        if req_version.matches(mv.SNAPSHOT_LIST_USER_ID, None):
             snapshot_ref['snapshot']['user_id'] = snapshot.get('user_id')
         return snapshot_ref

cinder/api/v3/views/volumes.py

@@ -13,6 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+from cinder.api import microversions as mv
 from cinder.api.v2.views import volumes as views_v2
 
 
@@ -41,14 +42,14 @@ class ViewBuilder(views_v2.ViewBuilder):
         volume_ref = super(ViewBuilder, self).detail(request, volume)
 
         req_version = request.api_version_request
-        # Add group_id if min version is greater than or equal to 3.13.
+        # Add group_id if min version is greater than or equal to GROUP_VOLUME.
-        if req_version.matches("3.13", None):
+        if req_version.matches(mv.GROUP_VOLUME, None):
             volume_ref['volume']['group_id'] = volume.get('group_id')
 
-        # Add provider_id if min version is greater than or equal to 3.21
+        # Add provider_id if min version is greater than or equal to
-        # for admin.
+        # VOLUME_DETAIL_PROVIDER_ID for admin.
         if (request.environ['cinder.context'].is_admin and
-                req_version.matches("3.21", None)):
+                req_version.matches(mv.VOLUME_DETAIL_PROVIDER_ID, None)):
             volume_ref['volume']['provider_id'] = volume.get('provider_id')
 
         return volume_ref

cinder/api/v3/volume_manage.py

@@ -15,6 +15,7 @@
 from six.moves import http_client
 
 from cinder.api.contrib import volume_manage as volume_manage_v2
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3 import resource_common_manage as common
 
@@ -27,7 +28,7 @@ class VolumeManageController(common.ManageResource,
 
     @wsgi.response(http_client.ACCEPTED)
     def create(self, req, body):
-        self._ensure_min_version(req, "3.8")
+        self._ensure_min_version(req, mv.MANAGE_EXISTING_LIST)
         return super(VolumeManageController, self).create(req, body)
 
 

cinder/api/v3/volume_metadata.py

@@ -22,13 +22,11 @@ import six
 from six.moves import http_client
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v2 import volume_metadata as volume_meta_v2
 
 
-METADATA_MICRO_VERSION = '3.15'
-
-
 class Controller(volume_meta_v2.Controller):
     """The volume metadata API controller for the OpenStack API."""
     def _validate_etag(self, req, volume_id):
@@ -46,7 +44,7 @@ class Controller(volume_meta_v2.Controller):
     def index(self, req, volume_id):
         req_version = req.api_version_request
         metadata = super(Controller, self).index(req, volume_id)
-        if req_version.matches(METADATA_MICRO_VERSION):
+        if req_version.matches(mv.ETAGS):
             data = jsonutils.dumps(metadata)
             if six.PY3:
                 data = data.encode('utf-8')
@@ -59,7 +57,7 @@ class Controller(volume_meta_v2.Controller):
     @wsgi.extends
     def update(self, req, volume_id, id, body):
         req_version = req.api_version_request
-        if req_version.matches(METADATA_MICRO_VERSION):
+        if req_version.matches(mv.ETAGS):
             if not self._validate_etag(req, volume_id):
                 return webob.Response(
                     status_int=http_client.PRECONDITION_FAILED)
@@ -69,7 +67,7 @@ class Controller(volume_meta_v2.Controller):
     @wsgi.extends
     def update_all(self, req, volume_id, body):
         req_version = req.api_version_request
-        if req_version.matches(METADATA_MICRO_VERSION):
+        if req_version.matches(mv.ETAGS):
             if not self._validate_etag(req, volume_id):
                 return webob.Response(
                     status_int=http_client.PRECONDITION_FAILED)

cinder/api/v3/volumes.py

@@ -21,6 +21,7 @@ import webob
 from webob import exc
 
 from cinder.api import common
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v2 import volumes as volumes_v2
 from cinder.api.v3.views import volumes as volume_views_v3
@@ -33,8 +34,6 @@ from cinder import utils
 
 LOG = logging.getLogger(__name__)
 
-SUMMARY_BASE_MICRO_VERSION = '3.12'
-
 
 def check_policy(context, action, target_obj=None):
     target = {
@@ -65,7 +64,7 @@ class VolumeController(volumes_v2.VolumeController):
         force = False
 
         params = ""
-        if req_version.matches('3.23'):
+        if req_version.matches(mv.VOLUME_LIST_BOOTABLE):
             force = utils.get_bool_param('force', req.params)
             if cascade or force:
                 params = "(cascade: %(c)s, force: %(f)s)" % {'c': cascade,
@@ -88,10 +87,10 @@ class VolumeController(volumes_v2.VolumeController):
     @common.process_general_filtering('volume')
     def _process_volume_filtering(self, context=None, filters=None,
                                   req_version=None):
-        if req_version.matches(None, "3.3"):
+        if req_version.matches(None, mv.MESSAGES):
             filters.pop('glance_metadata', None)
 
-        if req_version.matches(None, "3.9"):
+        if req_version.matches(None, mv.BACKUP_UPDATE):
             filters.pop('group_id', None)
 
         utils.remove_invalid_filter_options(
@@ -119,7 +118,8 @@ class VolumeController(volumes_v2.VolumeController):
         if 'name' in filters:
             filters['display_name'] = filters.pop('name')
 
-        strict = req.api_version_request.matches("3.2", None)
+        strict = req.api_version_request.matches(
+            mv.VOLUME_LIST_BOOTABLE, None)
         self.volume_api.check_volume_filters(filters, strict)
 
         volumes = self.volume_api.get_all(context, marker, limit,
@@ -140,7 +140,7 @@ class VolumeController(volumes_v2.VolumeController):
             volumes = self._view_builder.summary_list(req, volumes)
         return volumes
 
-    @wsgi.Controller.api_version(SUMMARY_BASE_MICRO_VERSION)
+    @wsgi.Controller.api_version(mv.VOLUME_SUMMARY)
     def summary(self, req):
         """Return summary of volumes."""
         view_builder_v3 = volume_views_v3.ViewBuilder()
@@ -154,7 +154,7 @@ class VolumeController(volumes_v2.VolumeController):
             context, filters=filters)
 
         req_version = req.api_version_request
-        if req_version.matches("3.36"):
+        if req_version.matches(mv.VOLUME_SUMMARY_METADATA):
             all_distinct_metadata = metadata
         else:
             all_distinct_metadata = None
@@ -163,7 +163,7 @@ class VolumeController(volumes_v2.VolumeController):
                                              all_distinct_metadata)
 
     @wsgi.response(http_client.ACCEPTED)
-    @wsgi.Controller.api_version('3.40')
+    @wsgi.Controller.api_version(mv.VOLUME_REVERT)
     @wsgi.action('revert')
     def revert(self, req, id, body):
         """revert a volume to a snapshot"""
@@ -208,8 +208,8 @@ class VolumeController(volumes_v2.VolumeController):
         context = req.environ['cinder.context']
 
         req_version = req.api_version_request
-        # Remove group_id from body if max version is less than 3.13.
+        # Remove group_id from body if max version is less than GROUP_VOLUME.
-        if req_version.matches(None, "3.12"):
+        if req_version.matches(None, mv.get_prior_version(mv.GROUP_VOLUME)):
             # NOTE(xyang): The group_id is from a group created with a
             # group_type. So with this group_id, we've got a group_type
             # for this volume. Also if group_id is passed in, that means

cinder/api/v3/workers.py

@@ -16,6 +16,7 @@
 from oslo_utils import timeutils
 from oslo_utils import uuidutils
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import wsgi
 from cinder.api.v3.views import workers as workers_view
 from cinder import db
@@ -98,7 +99,7 @@ class WorkerController(wsgi.Controller):
 
         return params
 
-    @wsgi.Controller.api_version('3.24')
+    @wsgi.Controller.api_version(mv.WORKERS_CLEANUP)
     @wsgi.response(202)
     def cleanup(self, req, body=None):
         """Do the cleanup on resources from a specific service/host/node."""

cinder/api/versions.py

@@ -51,7 +51,7 @@ _KNOWN_VERSIONS = {
         "status": "CURRENT",
         "version": api_version_request._MAX_API_VERSION,
         "min_version": api_version_request._MIN_API_VERSION,
-        "updated": "2016-02-08T12:20:21Z",
+        "updated": api_version_request.UPDATED,
         "links": _LINKS,
         "media-types": [{
             "base": "application/json",

cinder/api/views/backups.py

@@ -14,6 +14,7 @@
 #    under the License.
 
 from cinder.api import common
+from cinder.api import microversions as mv
 
 
 class ViewBuilder(common.ViewBuilder):
@@ -78,7 +79,7 @@ class ViewBuilder(common.ViewBuilder):
             }
         }
         req_version = request.api_version_request
-        if req_version.matches("3.43"):
+        if req_version.matches(mv.BACKUP_METADATA):
             backup_dict['backup']['metadata'] = backup.metadata
         return backup_dict
 

cinder/tests/tempest/api/volume/test_volume_revert.py

@@ -24,7 +24,6 @@ CONF = config.CONF
 
 
 class VolumeRevertTests(volume_base.BaseVolumeTest):
-    min_microversion = '3.40'
 
     @classmethod
     def setup_clients(cls):

cinder/tests/unit/api/contrib/test_admin_actions.py

@@ -23,7 +23,7 @@ import webob
 from webob import exc
 
 from cinder.api.contrib import admin_actions
-from cinder.api.openstack import api_version_request as api_version
+from cinder.api import microversions as mv
 from cinder.backup import api as backup_api
 from cinder.backup import rpcapi as backup_rpcapi
 from cinder.common import constants
@@ -525,18 +525,16 @@ class AdminActionsTest(BaseAdminTest):
                                force_host_copy=False, version=None,
                                cluster=None):
         # build request to migrate to host
-        # req = fakes.HTTPRequest.blank('/v3/%s/volumes/%s/action' % (
-        #     fake.PROJECT_ID, volume['id']))
         req = webob.Request.blank('/v3/%s/volumes/%s/action' % (
             fake.PROJECT_ID, volume['id']))
         req.method = 'POST'
         req.headers['content-type'] = 'application/json'
         body = {'os-migrate_volume': {'host': host,
                                       'force_host_copy': force_host_copy}}
-        version = version or '3.0'
+        version = version or mv.BASE_VERSION
-        req.headers = {'OpenStack-API-Version': 'volume %s' % version}
+        req.headers = mv.get_mv_header(version)
-        req.api_version_request = api_version.APIVersionRequest(version)
+        req.api_version_request = mv.get_api_version(version)
-        if version == '3.16':
+        if version == mv.VOLUME_MIGRATE_CLUSTER:
             body['os-migrate_volume']['cluster'] = cluster
         req.body = jsonutils.dump_as_bytes(body)
         req.environ['cinder.context'] = ctx
@@ -547,7 +545,9 @@ class AdminActionsTest(BaseAdminTest):
         volume = db.volume_get(self.ctx, volume['id'])
         return volume
 
-    @ddt.data('3.0', '3.15', '3.16')
+    @ddt.data(mv.BASE_VERSION,
+              mv.get_prior_version(mv.VOLUME_MIGRATE_CLUSTER),
+              mv.VOLUME_MIGRATE_CLUSTER)
     def test_migrate_volume_success_3(self, version):
         expected_status = http_client.ACCEPTED
         host = 'test2'
@@ -563,7 +563,8 @@ class AdminActionsTest(BaseAdminTest):
         cluster = 'cluster'
         volume = self._migrate_volume_prep()
         volume = self._migrate_volume_3_exec(self.ctx, volume, host,
-                                             expected_status, version='3.16',
+                                             expected_status,
+                                             version=mv.VOLUME_MIGRATE_CLUSTER,
                                              cluster=cluster)
         self.assertEqual('starting', volume['migration_status'])
 
@@ -574,7 +575,8 @@ class AdminActionsTest(BaseAdminTest):
         volume = self._migrate_volume_prep()
         self.assertRaises(exception.InvalidInput,
                           self._migrate_volume_3_exec, self.ctx, volume, host,
-                          None, version='3.16', cluster=cluster)
+                          None, version=mv.VOLUME_MIGRATE_CLUSTER,
+                          cluster=cluster)
 
     def _migrate_volume_exec(self, ctx, volume, host, expected_status,
                              force_host_copy=False):

cinder/tests/unit/api/contrib/test_backup_project_attribute.py

@@ -17,7 +17,7 @@ import ddt
 from oslo_serialization import jsonutils
 import webob
 
-from cinder.api.openstack import api_version_request as api_version
+from cinder.api import microversions as mv
 from cinder.api.v3 import router as router_v3
 from cinder.backup import api as backup_api
 from cinder import context
@@ -57,7 +57,8 @@ class BackupProjectAttributeTest(test.TestCase):
         self.stubs.Set(backup_api.API, 'get', fake_backup_get)
         self.stubs.Set(backup_api.API, 'get_all', fake_backup_get_all)
 
-    def _send_backup_request(self, ctx, detail=False, version='3.18'):
+    def _send_backup_request(self, ctx, detail=False,
+                             version=mv.BACKUP_PROJECT):
         req = None
         if detail:
             req = webob.Request.blank(('/v3/%s/backups/detail'
@@ -67,8 +68,8 @@ class BackupProjectAttributeTest(test.TestCase):
                                                              fake.BACKUP_ID))
         req.method = 'GET'
         req.environ['cinder.context'] = ctx
-        req.headers['OpenStack-API-Version'] = 'volume ' + version
+        req.headers = mv.get_mv_header(version)
-        req.api_version_request = api_version.APIVersionRequest(version)
+        req.api_version_request = mv.get_api_version(version)
         res = req.get_response(app())
 
         if detail:
@@ -97,5 +98,6 @@ class BackupProjectAttributeTest(test.TestCase):
 
     def test_get_backup_under_allowed_api_version(self):
         ctx = context.RequestContext(fake.USER2_ID, fake.PROJECT_ID, True)
-        bak = self._send_backup_request(ctx, version='3.17')
+        bak = self._send_backup_request(
+            ctx, version=mv.get_prior_version(mv.BACKUP_PROJECT))
         self.assertNotIn('os-backup-project-attr:project_id', bak)

cinder/tests/unit/api/contrib/test_backups.py

@@ -25,6 +25,7 @@ from six.moves import http_client
 import webob
 
 from cinder.api.contrib import backups
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 # needed for stubs to work
 import cinder.backup
@@ -117,8 +118,8 @@ class BackupsAPITestCase(test.TestCase):
         req = webob.Request.blank('/v3/%s/backups/%s' % (
                                   fake.PROJECT_ID, backup.id))
         req.method = 'GET'
+        req.headers = mv.get_mv_header(mv.BACKUP_METADATA)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.43'
         res = req.get_response(fakes.wsgi_app(
             fake_auth_context=self.user_context))
         res_dict = jsonutils.loads(res.body)
@@ -131,6 +132,7 @@ class BackupsAPITestCase(test.TestCase):
         req = webob.Request.blank('/v2/%s/backups/%s' % (
             fake.PROJECT_ID, fake.WILL_NOT_BE_FOUND_ID))
         req.method = 'GET'
+        req.headers = mv.get_mv_header(mv.BACKUP_METADATA)
         req.headers['Content-Type'] = 'application/json'
         res = req.get_response(fakes.wsgi_app(
             fake_auth_context=self.user_context))
@@ -330,9 +332,9 @@ class BackupsAPITestCase(test.TestCase):
 
         req = webob.Request.blank('/v3/%s/backups/detail' % fake.PROJECT_ID)
         req.method = 'GET'
+        req.headers = mv.get_mv_header(mv.BACKUP_METADATA)
         req.headers['Content-Type'] = 'application/json'
         req.headers['Accept'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.43'
         res = req.get_response(fakes.wsgi_app(
             fake_auth_context=self.user_context))
         res_dict = jsonutils.loads(res.body)
@@ -536,8 +538,8 @@ class BackupsAPITestCase(test.TestCase):
                 }
         req = webob.Request.blank('/v3/%s/backups' % fake.PROJECT_ID)
         req.method = 'POST'
+        req.headers = mv.get_mv_header(mv.BACKUP_METADATA)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.43'
         req.body = jsonutils.dump_as_bytes(body)
         res = req.get_response(fakes.wsgi_app(
             fake_auth_context=self.user_context))
@@ -546,8 +548,8 @@ class BackupsAPITestCase(test.TestCase):
         req = webob.Request.blank('/v3/%s/backups/%s' % (
                                   fake.PROJECT_ID, res_dict['backup']['id']))
         req.method = 'GET'
+        req.headers = mv.get_mv_header(mv.BACKUP_METADATA)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.43'
         res = req.get_response(fakes.wsgi_app(
             fake_auth_context=self.user_context))
         res_dict = jsonutils.loads(res.body)

cinder/tests/unit/api/contrib/test_scheduler_stats.py

@@ -19,6 +19,7 @@ import mock
 import webob
 
 from cinder.api.contrib import scheduler_stats
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder import context
 from cinder import exception
@@ -84,7 +85,7 @@ class SchedulerStatsAPITest(test.TestCase):
                                       fake.PROJECT_ID)
         mock_rpcapi.return_value = [dict(name='pool1',
                                          capabilities=dict(foo='bar'))]
-        req.api_version_request = api_version.APIVersionRequest('3.28')
+        req.api_version_request = mv.get_api_version(mv.POOL_FILTER)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.get_pools(req)
 
@@ -106,7 +107,7 @@ class SchedulerStatsAPITest(test.TestCase):
                                       '&foo=bar' % fake.PROJECT_ID)
         mock_rpcapi.return_value = [dict(name='pool1',
                                          capabilities=dict(foo='bar'))]
-        req.api_version_request = api_version.APIVersionRequest('3.28')
+        req.api_version_request = mv.get_api_version(mv.POOL_FILTER)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.get_pools(req)
 
@@ -175,8 +176,8 @@ class SchedulerStatsAPITest(test.TestCase):
                           self.controller.get_pools,
                           req)
 
-    @ddt.data(('3.34', False),
+    @ddt.data((mv.get_prior_version(mv.POOL_TYPE_FILTER), False),
-              ('3.35', True))
+              (mv.POOL_TYPE_FILTER, True))
     @ddt.unpack
     @mock.patch('cinder.scheduler.rpcapi.SchedulerAPI.get_pools')
     @mock.patch('cinder.api.common.reject_invalid_filters')

cinder/tests/unit/api/contrib/test_services.py

@@ -25,7 +25,7 @@ import webob.exc
 
 from cinder.api.contrib import services
 from cinder.api import extensions
-from cinder.api.openstack import api_version_request as api_version
+from cinder.api import microversions as mv
 from cinder import context
 from cinder import exception
 from cinder import objects
@@ -114,10 +114,10 @@ fake_services_list = [
 class FakeRequest(object):
     environ = {"cinder.context": context.get_admin_context()}
 
-    def __init__(self, version='3.0', **kwargs):
+    def __init__(self, version=mv.BASE_VERSION, **kwargs):
         self.GET = kwargs
-        self.headers = {'OpenStack-API-Version': 'volume ' + version}
+        self.headers = mv.get_mv_header(version)
-        self.api_version_request = api_version.APIVersionRequest(version)
+        self.api_version_request = mv.get_api_version(version)
 
 
 class FakeRequestWithBinary(FakeRequest):
@@ -246,19 +246,19 @@ class ServicesTest(test.TestCase):
         self.assertEqual(response, res_dict)
 
     def test_failover_old_version(self):
-        req = FakeRequest(version='3.18')
+        req = FakeRequest(version=mv.BACKUP_PROJECT)
         self.assertRaises(exception.InvalidInput, self.controller.update, req,
                           'failover', {'cluster': 'cluster1'})
 
     def test_failover_no_values(self):
-        req = FakeRequest(version='3.26')
+        req = FakeRequest(version=mv.REPLICATION_CLUSTER)
         self.assertRaises(exception.InvalidInput, self.controller.update, req,
                           'failover', {'backend_id': 'replica1'})
 
     @ddt.data({'host': 'hostname'}, {'cluster': 'mycluster'})
     @mock.patch('cinder.volume.api.API.failover')
     def test_failover(self, body, failover_mock):
-        req = FakeRequest(version='3.26')
+        req = FakeRequest(version=mv.REPLICATION_CLUSTER)
         body['backend_id'] = 'replica1'
         res = self.controller.update(req, 'failover', body)
         self.assertEqual(202, res.status_code)
@@ -269,14 +269,14 @@ class ServicesTest(test.TestCase):
     @ddt.data({}, {'host': 'hostname', 'cluster': 'mycluster'})
     @mock.patch('cinder.volume.api.API.failover')
     def test_failover_invalid_input(self, body, failover_mock):
-        req = FakeRequest(version='3.26')
+        req = FakeRequest(version=mv.REPLICATION_CLUSTER)
         body['backend_id'] = 'replica1'
         self.assertRaises(exception.InvalidInput,
                           self.controller.update, req, 'failover', body)
         failover_mock.assert_not_called()
 
     def test_services_list_with_cluster_name(self):
-        req = FakeRequest(version='3.7')
+        req = FakeRequest(version=mv.CLUSTER_SUPPORT)
         res_dict = self.controller.index(req)
 
         response = {'services': [{'binary': 'cinder-scheduler',
@@ -689,7 +689,7 @@ class ServicesTest(test.TestCase):
     def test_services_action_cluster_not_found(self, method, body,
                                                mock_get_all_services):
         url = '/v3/%s/os-services/%s' % (fake.PROJECT_ID, method)
-        req = fakes.HTTPRequest.blank(url, version='3.26')
+        req = fakes.HTTPRequest.blank(url, version=mv.REPLICATION_CLUSTER)
         mock_get_all_services.return_value = []
         msg = 'No service found with cluster=%s' % mock.sentinel.cluster
         result = self.assertRaises(exception.InvalidInput,
@@ -729,7 +729,7 @@ class ServicesTest(test.TestCase):
     @mock.patch('cinder.api.contrib.services.ServiceController._set_log')
     def test_set_log(self, set_log_mock):
         set_log_mock.return_value = None
-        req = FakeRequest(version='3.32')
+        req = FakeRequest(version=mv.LOG_LEVEL)
         body = mock.sentinel.body
         res = self.controller.update(req, 'set-log', body)
         self.assertEqual(set_log_mock.return_value, res)
@@ -738,7 +738,7 @@ class ServicesTest(test.TestCase):
     @mock.patch('cinder.api.contrib.services.ServiceController._get_log')
     def test_get_log(self, get_log_mock):
         get_log_mock.return_value = None
-        req = FakeRequest(version='3.32')
+        req = FakeRequest(version=mv.LOG_LEVEL)
         body = mock.sentinel.body
         res = self.controller.update(req, 'get-log', body)
         self.assertEqual(get_log_mock.return_value, res)

cinder/tests/unit/api/contrib/test_used_limits.py

@@ -17,6 +17,7 @@ import ddt
 import mock
 
 from cinder.api.contrib import used_limits
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request
 from cinder.api.openstack import wsgi
 from cinder import exception
@@ -40,8 +41,11 @@ class UsedLimitsTestCase(test.TestCase):
         super(UsedLimitsTestCase, self).setUp()
         self.controller = used_limits.UsedLimitsController()
 
-    @ddt.data(('2.0', False), ('3.38', True), ('3.38', False), ('3.39', True),
+    @ddt.data(('2.0', False),
-              ('3.39', False))
+              (mv.get_prior_version(mv.LIMITS_ADMIN_FILTER), True),
+              (mv.get_prior_version(mv.LIMITS_ADMIN_FILTER), False),
+              (mv.LIMITS_ADMIN_FILTER, True),
+              (mv.LIMITS_ADMIN_FILTER, False))
     @mock.patch('cinder.quota.QUOTAS.get_project_quotas')
     @mock.patch('cinder.policy.enforce')
     def test_used_limits(self, ver_project, _mock_policy_enforce,
@@ -78,9 +82,9 @@ class UsedLimitsTestCase(test.TestCase):
         self.controller.index(fake_req, res)
         abs_limits = res.obj['limits']['absolute']
 
-        # if admin, only 3.39 and req contains project_id filter, cinder
+        # if admin, only LIMITS_ADMIN_FILTER and req contains project_id
-        # returns the specified project's quota.
+        # filter, cinder returns the specified project's quota.
-        if version == '3.39' and has_project:
+        if version == mv.LIMITS_ADMIN_FILTER and has_project:
             self.assertEqual(1, abs_limits['totalGigabytesUsed'])
         else:
             self.assertEqual(2, abs_limits['totalGigabytesUsed'])

cinder/tests/unit/api/contrib/test_volume_actions.py

@@ -24,7 +24,7 @@ from six.moves import http_client
 import webob
 
 from cinder.api.contrib import volume_actions
-from cinder.api.openstack import api_version_request as api_version
+from cinder.api import microversions as mv
 from cinder import context
 from cinder import db
 from cinder import exception
@@ -818,7 +818,7 @@ class VolumeImageActionsTest(test.TestCase):
             'size': 0}
         return ret
 
-    def fake_image_service_create_3_1(self, *args):
+    def fake_image_service_create_with_params(self, *args):
         ret = {
             'status': u'queued',
             'name': u'image_name',
@@ -1017,13 +1017,13 @@ class VolumeImageActionsTest(test.TestCase):
                           id,
                           body)
 
-    @ddt.data({'version': '3.41',
+    @ddt.data({'version': mv.get_prior_version(mv.VOLUME_EXTEND_INUSE),
                'status': 'available'},
-              {'version': '3.41',
+              {'version': mv.get_prior_version(mv.VOLUME_EXTEND_INUSE),
                'status': 'in-use'},
-              {'version': '3.42',
+              {'version': mv.VOLUME_EXTEND_INUSE,
                'status': 'available'},
-              {'version': '3.42',
+              {'version': mv.VOLUME_EXTEND_INUSE,
                'status': 'in-use'})
     @ddt.unpack
     def test_extend_attached_volume(self, version, status):
@@ -1035,9 +1035,9 @@ class VolumeImageActionsTest(test.TestCase):
         body = {"os-extend": {"new_size": 2}}
         req = fakes.HTTPRequest.blank('/v3/%s/volumes/%s/action' %
                                       (fake.PROJECT_ID, vol['id']))
-        req.api_version_request = api_version.APIVersionRequest(version)
+        req.api_version_request = mv.get_api_version(version)
         self.controller._extend(req, vol['id'], body)
-        if version == '3.42' and status == 'in-use':
+        if version == mv.VOLUME_EXTEND_INUSE and status == 'in-use':
             mock_extend.assert_called_with(req.environ['cinder.context'],
                                            vol, 2, attached=True)
         else:
@@ -1117,8 +1117,8 @@ class VolumeImageActionsTest(test.TestCase):
         id = 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee'
         req = fakes.HTTPRequest.blank('/v3/tenant1/volumes/%s/action' % id)
         req.environ['cinder.context'].is_admin = False
-        req.headers = {'OpenStack-API-Version': 'volume 3.1'}
+        req.headers = mv.get_mv_header(mv.UPLOAD_IMAGE_PARAMS)
-        req.api_version_request = api_version.APIVersionRequest('3.1')
+        req.api_version_request = mv.get_api_version(mv.UPLOAD_IMAGE_PARAMS)
         body = self._get_os_volume_upload_image()
         body['os-volume_upload_image']['visibility'] = 'public'
         self.assertRaises(exception.PolicyNotAuthorized,
@@ -1311,7 +1311,7 @@ class VolumeImageActionsTest(test.TestCase):
     @mock.patch.object(volume_api.API, "get_volume_image_metadata")
     @mock.patch.object(glance.GlanceImageService, "create")
     @mock.patch.object(volume_rpcapi.VolumeAPI, "copy_volume_to_image")
-    def test_copy_volume_to_image_version_3_1(
+    def test_copy_volume_to_image_version_with_params(
             self,
             mock_copy_volume_to_image,
             mock_create,
@@ -1323,7 +1323,7 @@ class VolumeImageActionsTest(test.TestCase):
             "volume_id": volume.id,
             "key": "x_billing_code_license",
             "value": "246254365"}
-        mock_create.side_effect = self.fake_image_service_create_3_1
+        mock_create.side_effect = self.fake_image_service_create_with_params
         mock_copy_volume_to_image.side_effect = \
             self.fake_rpc_copy_volume_to_image
 
@@ -1333,8 +1333,8 @@ class VolumeImageActionsTest(test.TestCase):
             '/v3/%s/volumes/%s/action' % (fake.PROJECT_ID, volume.id),
             use_admin_context=self.context.is_admin)
         req.environ['cinder.context'].is_admin = True
-        req.headers = {'OpenStack-API-Version': 'volume 3.1'}
+        req.headers = mv.get_mv_header(mv.UPLOAD_IMAGE_PARAMS)
-        req.api_version_request = api_version.APIVersionRequest('3.1')
+        req.api_version_request = mv.get_api_version(mv.UPLOAD_IMAGE_PARAMS)
         body = self._get_os_volume_upload_image()
         body['os-volume_upload_image']['visibility'] = 'public'
         body['os-volume_upload_image']['protected'] = True

cinder/tests/unit/api/contrib/test_volume_manage.py

@@ -23,6 +23,7 @@ from six.moves.urllib.parse import urlencode
 import webob
 
 from cinder.api.contrib import volume_manage
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder import context
 from cinder import exception
@@ -226,15 +227,15 @@ class VolumeManageTest(test.TestCase):
         self.assertEqual(body['volume']['ref'], args[3])
         self.assertTrue(mock_validate.called)
 
-    def _get_resp_create(self, body, version='3.0'):
+    def _get_resp_create(self, body, version=mv.BASE_VERSION):
         url = '/v3/%s/os-volume-manage' % fake.PROJECT_ID
         req = webob.Request.blank(url, base_url='http://localhost.com' + url)
         req.method = 'POST'
+        req.headers = mv.get_mv_header(version)
         req.headers['Content-Type'] = 'application/json'
         req.environ['cinder.context'] = self._admin_ctxt
         req.body = jsonutils.dump_as_bytes(body)
-        req.headers = {'OpenStack-API-Version': 'volume %s' % version}
+        req.api_version_request = mv.get_api_version(version)
-        req.api_version_request = api_version.APIVersionRequest(version)
         res = self.controller.create(req, body)
         return res
 
@@ -244,7 +245,7 @@ class VolumeManageTest(test.TestCase):
     def test_manage_volume_ok_cluster(self, mock_validate, mock_api_manage):
         body = {'volume': {'cluster': 'cluster',
                            'ref': 'fake_ref'}}
-        res = self._get_resp_create(body, '3.16')
+        res = self._get_resp_create(body, mv.VOLUME_MIGRATE_CLUSTER)
         self.assertEqual(['volume'], list(res.keys()))
 
         # Check that the manage API was called with the correct arguments.
@@ -262,7 +263,8 @@ class VolumeManageTest(test.TestCase):
                            'cluster': 'cluster',
                            'ref': 'fake_ref'}}
         self.assertRaises(exception.InvalidInput,
-                          self._get_resp_create, body, '3.16')
+                          self._get_resp_create, body,
+                          mv.VOLUME_MIGRATE_CLUSTER)
 
     def test_manage_volume_missing_host(self):
         """Test correct failure when host is not specified."""
@@ -485,7 +487,7 @@ class VolumeManageTest(test.TestCase):
         """Test managing volume to return 'creating' status in V3 API."""
         body = {'volume': {'host': 'host_ok',
                            'ref': 'fake_ref'}}
-        res = self._get_resp_post_v3(body, '3.15')
+        res = self._get_resp_post_v3(body, mv.ETAGS)
         self.assertEqual(http_client.ACCEPTED, res.status_int)
         self.assertEqual(1, mock_api_manage.call_count)
         self.assertEqual('creating',

cinder/tests/unit/api/v3/test_attachments.py

@@ -21,6 +21,7 @@ import ddt
 import mock
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import attachments as v3_attachments
 from cinder import context
 from cinder import exception
@@ -31,8 +32,6 @@ from cinder.tests.unit import fake_constants as fake
 from cinder.volume import api as volume_api
 from cinder.volume import rpcapi as volume_rpcapi
 
-ATTACHMENTS_MICRO_VERSION = '3.27'
-
 
 @ddt.ddt
 class AttachmentsAPITestCase(test.TestCase):
@@ -81,7 +80,7 @@ class AttachmentsAPITestCase(test.TestCase):
     def test_create_attachment(self):
         req = fakes.HTTPRequest.blank('/v3/%s/attachments' %
                                       fake.PROJECT_ID,
-                                      version=ATTACHMENTS_MICRO_VERSION)
+                                      version=mv.NEW_ATTACH)
         body = {
             "attachment":
                 {
@@ -104,7 +103,7 @@ class AttachmentsAPITestCase(test.TestCase):
         mock_update.return_value = fake_connector
         req = fakes.HTTPRequest.blank('/v3/%s/attachments/%s' %
                                       (fake.PROJECT_ID, self.attachment1.id),
-                                      version=ATTACHMENTS_MICRO_VERSION,
+                                      version=mv.NEW_ATTACH,
                                       use_admin_context=True)
         body = {
             "attachment":
@@ -124,7 +123,7 @@ class AttachmentsAPITestCase(test.TestCase):
         mock_get.return_value = {'project_id': fake.PROJECT2_ID}
         req = fakes.HTTPRequest.blank('/v3/%s/attachments/%s' %
                                       (fake.PROJECT_ID, self.attachment1.id),
-                                      version=ATTACHMENTS_MICRO_VERSION,
+                                      version=mv.NEW_ATTACH,
                                       use_admin_context=False)
         body = {
             "attachment":
@@ -139,7 +138,8 @@ class AttachmentsAPITestCase(test.TestCase):
                           self.controller.delete, req,
                           self.attachment1.id)
 
-    @ddt.data('3.30', '3.31', '3.34')
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER),
+              mv.RESOURCE_FILTER, mv.LIKE_FILTER)
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_attachment_list_with_general_filter(self, version, mock_update):
         url = '/v3/%s/attachments' % fake.PROJECT_ID
@@ -148,8 +148,8 @@ class AttachmentsAPITestCase(test.TestCase):
                                       use_admin_context=False)
         self.controller.index(req)
 
-        if version != '3.30':
+        if version != mv.get_prior_version(mv.RESOURCE_FILTER):
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'attachment',
                                                 support_like)
@@ -164,7 +164,7 @@ class AttachmentsAPITestCase(test.TestCase):
             attach_status=status)
         req = fakes.HTTPRequest.blank('/v3/%s/attachments/%s' %
                                       (fake.PROJECT_ID, attachment.id),
-                                      version=ATTACHMENTS_MICRO_VERSION,
+                                      version=mv.NEW_ATTACH,
                                       use_admin_context=True)
 
         self.controller.delete(req, attachment.id)
@@ -201,7 +201,7 @@ class AttachmentsAPITestCase(test.TestCase):
     def test_create_attachment_without_resource_uuid(self, resource_uuid):
         req = fakes.HTTPRequest.blank('/v3/%s/attachments' %
                                       fake.PROJECT_ID,
-                                      version=ATTACHMENTS_MICRO_VERSION)
+                                      version=mv.NEW_ATTACH)
         body = {
             "attachment":
                 {
@@ -220,7 +220,7 @@ class AttachmentsAPITestCase(test.TestCase):
         if is_detail:
             url = '/v3/%s/groups/detail' % fake.PROJECT_ID
             list_func = self.controller.detail
-        req = fakes.HTTPRequest.blank(url, version=ATTACHMENTS_MICRO_VERSION,
+        req = fakes.HTTPRequest.blank(url, version=mv.NEW_ATTACH,
                                       use_admin_context=True)
         res_dict = list_func(req)
 
@@ -231,7 +231,7 @@ class AttachmentsAPITestCase(test.TestCase):
 
     def test_list_attachments_with_limit(self):
         url = '/v3/%s/attachments?limit=1' % fake.PROJECT_ID
-        req = fakes.HTTPRequest.blank(url, version=ATTACHMENTS_MICRO_VERSION,
+        req = fakes.HTTPRequest.blank(url, version=mv.NEW_ATTACH,
                                       use_admin_context=True)
         res_dict = self.controller.index(req)
 
@@ -241,7 +241,7 @@ class AttachmentsAPITestCase(test.TestCase):
     def test_list_attachments_with_marker(self):
         url = '/v3/%s/attachments?marker=%s' % (fake.PROJECT_ID,
                                                 self.attachment3.id)
-        req = fakes.HTTPRequest.blank(url, version=ATTACHMENTS_MICRO_VERSION,
+        req = fakes.HTTPRequest.blank(url, version=mv.NEW_ATTACH,
                                       use_admin_context=True)
         res_dict = self.controller.index(req)
 
@@ -254,7 +254,7 @@ class AttachmentsAPITestCase(test.TestCase):
     def test_list_attachments_with_sort(self, sort_dir):
         url = '/v3/%s/attachments?sort_key=id&sort_dir=%s' % (fake.PROJECT_ID,
                                                               sort_dir)
-        req = fakes.HTTPRequest.blank(url, version=ATTACHMENTS_MICRO_VERSION,
+        req = fakes.HTTPRequest.blank(url, version=mv.NEW_ATTACH,
                                       use_admin_context=True)
         res_dict = self.controller.index(req)
 
@@ -280,7 +280,7 @@ class AttachmentsAPITestCase(test.TestCase):
     @ddt.unpack
     def test_list_attachment_with_tenants(self, admin, request_url, count):
         url = '/v3/%s/attachments%s' % (fake.PROJECT_ID, request_url)
-        req = fakes.HTTPRequest.blank(url, version=ATTACHMENTS_MICRO_VERSION,
+        req = fakes.HTTPRequest.blank(url, version=mv.NEW_ATTACH,
                                       use_admin_context=admin)
         res_dict = self.controller.index(req)
 

cinder/tests/unit/api/v3/test_backups.py

@@ -19,6 +19,7 @@ import ddt
 import mock
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder.api.v3 import backups
 from cinder.api.views import backups as backup_view
@@ -44,7 +45,7 @@ class BackupsControllerAPITestCase(test.TestCase):
                                            is_admin=True)
         self.controller = backups.BackupsController()
 
-    def _fake_update_request(self, backup_id, version='3.9'):
+    def _fake_update_request(self, backup_id, version=mv.BACKUP_UPDATE):
         req = fakes.HTTPRequest.blank('/v3/%s/backups/%s/update' %
                                       (fake.PROJECT_ID, backup_id))
         req.environ['cinder.context'].is_admin = True
@@ -54,7 +55,8 @@ class BackupsControllerAPITestCase(test.TestCase):
         return req
 
     def test_update_wrong_version(self):
-        req = self._fake_update_request(fake.BACKUP_ID, version='3.6')
+        req = self._fake_update_request(
+            fake.BACKUP_ID, version=mv.get_prior_version(mv.BACKUP_UPDATE))
         body = {"backup": {"name": "Updated Test Name", }}
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
                           self.controller.update, req, fake.BACKUP_ID,
@@ -86,7 +88,9 @@ class BackupsControllerAPITestCase(test.TestCase):
                           self.controller.update,
                           req, fake.BACKUP_ID, body)
 
-    @ddt.data('3.30', '3.31', '3.34')
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER),
+              mv.RESOURCE_FILTER,
+              mv.LIKE_FILTER)
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_backup_list_with_general_filter(self, version, mock_update):
         url = '/v3/%s/backups' % fake.PROJECT_ID
@@ -95,13 +99,14 @@ class BackupsControllerAPITestCase(test.TestCase):
                                       use_admin_context=False)
         self.controller.index(req)
 
-        if version != '3.30':
+        if version != mv.get_prior_version(mv.RESOURCE_FILTER):
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'backup',
                                                 support_like)
 
-    @ddt.data('3.36', '3.37')
+    @ddt.data(mv.get_prior_version(mv.BACKUP_SORT_NAME),
+              mv.BACKUP_SORT_NAME)
     def test_backup_list_with_name(self, version):
         backup1 = test_utils.create_backup(
             self.ctxt, display_name='b_test_name',
@@ -111,7 +116,7 @@ class BackupsControllerAPITestCase(test.TestCase):
             status=fields.BackupStatus.AVAILABLE)
         url = '/v3/%s/backups?sort_key=name' % fake.PROJECT_ID
         req = fakes.HTTPRequest.blank(url, version=version)
-        if version == '3.36':
+        if version == mv.get_prior_version(mv.BACKUP_SORT_NAME):
             self.assertRaises(exception.InvalidInput,
                               self.controller.index,
                               req)

cinder/tests/unit/api/v3/test_cluster.py

@@ -21,6 +21,7 @@ import mock
 from oslo_utils import versionutils
 
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder.api.v3 import clusters
 from cinder import context
@@ -78,7 +79,7 @@ EXPECTED = [{'created_at': datetime.datetime(2016, 6, 1, 2, 46, 28),
 
 
 class FakeRequest(object):
-    def __init__(self, is_admin=True, version='3.7', **kwargs):
+    def __init__(self, is_admin=True, version=mv.CLUSTER_SUPPORT, **kwargs):
         self.GET = kwargs
         self.headers = {'OpenStack-API-Version': 'volume ' + version}
         self.api_version_request = api_version.APIVersionRequest(version)
@@ -108,8 +109,10 @@ class ClustersTestCase(test.TestCase):
     REPLICATION_FILTERS = ({'replication_status': 'error'}, {'frozen': True},
                            {'active_backend_id': 'replication'})
 
-    def _get_expected(self, version='3.8'):
+    def _get_expected(self,
-        if versionutils.convert_version_to_tuple(version) >= (3, 19):
+                      version=mv.get_prior_version(mv.REPLICATION_CLUSTER)):
+        if (versionutils.convert_version_to_tuple(version) >=
+                versionutils.convert_version_to_tuple(mv.REPLICATION_CLUSTER)):
             return EXPECTED
 
         expect = []
@@ -130,7 +133,7 @@ class ClustersTestCase(test.TestCase):
 
     @mock.patch('cinder.db.cluster_get_all', return_value=CLUSTERS_ORM)
     def _test_list(self, get_all_mock, detailed, filters=None, expected=None,
-                   version='3.8'):
+                   version=mv.get_prior_version(mv.REPLICATION_CLUSTER)):
         filters = filters or {}
         req = FakeRequest(version=version, **filters)
         method = getattr(self.controller, 'detail' if detailed else 'index')
@@ -187,14 +190,13 @@ class ClustersTestCase(test.TestCase):
         """Verify the wrong version so that user can't list clusters."""
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
                           self._test_list, detailed=detailed,
-                          version='3.6')
+                          version=mv.get_prior_version(mv.CLUSTER_SUPPORT))
 
     @ddt.data(*REPLICATION_FILTERS)
     def test_index_detail_replication_new_fields(self, filters):
-        version = '3.26'
+        expected = {'clusters': self._get_expected(mv.REPLICATION_CLUSTER)}
-        expected = {'clusters': self._get_expected(version)}
         self._test_list(detailed=True, filters=filters, expected=expected,
-                        version=version)
+                        version=mv.REPLICATION_CLUSTER)
 
     @ddt.data(*REPLICATION_FILTERS)
     def test_index_summary_replication_new_fields(self, filters):
@@ -209,7 +211,7 @@ class ClustersTestCase(test.TestCase):
                                   'replication_status': 'error',
                                   'status': 'disabled'}]}
         self._test_list(detailed=False, filters=filters, expected=expected,
-                        version='3.26')
+                        version=mv.REPLICATION_CLUSTER)
 
     @mock.patch('cinder.db.sqlalchemy.api.cluster_get',
                 return_value=CLUSTERS_ORM[0])
@@ -232,7 +234,7 @@ class ClustersTestCase(test.TestCase):
                           self.controller.show, req, 'name')
 
     def test_show_wrong_version(self):
-        req = FakeRequest(version='3.5')
+        req = FakeRequest(version=mv.get_prior_version(mv.CLUSTER_SUPPORT))
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
                           self.controller.show, req, 'name')
 
@@ -307,6 +309,6 @@ class ClustersTestCase(test.TestCase):
 
     @ddt.data('enable', 'disable')
     def test_update_wrong_version(self, action):
-        req = FakeRequest(version='3.5')
+        req = FakeRequest(version=mv.get_prior_version(mv.CLUSTER_SUPPORT))
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
                           self.controller.update, req, action, {})

cinder/tests/unit/api/v3/test_consistencygroups.py

@@ -15,6 +15,7 @@ import ddt
 from six.moves import http_client
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder.api.v3 import consistencygroups
 from cinder import context
@@ -72,9 +73,10 @@ class ConsistencyGroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/consistencygroups/%s/update' %
                                       (fake.PROJECT_ID, consistencygroup.id))
         req.environ['cinder.context'].is_admin = True
+        req.headers = mv.get_mv_header(mv.CG_UPDATE_BLANK_PROPERTIES)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.6'
+        req.api_version_request = mv.get_api_version(
-        req.api_version_request = api_version.APIVersionRequest('3.6')
+            mv.CG_UPDATE_BLANK_PROPERTIES)
         body = {"consistencygroup": {"name": "",
                                      "description": "",
                                      "add_volumes": None,
@@ -118,9 +120,10 @@ class ConsistencyGroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/consistencygroups/%s/update' %
                                       (fake.PROJECT_ID, consistencygroup.id))
         req.environ['cinder.context'].is_admin = True
+        req.headers = mv.get_mv_header(mv.CG_UPDATE_BLANK_PROPERTIES)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.6'
+        req.api_version_request = mv.get_api_version(
-        req.api_version_request = api_version.APIVersionRequest('3.6')
+            mv.CG_UPDATE_BLANK_PROPERTIES)
         body = {"consistencygroup": {"name": None,
                                      "description": None,
                                      "add_volumes": None,
@@ -132,16 +135,20 @@ class ConsistencyGroupsAPITestCase(test.TestCase):
                                 req, consistencygroup.id, body)
         consistencygroup.destroy()
 
-    def test_update_consistencygroup_all_empty_parameters_not_version_36(self):
+    def test_update_consistencygroup_all_empty_parameters_not_version_ok(self):
         consistencygroup = self._create_consistencygroup(
             ctxt=self.ctxt,
             status=fields.ConsistencyGroupStatus.AVAILABLE)
         req = fakes.HTTPRequest.blank('/v3/%s/consistencygroups/%s/update' %
                                       (fake.PROJECT_ID, consistencygroup.id))
         req.environ['cinder.context'].is_admin = True
+
+        non_supported_version = mv.get_prior_version(
+            mv.CG_UPDATE_BLANK_PROPERTIES)
+        req.headers = mv.get_mv_header(non_supported_version)
+        req.api_version_request = mv.get_api_version(non_supported_version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.5'
+
-        req.api_version_request = api_version.APIVersionRequest('3.5')
         body = {"consistencygroup": {"name": None,
                                      "description": None,
                                      "add_volumes": None,
@@ -160,9 +167,13 @@ class ConsistencyGroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/consistencygroups/%s/update' %
                                       (fake.PROJECT_ID, consistencygroup.id))
         req.environ['cinder.context'].is_admin = True
+
+        non_supported_version = mv.get_prior_version(
+            mv.CG_UPDATE_BLANK_PROPERTIES)
+        req.headers = mv.get_mv_header(non_supported_version)
+        req.api_version_request = mv.get_api_version(non_supported_version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.5'
+
-        req.api_version_request = api_version.APIVersionRequest('3.5')
         body = None
         self.assertRaisesRegexp(webob.exc.HTTPBadRequest,
                                 "Missing request body",
@@ -177,9 +188,13 @@ class ConsistencyGroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/consistencygroups/%s/update' %
                                       (fake.PROJECT_ID, consistencygroup.id))
         req.environ['cinder.context'].is_admin = True
+
+        non_supported_version = mv.get_prior_version(
+            mv.CG_UPDATE_BLANK_PROPERTIES)
+        req.headers = mv.get_mv_header(non_supported_version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume 3.5'
+
-        req.api_version_request = api_version.APIVersionRequest('3.5')
+        req.api_version_request = mv.get_api_version(non_supported_version)
         body = {"consistencygroup": {"name": "my_fake_cg",
                                      "description": "fake consistency group",
                                      "add_volumes": "volume-uuid-1",

cinder/tests/unit/api/v3/test_group_snapshots.py

@@ -22,6 +22,7 @@ import mock
 from six.moves import http_client
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import group_snapshots as v3_group_snapshots
 from cinder import context
 from cinder import db
@@ -35,9 +36,6 @@ from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import utils
 import cinder.volume
 
-GROUP_MICRO_VERSION = '3.14'
-SUPPORT_FILTER_VERSION = '3.29'
-
 
 @ddt.ddt
 class GroupSnapshotsAPITestCase(test.TestCase):
@@ -76,7 +74,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             self.context, group_id=self.group.id)
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s' %
                                       (fake.PROJECT_ID, group_snapshot.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         res_dict = self.controller.show(req, group_snapshot.id)
 
         self.assertEqual(1, len(res_dict))
@@ -95,7 +93,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         url = '/v3/%s/group_snapshots?limit=1' % fake.PROJECT_ID
         if is_detail:
             url = '/v3/%s/group_snapshots/detail?limit=1' % fake.PROJECT_ID
-        req = fakes.HTTPRequest.blank(url, version=SUPPORT_FILTER_VERSION)
+        req = fakes.HTTPRequest.blank(url,
+                                      version=mv.GROUP_SNAPSHOT_PAGINATION)
         if is_detail:
             res_dict = self.controller.detail(req)
         else:
@@ -122,7 +121,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         url = '/v3/%s/group_snapshots?offset=1' % fake.PROJECT_ID
         if is_detail:
             url = '/v3/%s/group_snapshots/detail?offset=1' % fake.PROJECT_ID
-        req = fakes.HTTPRequest.blank(url, version=SUPPORT_FILTER_VERSION)
+        req = fakes.HTTPRequest.blank(url,
+                                      version=mv.GROUP_SNAPSHOT_PAGINATION)
         if is_detail:
             res_dict = self.controller.detail(req)
         else:
@@ -146,7 +146,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         if is_detail:
             url = ('/v3/%s/group_snapshots/detail?offset=234523423455454' %
                    fake.PROJECT_ID)
-        req = fakes.HTTPRequest.blank(url, version=SUPPORT_FILTER_VERSION)
+        req = fakes.HTTPRequest.blank(url,
+                                      version=mv.GROUP_SNAPSHOT_PAGINATION)
         if is_detail:
             self.assertRaises(webob.exc.HTTPBadRequest, self.controller.detail,
                               req)
@@ -164,7 +165,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         if is_detail:
             url = ('/v3/%s/group_snapshots/detail?limit=2&offset=1' %
                    fake.PROJECT_ID)
-        req = fakes.HTTPRequest.blank(url, version=SUPPORT_FILTER_VERSION)
+        req = fakes.HTTPRequest.blank(url,
+                                      version=mv.GROUP_SNAPSHOT_PAGINATION)
         if is_detail:
             res_dict = self.controller.detail(req)
         else:
@@ -184,7 +186,9 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                              res_dict['group_snapshots'][0].keys())
         group_snapshot.destroy()
 
-    @ddt.data('3.30', '3.31', '3.34')
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER),
+              mv.RESOURCE_FILTER,
+              mv.LIKE_FILTER)
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_group_snapshot_list_with_general_filter(self,
                                                      version, mock_update):
@@ -194,8 +198,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                                       use_admin_context=False)
         self.controller.index(req)
 
-        if version != '3.30':
+        if version != mv.get_prior_version(mv.RESOURCE_FILTER):
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'group_snapshot',
                                                 support_like)
@@ -209,7 +213,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             url = ('/v3/%s/group_snapshots/detail?'
                    'all_tenants=True&id=%s') % (fake.PROJECT_ID,
                                                 self.g_snapshots_array[0].id)
-        req = fakes.HTTPRequest.blank(url, version=SUPPORT_FILTER_VERSION,
+        req = fakes.HTTPRequest.blank(url,
+                                      version=mv.GROUP_SNAPSHOT_PAGINATION,
                                       use_admin_context=True)
         if is_detail:
             res_dict = self.controller.detail(req)
@@ -226,10 +231,10 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             self.assertNotIn('description',
                              res_dict['group_snapshots'][0].keys())
 
-    @ddt.data({'is_detail': True, 'version': GROUP_MICRO_VERSION},
+    @ddt.data({'is_detail': True, 'version': mv.GROUP_SNAPSHOTS},
-              {'is_detail': False, 'version': GROUP_MICRO_VERSION},
+              {'is_detail': False, 'version': mv.GROUP_SNAPSHOTS},
-              {'is_detail': True, 'version': '3.28'},
+              {'is_detail': True, 'version': mv.POOL_FILTER},
-              {'is_detail': False, 'version': '3.28'},)
+              {'is_detail': False, 'version': mv.POOL_FILTER},)
     @ddt.unpack
     def test_list_group_snapshot_with_filter_previous_version(self, is_detail,
                                                               version):
@@ -257,7 +262,8 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         if is_detail:
             url = ('/v3/%s/group_snapshots/detail?sort=id:asc' %
                    fake.PROJECT_ID)
-        req = fakes.HTTPRequest.blank(url, version=SUPPORT_FILTER_VERSION)
+        req = fakes.HTTPRequest.blank(url,
+                                      version=mv.GROUP_SNAPSHOT_PAGINATION)
         expect_result = [snapshot.id for snapshot in self.g_snapshots_array]
         expect_result.sort()
         if is_detail:
@@ -282,7 +288,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s' %
                                       (fake.PROJECT_ID,
                                        fake.WILL_NOT_BE_FOUND_ID),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(exception.GroupSnapshotNotFound,
                           self.controller.show,
                           req, fake.WILL_NOT_BE_FOUND_ID)
@@ -294,7 +300,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         else:
             request_url = '/v3/%s/group_snapshots'
         req = fakes.HTTPRequest.blank(request_url % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         if is_detail:
             res_dict = self.controller.detail(req)
         else:
@@ -326,7 +332,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                                    "group_id": self.group.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         res_dict = self.controller.create(req, body)
 
         self.assertEqual(1, len(res_dict))
@@ -356,7 +362,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                                    "group_id": group.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, body)
         self.assertTrue(mock_validate.called)
@@ -369,7 +375,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         # omit body from the request
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, None)
 
@@ -383,7 +389,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                                    "group_id": self.group.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, body)
 
@@ -397,7 +403,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                                    "group_id": self.group.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(exception.GroupSnapshotNotFound,
                           self.controller.create,
                           req, body)
@@ -413,7 +419,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
                                    "group_id": empty_group.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
 
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, body)
@@ -426,7 +432,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             status=fields.GroupSnapshotStatus.AVAILABLE)
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s' %
                                       (fake.PROJECT_ID, group_snapshot.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         res_dict = self.controller.delete(req, group_snapshot.id)
 
         group_snapshot = objects.GroupSnapshot.get_by_id(self.context,
@@ -450,7 +456,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             volume_type_ids=[fake.VOLUME_TYPE_ID],)
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s' %
                                       (fake.PROJECT_ID, group_snapshot.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.delete,
                           req, group_snapshot.id)
 
@@ -461,7 +467,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s' %
                                       (fake.PROJECT_ID,
                                        fake.WILL_NOT_BE_FOUND_ID),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(exception.GroupSnapshotNotFound,
                           self.controller.delete,
                           req, fake.WILL_NOT_BE_FOUND_ID)
@@ -473,19 +479,20 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             status='invalid')
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s' %
                                       (fake.PROJECT_ID, group_snapshot.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.delete,
                           req, group_snapshot.id)
 
         group_snapshot.destroy()
 
-    @ddt.data(('3.11', 'fake_snapshot_001',
+    @ddt.data((mv.GROUP_TYPE, 'fake_snapshot_001',
                fields.GroupSnapshotStatus.AVAILABLE,
                exception.VersionNotFoundForAPIMethod),
-              ('3.18', 'fake_snapshot_001',
+              (mv.get_prior_version(mv.GROUP_SNAPSHOT_RESET_STATUS),
+               'fake_snapshot_001',
                fields.GroupSnapshotStatus.AVAILABLE,
                exception.VersionNotFoundForAPIMethod),
-              ('3.19', 'fake_snapshot_001',
+              (mv.GROUP_SNAPSHOT_RESET_STATUS, 'fake_snapshot_001',
                fields.GroupSnapshotStatus.AVAILABLE,
                exception.GroupSnapshotNotFound))
     @ddt.unpack
@@ -509,7 +516,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             status=fields.GroupSnapshotStatus.CREATING)
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s/action' %
                                       (fake.PROJECT_ID, group_snapshot.id),
-                                      version='3.19')
+                                      version=mv.GROUP_SNAPSHOT_RESET_STATUS)
         body = {"reset_status": {
             "status": "invalid_test_status"
         }}
@@ -525,7 +532,7 @@ class GroupSnapshotsAPITestCase(test.TestCase):
             status=fields.GroupSnapshotStatus.CREATING)
         req = fakes.HTTPRequest.blank('/v3/%s/group_snapshots/%s/action' %
                                       (fake.PROJECT_ID, group_snapshot.id),
-                                      version='3.19')
+                                      version=mv.GROUP_SNAPSHOT_RESET_STATUS)
         body = {"reset_status": {
             "status": fields.GroupSnapshotStatus.AVAILABLE
         }}

cinder/tests/unit/api/v3/test_group_specs.py

@@ -21,12 +21,11 @@ from cinder import db
 from cinder import rpc
 from cinder import test
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import group_specs as v3_group_specs
 from cinder.tests.unit.api import fakes
 from cinder.tests.unit import fake_constants as fake
 
-GROUP_TYPE_MICRO_VERSION = '3.11'
-
 fake_group_specs = {
     'key1': 'value1',
     'key2': 'value2'
@@ -71,7 +70,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res_dict = self.controller.index(req, fake.GROUP_ID)
         group_specs_dict = res_dict['group_specs']
@@ -90,7 +89,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.controller.create(req, fake.GROUP_ID, create_fake_group_specs)
         self.assertTrue(mock_rpc_notifier.called)
 
@@ -108,7 +107,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.controller.update(req,
                                fake.GROUP_TYPE_ID,
                                'id',
@@ -124,7 +123,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         res_dict = self.controller.show(req, fake.GROUP_TYPE_ID, 'key1')
         self.assertEqual('value1', res_dict['key1'])
 
@@ -138,7 +137,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.controller.delete(req, fake.GROUP_TYPE_ID, 'key1')
         self.assertTrue(rpc_notifier_mock.called)
 
@@ -151,7 +150,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPNotFound,
                           self.controller.create,
                           req,
@@ -166,7 +165,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPNotFound,
                           self.controller.delete,
                           req,
@@ -178,7 +177,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.update,
                           req,
@@ -198,7 +197,7 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPNotFound,
                           self.controller.show,
                           req,
@@ -216,6 +215,6 @@ class GroupSpecsTestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('v3/%s/group_specs' %
                                       fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, fake.GROUP_ID, incorrect_fake_group_specs)

cinder/tests/unit/api/v3/test_group_types.py

@@ -23,6 +23,7 @@ import six
 import webob
 
 import cinder.api.common as common
+from cinder.api import microversions as mv
 from cinder.api.v3 import group_specs as v3_group_specs
 from cinder.api.v3 import group_types as v3_group_types
 from cinder.api.v3.views import group_types as views_types
@@ -33,7 +34,6 @@ from cinder.tests.unit.api import fakes
 from cinder.tests.unit import fake_constants as fake
 from cinder.volume import group_types
 
-GROUP_TYPE_MICRO_VERSION = '3.11'
 IN_USE_GROUP_TYPE = fake.GROUP_TYPE3_ID
 
 
@@ -132,7 +132,7 @@ class GroupTypesApiTest(test.TestCase):
             mock_create, mock_get):
         boolean_is_public = strutils.bool_from_string(is_public)
         req = fakes.HTTPRequest.blank('/v3/%s/types' % fake.PROJECT_ID,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
 
         body = {"group_type": {"is_public": is_public, "name": "group_type1",
@@ -157,7 +157,7 @@ class GroupTypesApiTest(test.TestCase):
             '_notify_group_type_error')
         req = fakes.HTTPRequest.blank('/v3/%s/group_types/%s' % (
             fake.PROJECT_ID, grp_type_id),
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         if grp_type_id == IN_USE_GROUP_TYPE:
             self.assertRaises(webob.exc.HTTPBadRequest,
@@ -177,7 +177,7 @@ class GroupTypesApiTest(test.TestCase):
 
         req = fakes.HTTPRequest.blank('/v3/%s/group_types' % fake.PROJECT_ID,
                                       use_admin_context=True,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         res_dict = self.controller.index(req)
 
         self.assertEqual(3, len(res_dict['group_types']))
@@ -193,7 +193,7 @@ class GroupTypesApiTest(test.TestCase):
                          return_empty_group_types_get_all_types)
 
         req = fakes.HTTPRequest.blank('/v3/%s/group_types' % fake.PROJECT_ID,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         res_dict = self.controller.index(req)
 
         self.assertEqual(0, len(res_dict['group_types']))
@@ -201,7 +201,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_limit(self):
         req = fakes.HTTPRequest.blank('/v3/%s/group_types?limit=1' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
 
@@ -216,7 +216,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_offset(self):
         req = fakes.HTTPRequest.blank(
             '/v3/%s/group_types?offset=1' % fake.PROJECT_ID,
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
 
@@ -224,14 +224,14 @@ class GroupTypesApiTest(test.TestCase):
 
     def test_group_types_index_with_offset_out_of_range(self):
         url = '/v3/%s/group_types?offset=424366766556787' % fake.PROJECT_ID
-        req = fakes.HTTPRequest.blank(url, version=GROUP_TYPE_MICRO_VERSION)
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.index, req)
 
     def test_group_types_index_with_limit_and_offset(self):
         req = fakes.HTTPRequest.blank(
             '/v3/%s/group_types?limit=2&offset=1' % fake.PROJECT_ID,
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
 
@@ -244,7 +244,7 @@ class GroupTypesApiTest(test.TestCase):
                                       '&marker=%s' %
                                       (fake.PROJECT_ID,
                                        self.type_id2),
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
 
@@ -254,7 +254,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_valid_filter(self):
         req = fakes.HTTPRequest.blank(
             '/v3/%s/group_types?is_public=True' % fake.PROJECT_ID,
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
 
@@ -267,7 +267,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_invalid_filter(self):
         req = fakes.HTTPRequest.blank(
             '/v3/%s/group_types?id=%s' % (fake.PROJECT_ID, self.type_id1),
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
 
@@ -276,7 +276,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_sort_keys(self):
         req = fakes.HTTPRequest.blank('/v3/%s/group_types?sort=id' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
         expect_result = [self.type_id0, self.type_id1, self.type_id2,
@@ -292,7 +292,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_sort_and_limit(self):
         req = fakes.HTTPRequest.blank(
             '/v3/%s/group_types?sort=id&limit=2' % fake.PROJECT_ID,
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
         expect_result = [self.type_id0, self.type_id1, self.type_id2,
@@ -306,7 +306,7 @@ class GroupTypesApiTest(test.TestCase):
     def test_group_types_index_with_sort_keys_and_sort_dirs(self):
         req = fakes.HTTPRequest.blank(
             '/v3/%s/group_types?sort=id:asc' % fake.PROJECT_ID,
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         res = self.controller.index(req)
         expect_result = [self.type_id0, self.type_id1, self.type_id2,
@@ -332,7 +332,7 @@ class GroupTypesApiTest(test.TestCase):
         type_id = six.text_type(uuid.uuid4())
         req = fakes.HTTPRequest.blank(
             '/v3/%s/types/%s' % (fake.PROJECT_ID, type_id),
-            version=GROUP_TYPE_MICRO_VERSION)
+            version=mv.GROUP_TYPE)
         req.environ['cinder.context'] = self.ctxt
         body = {"group_type": {"is_public": is_public, "name": "group_type1"}}
         self.controller.update(req, type_id, body)
@@ -347,7 +347,7 @@ class GroupTypesApiTest(test.TestCase):
         type_id = six.text_type(uuid.uuid4())
         req = fakes.HTTPRequest.blank('/v3/%s/group_types/' % fake.PROJECT_ID
                                       + type_id,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         res_dict = self.controller.show(req, type_id)
 
         self.assertEqual(1, len(res_dict))
@@ -359,10 +359,10 @@ class GroupTypesApiTest(test.TestCase):
         self.mock_object(group_types, 'get_group_type',
                          return_group_types_get_group_type)
 
-        type_id = six.text_type(uuid.uuid4())
+        type_id = uuid.uuid4()
-        req = fakes.HTTPRequest.blank('/v3/%s/group_types/' % fake.PROJECT_ID
+        req = fakes.HTTPRequest.blank(
-                                      + type_id,
+            '/v3/%s/group_types/%s' % (fake.PROJECT_ID, type_id),
-                                      version='3.5')
+            version=mv.get_prior_version(mv.GROUP_TYPE))
 
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
                           self.controller.show, req, type_id)
@@ -374,7 +374,7 @@ class GroupTypesApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/group_types/%s' %
                                       (fake.PROJECT_ID,
                                        fake.WILL_NOT_BE_FOUND_ID),
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         self.assertRaises(webob.exc.HTTPNotFound, self.controller.show,
                           req, fake.WILL_NOT_BE_FOUND_ID)
 
@@ -383,7 +383,7 @@ class GroupTypesApiTest(test.TestCase):
                          return_group_types_get_default)
         req = fakes.HTTPRequest.blank('/v3/%s/group_types/default' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.method = 'GET'
         res_dict = self.controller.show(req, 'default')
         self.assertEqual(1, len(res_dict))
@@ -396,7 +396,7 @@ class GroupTypesApiTest(test.TestCase):
                          return_group_types_get_default_not_found)
         req = fakes.HTTPRequest.blank('/v3/%s/group_types/default' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_TYPE_MICRO_VERSION)
+                                      version=mv.GROUP_TYPE)
         req.method = 'GET'
 
         self.assertRaises(webob.exc.HTTPNotFound,
@@ -419,7 +419,7 @@ class GroupTypesApiTest(test.TestCase):
         )
 
         request = fakes.HTTPRequest.blank("/v3",
-                                          version=GROUP_TYPE_MICRO_VERSION)
+                                          version=mv.GROUP_TYPE)
         output = view_builder.show(request, raw_group_type)
 
         self.assertIn('group_type', output)
@@ -448,7 +448,7 @@ class GroupTypesApiTest(test.TestCase):
         )
 
         request = fakes.HTTPRequest.blank("/v3", use_admin_context=True,
-                                          version=GROUP_TYPE_MICRO_VERSION)
+                                          version=mv.GROUP_TYPE)
         output = view_builder.show(request, raw_group_type)
 
         self.assertIn('group_type', output)
@@ -479,7 +479,7 @@ class GroupTypesApiTest(test.TestCase):
             )
 
             request = fakes.HTTPRequest.blank("/v3",
-                                              version=GROUP_TYPE_MICRO_VERSION)
+                                              version=mv.GROUP_TYPE)
             output = view_builder.show(request, raw_group_type)
 
             self.assertIn('group_type', output)
@@ -510,7 +510,7 @@ class GroupTypesApiTest(test.TestCase):
             )
 
             request = fakes.HTTPRequest.blank("/v3",
-                                              version=GROUP_TYPE_MICRO_VERSION)
+                                              version=mv.GROUP_TYPE)
             output = view_builder.show(request, raw_group_type)
 
             self.assertIn('group_type', output)
@@ -542,7 +542,7 @@ class GroupTypesApiTest(test.TestCase):
             )
 
             request = fakes.HTTPRequest.blank("/v3",
-                                              version=GROUP_TYPE_MICRO_VERSION)
+                                              version=mv.GROUP_TYPE)
             output = view_builder.show(request, raw_group_type)
 
             self.assertIn('group_type', output)
@@ -576,7 +576,7 @@ class GroupTypesApiTest(test.TestCase):
             )
 
         request = fakes.HTTPRequest.blank("/v3",
-                                          version=GROUP_TYPE_MICRO_VERSION)
+                                          version=mv.GROUP_TYPE)
         output = view_builder.index(request, raw_group_types)
 
         self.assertIn('group_types', output)
@@ -611,7 +611,7 @@ class GroupTypesApiTest(test.TestCase):
             )
 
         request = fakes.HTTPRequest.blank("/v3", use_admin_context=True,
-                                          version=GROUP_TYPE_MICRO_VERSION)
+                                          version=mv.GROUP_TYPE)
         output = view_builder.index(request, raw_group_types)
 
         self.assertIn('group_types', output)

cinder/tests/unit/api/v3/test_groups.py

@@ -22,6 +22,7 @@ import mock
 from six.moves import http_client
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import groups as v3_groups
 from cinder import context
 from cinder import db
@@ -36,10 +37,7 @@ from cinder.tests.unit import fake_constants as fake
 from cinder.tests.unit import utils
 from cinder.volume import api as volume_api
 
-GROUP_MICRO_VERSION = '3.13'
+INVALID_GROUP_REPLICATION = mv.get_prior_version(mv.GROUP_REPLICATION)
-GROUP_FROM_SRC_MICRO_VERSION = '3.14'
-GROUP_REPLICATION_MICRO_VERSION = '3.38'
-INVALID_GROUP_REPLICATION_MICRO_VERSION = '3.37'
 
 
 @ddt.ddt
@@ -134,7 +132,7 @@ class GroupsAPITestCase(test.TestCase):
 
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         res_dict = self.controller.show(req, self.group1.id)
 
         self.assertEqual(1, len(res_dict))
@@ -149,7 +147,10 @@ class GroupsAPITestCase(test.TestCase):
         self.assertEqual([fake.VOLUME_TYPE_ID],
                          res_dict['group']['volume_types'])
 
-    @ddt.data(('3.24', False), ('3.24', True), ('3.25', False), ('3.25', True))
+    @ddt.data((mv.get_prior_version(mv.GROUP_VOLUME_LIST), False),
+              (mv.get_prior_version(mv.GROUP_VOLUME_LIST), True),
+              (mv.GROUP_VOLUME_LIST, False),
+              (mv.GROUP_VOLUME_LIST, True))
     @ddt.unpack
     @mock.patch('cinder.objects.volume_type.VolumeTypeList.get_all_by_group')
     @mock.patch('cinder.objects.volume.VolumeList.get_all_by_generic_group')
@@ -178,10 +179,10 @@ class GroupsAPITestCase(test.TestCase):
         res_dict = self.controller.detail(req)
 
         # If the microversion >= 3.25 and "list_volume=True", "volumes" should
-        # be contained in the response body. Else,"volumes" should not be
+        # be contained in the response body. Else, "volumes" should not be
         # contained in the response body.
         self.assertEqual(3, len(res_dict['groups']))
-        if (version, has_list_volume) == ('3.25', True):
+        if (version, has_list_volume) == (mv.GROUP_VOLUME_LIST, True):
             self.assertEqual([fake.VOLUME_ID],
                              res_dict['groups'][0]['volumes'])
         else:
@@ -211,7 +212,7 @@ class GroupsAPITestCase(test.TestCase):
         # be contained in the response body.
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s?list_volume=True' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version='3.25')
+                                      version=mv.GROUP_VOLUME_LIST)
         res_dict = self.controller.show(req, self.group1.id)
         self.assertEqual(1, len(res_dict))
         self.assertEqual([fake.VOLUME_ID],
@@ -221,16 +222,17 @@ class GroupsAPITestCase(test.TestCase):
         # should not be contained in the response body.
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version='3.25')
+                                      version=mv.GROUP_VOLUME_LIST)
         res_dict = self.controller.show(req, self.group1.id)
         self.assertEqual(1, len(res_dict))
         self.assertIsNone(res_dict['group'].get('volumes', None))
 
         # If the microversion < 3.25, "volumes" should not be contained in the
         # response body.
-        req = fakes.HTTPRequest.blank('/v3/%s/groups/%s?list_volume=True' %
+        req = fakes.HTTPRequest.blank(
-                                      (fake.PROJECT_ID, self.group1.id),
+            '/v3/%s/groups/%s?list_volume=True' %
-                                      version='3.24')
+            (fake.PROJECT_ID, self.group1.id),
+            version=mv.get_prior_version(mv.GROUP_VOLUME_LIST))
         res_dict = self.controller.show(req, self.group1.id)
         self.assertEqual(1, len(res_dict))
         self.assertIsNone(res_dict['group'].get('volumes', None))
@@ -239,11 +241,12 @@ class GroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s' %
                                       (fake.PROJECT_ID,
                                        fake.WILL_NOT_BE_FOUND_ID),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         self.assertRaises(exception.GroupNotFound, self.controller.show,
                           req, fake.WILL_NOT_BE_FOUND_ID)
 
-    @ddt.data('3.30', '3.31', '3.34')
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER),
+              mv.RESOURCE_FILTER, mv.LIKE_FILTER)
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_group_list_with_general_filter(self, version, mock_update):
         url = '/v3/%s/groups' % fake.PROJECT_ID
@@ -252,8 +255,8 @@ class GroupsAPITestCase(test.TestCase):
                                       use_admin_context=False)
         self.controller.index(req)
 
-        if version != '3.30':
+        if version != mv.get_prior_version(mv.RESOURCE_FILTER):
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'group',
                                                 support_like)
@@ -273,7 +276,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group3.save()
 
         req = fakes.HTTPRequest.blank('/v3/%s/groups' % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         res_dict = self.controller.index(req)
 
         self.assertEqual(1, len(res_dict))
@@ -295,7 +298,7 @@ class GroupsAPITestCase(test.TestCase):
         url = '/v3/%s/groups?limit=1' % fake.PROJECT_ID
         if is_detail:
             url = '/v3/%s/groups/detail?limit=1' % fake.PROJECT_ID
-        req = fakes.HTTPRequest.blank(url, version=GROUP_MICRO_VERSION)
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_VOLUME)
 
         if is_detail:
             res_dict = self.controller.detail(req)
@@ -320,7 +323,7 @@ class GroupsAPITestCase(test.TestCase):
         url = '/v3/%s/groups?offset=1' % fake.PROJECT_ID
         if is_detail:
             url = '/v3/%s/groups/detail?offset=1' % fake.PROJECT_ID
-        req = fakes.HTTPRequest.blank(url, version=GROUP_MICRO_VERSION)
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_VOLUME)
         res_dict = self.controller.index(req)
 
         self.assertEqual(1, len(res_dict))
@@ -337,7 +340,7 @@ class GroupsAPITestCase(test.TestCase):
         if is_detail:
             url = ('/v3/%s/groups/detail?offset=234523423455454' %
                    fake.PROJECT_ID)
-        req = fakes.HTTPRequest.blank(url, version=GROUP_MICRO_VERSION)
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_VOLUME)
         if is_detail:
             self.assertRaises(webob.exc.HTTPBadRequest, self.controller.detail,
                               req)
@@ -351,7 +354,7 @@ class GroupsAPITestCase(test.TestCase):
         if is_detail:
             url = ('/v3/%s/groups/detail?limit=2&offset=1' %
                    fake.PROJECT_ID)
-        req = fakes.HTTPRequest.blank(url, version=GROUP_MICRO_VERSION)
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_VOLUME)
 
         if is_detail:
             res_dict = self.controller.detail(req)
@@ -377,7 +380,7 @@ class GroupsAPITestCase(test.TestCase):
             url = ('/v3/%s/groups/detail?'
                    'all_tenants=True&id=%s') % (fake.PROJECT_ID,
                                                 self.group3.id)
-        req = fakes.HTTPRequest.blank(url, version=GROUP_MICRO_VERSION,
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_VOLUME,
                                       use_admin_context=True)
 
         if is_detail:
@@ -398,7 +401,7 @@ class GroupsAPITestCase(test.TestCase):
         if is_detail:
             url = ('/v3/%s/groups/detail?sort=id:asc' %
                    fake.PROJECT_ID)
-        req = fakes.HTTPRequest.blank(url, version=GROUP_MICRO_VERSION)
+        req = fakes.HTTPRequest.blank(url, version=mv.GROUP_VOLUME)
         expect_result = [self.group1.id, self.group2.id,
                          self.group3.id]
         expect_result.sort()
@@ -438,7 +441,7 @@ class GroupsAPITestCase(test.TestCase):
         # self.group3.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/detail' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         res_dict = self.controller.detail(req)
 
         self.assertEqual(1, len(res_dict))
@@ -476,7 +479,7 @@ class GroupsAPITestCase(test.TestCase):
                           "description":
                           "Group 1", }}
         req = fakes.HTTPRequest.blank('/v3/%s/groups' % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         res_dict = self.controller.create(req, body)
 
         self.assertEqual(1, len(res_dict))
@@ -489,7 +492,7 @@ class GroupsAPITestCase(test.TestCase):
     def test_create_group_with_no_body(self):
         # omit body from the request
         req = fakes.HTTPRequest.blank('/v3/%s/groups' % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, None)
 
@@ -498,7 +501,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": False}}
         res_dict = self.controller.delete_group(
             req, self.group1.id, body)
@@ -513,7 +516,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": False}}
         res_dict = self.controller.delete_group(
             req, self.group1.id, body)
@@ -528,7 +531,7 @@ class GroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID,
                                        fake.WILL_NOT_BE_FOUND_ID),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": False}}
         self.assertRaises(exception.GroupNotFound,
                           self.controller.delete_group,
@@ -538,7 +541,7 @@ class GroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID,
                                        self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": False}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -548,7 +551,7 @@ class GroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID,
                                        self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         res_dict = self.controller.delete_group(
             req, self.group1.id, body)
@@ -565,7 +568,7 @@ class GroupsAPITestCase(test.TestCase):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID,
                                        self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         res_dict = self.controller.delete_group(
             req, self.group1.id, body)
@@ -620,7 +623,7 @@ class GroupsAPITestCase(test.TestCase):
                           "description":
                           "Group 1", }}
         req = fakes.HTTPRequest.blank('/v3/%s/groups' % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         ex = self.assertRaises(exception.GroupLimitExceeded,
                                self.controller.create,
                                req, body)
@@ -631,7 +634,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"invalid_request_element": {"delete-volumes": False}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -642,7 +645,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": "abcd"}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -653,7 +656,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": ""}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -666,7 +669,7 @@ class GroupsAPITestCase(test.TestCase):
 
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -688,7 +691,7 @@ class GroupsAPITestCase(test.TestCase):
         vol = utils.create_volume(self.ctxt, group_id=self.group1.id)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         res_dict = self.controller.delete_group(
             req, self.group1.id, body)
@@ -707,7 +710,7 @@ class GroupsAPITestCase(test.TestCase):
                                   attach_status='attached')
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -722,7 +725,7 @@ class GroupsAPITestCase(test.TestCase):
         utils.create_snapshot(self.ctxt, vol.id)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.delete_group,
@@ -739,7 +742,7 @@ class GroupsAPITestCase(test.TestCase):
                               deleted=True)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"delete": {"delete-volumes": True}}
         res_dict = self.controller.delete_group(
             req, self.group1.id, body)
@@ -758,7 +761,7 @@ class GroupsAPITestCase(test.TestCase):
                           "description":
                           "Group 1", }}
         req = fakes.HTTPRequest.blank('/v3/%s/groups' % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.create,
                           req, body)
@@ -770,7 +773,7 @@ class GroupsAPITestCase(test.TestCase):
                           "description":
                           "Group 1", }}
         req = fakes.HTTPRequest.blank('/v3/%s/groups' % fake.PROJECT_ID,
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         self.assertRaises(webob.exc.HTTPBadRequest,
                           self.controller.create,
                           req, body)
@@ -820,7 +823,7 @@ class GroupsAPITestCase(test.TestCase):
             volume_type_id=volume_type_id)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         name = 'newgroup'
         description = 'New Group Description'
         add_volumes = add_volume.id + "," + add_volume2.id
@@ -851,7 +854,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.status = status
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"group": {"name": "new name",
                           "description": "new description",
                           "add_volumes": None,
@@ -870,7 +873,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"group": {"name": None,
                           "description": None,
                           "add_volumes": "fake-volume-uuid",
@@ -885,7 +888,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"group": {"name": None,
                           "description": "new description",
                           "add_volumes": None,
@@ -900,7 +903,7 @@ class GroupsAPITestCase(test.TestCase):
         self.group1.save()
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         body = {"group": {"name": None,
                           "description": None,
                           "add_volumes": None,
@@ -919,7 +922,7 @@ class GroupsAPITestCase(test.TestCase):
             status='wrong_status')
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         add_volumes = add_volume.id
         body = {"group": {"name": "group1",
                           "description": "",
@@ -941,7 +944,7 @@ class GroupsAPITestCase(test.TestCase):
             volume_type_id=wrong_type)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         add_volumes = add_volume.id
         body = {"group": {"name": "group1",
                           "description": "",
@@ -962,7 +965,7 @@ class GroupsAPITestCase(test.TestCase):
             group_id=fake.GROUP2_ID)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
         add_volumes = add_volume.id
         body = {"group": {"name": "group1",
                           "description": "",
@@ -984,7 +987,7 @@ class GroupsAPITestCase(test.TestCase):
             host=self.group1.host)
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/update' %
                                       (fake.PROJECT_ID, self.group1.id),
-                                      version=GROUP_MICRO_VERSION)
+                                      version=mv.GROUP_VOLUME)
 
         body = {"group": {"name": "new name",
                           "description": None,
@@ -999,16 +1002,16 @@ class GroupsAPITestCase(test.TestCase):
         self.assertEqual(add_volume.status, vol.status)
         add_volume.destroy()
 
-    @ddt.data(('3.11', 'fake_group_001',
+    @ddt.data((mv.GROUP_TYPE, 'fake_group_001',
                fields.GroupStatus.AVAILABLE,
                exception.VersionNotFoundForAPIMethod),
-              ('3.19', 'fake_group_001',
+              (mv.GROUP_SNAPSHOT_RESET_STATUS, 'fake_group_001',
                fields.GroupStatus.AVAILABLE,
                exception.VersionNotFoundForAPIMethod),
-              ('3.20', 'fake_group_001',
+              (mv.GROUP_VOLUME_RESET_STATUS, 'fake_group_001',
                fields.GroupStatus.AVAILABLE,
                exception.GroupNotFound),
-              ('3.20', None,
+              (mv.GROUP_VOLUME_RESET_STATUS, None,
                'invalid_test_status',
                webob.exc.HTTPBadRequest),
               )
@@ -1029,7 +1032,7 @@ class GroupsAPITestCase(test.TestCase):
     def test_reset_group_status(self):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group2.id),
-                                      version='3.20')
+                                      version=mv.GROUP_VOLUME_RESET_STATUS)
         body = {"reset_status": {
             "status": fields.GroupStatus.AVAILABLE
         }}
@@ -1068,7 +1071,7 @@ class GroupsAPITestCase(test.TestCase):
                                     "group_snapshot_id": group_snapshot.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/groups/action' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_FROM_SRC_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         res_dict = self.controller.create_from_src(req, body)
 
         self.assertIn('id', res_dict['group'])
@@ -1101,7 +1104,7 @@ class GroupsAPITestCase(test.TestCase):
                                     "source_group_id": source_grp.id}}
         req = fakes.HTTPRequest.blank('/v3/%s/groups/action' %
                                       fake.PROJECT_ID,
-                                      version=GROUP_FROM_SRC_MICRO_VERSION)
+                                      version=mv.GROUP_SNAPSHOTS)
         res_dict = self.controller.create_from_src(req, body)
 
         self.assertIn('id', res_dict['group'])
@@ -1120,7 +1123,7 @@ class GroupsAPITestCase(test.TestCase):
     def test_enable_replication(self, mock_rep_grp_type, mock_rep_vol_type):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group3.id),
-                                      version=GROUP_REPLICATION_MICRO_VERSION)
+                                      version=mv.GROUP_REPLICATION)
         self.group3.status = fields.GroupStatus.AVAILABLE
         self.group3.save()
         body = {"enable_replication": {}}
@@ -1145,7 +1148,7 @@ class GroupsAPITestCase(test.TestCase):
         mock_rep_vol_type.return_value = is_vol_rep_type
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group3.id),
-                                      version=GROUP_REPLICATION_MICRO_VERSION)
+                                      version=mv.GROUP_REPLICATION)
         self.group3.status = fields.GroupStatus.AVAILABLE
         self.group3.save()
         body = {"enable_replication": {}}
@@ -1161,7 +1164,7 @@ class GroupsAPITestCase(test.TestCase):
                                                  mock_rep_vol_type):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group3.id),
-                                      version=GROUP_REPLICATION_MICRO_VERSION)
+                                      version=mv.GROUP_REPLICATION)
         self.group3.status = fields.GroupStatus.AVAILABLE
         self.group3.save()
         body = {"enable_replication": {}}
@@ -1173,13 +1176,13 @@ class GroupsAPITestCase(test.TestCase):
                 return_value=True)
     @mock.patch('cinder.volume.utils.is_group_a_type',
                 return_value=True)
-    @ddt.data((GROUP_REPLICATION_MICRO_VERSION, True,
+    @ddt.data((mv.GROUP_REPLICATION, True,
                fields.GroupStatus.CREATING,
                webob.exc.HTTPBadRequest),
-              (GROUP_REPLICATION_MICRO_VERSION, False,
+              (mv.GROUP_REPLICATION, False,
                fields.GroupStatus.AVAILABLE,
                exception.GroupNotFound),
-              (INVALID_GROUP_REPLICATION_MICRO_VERSION, True,
+              (INVALID_GROUP_REPLICATION, True,
                fields.GroupStatus.AVAILABLE,
                exception.VersionNotFoundForAPIMethod),
               )
@@ -1209,7 +1212,7 @@ class GroupsAPITestCase(test.TestCase):
     def test_disable_replication(self, mock_rep_grp_type, mock_rep_vol_type):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group3.id),
-                                      version=GROUP_REPLICATION_MICRO_VERSION)
+                                      version=mv.GROUP_REPLICATION)
         self.group3.status = fields.GroupStatus.AVAILABLE
         self.group3.replication_status = fields.ReplicationStatus.ENABLED
         self.group3.save()
@@ -1227,19 +1230,19 @@ class GroupsAPITestCase(test.TestCase):
                 return_value=True)
     @mock.patch('cinder.volume.utils.is_group_a_type',
                 return_value=True)
-    @ddt.data((GROUP_REPLICATION_MICRO_VERSION, True,
+    @ddt.data((mv.GROUP_REPLICATION, True,
                fields.GroupStatus.CREATING,
                fields.ReplicationStatus.ENABLED,
                webob.exc.HTTPBadRequest),
-              (GROUP_REPLICATION_MICRO_VERSION, True,
+              (mv.GROUP_REPLICATION, True,
                fields.GroupStatus.AVAILABLE,
                fields.ReplicationStatus.DISABLED,
                webob.exc.HTTPBadRequest),
-              (GROUP_REPLICATION_MICRO_VERSION, False,
+              (mv.GROUP_REPLICATION, False,
                fields.GroupStatus.AVAILABLE,
                fields.ReplicationStatus.DISABLED,
                exception.GroupNotFound),
-              (INVALID_GROUP_REPLICATION_MICRO_VERSION, True,
+              (INVALID_GROUP_REPLICATION, True,
                fields.GroupStatus.AVAILABLE,
                fields.ReplicationStatus.ENABLED,
                exception.VersionNotFoundForAPIMethod),
@@ -1272,7 +1275,7 @@ class GroupsAPITestCase(test.TestCase):
     def test_failover_replication(self, mock_rep_grp_type, mock_rep_vol_type):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group3.id),
-                                      version=GROUP_REPLICATION_MICRO_VERSION)
+                                      version=mv.GROUP_REPLICATION)
         self.group3.status = fields.GroupStatus.AVAILABLE
         self.group3.replication_status = fields.ReplicationStatus.ENABLED
         self.group3.save()
@@ -1290,19 +1293,19 @@ class GroupsAPITestCase(test.TestCase):
                 return_value=True)
     @mock.patch('cinder.volume.utils.is_group_a_type',
                 return_value=True)
-    @ddt.data((GROUP_REPLICATION_MICRO_VERSION, True,
+    @ddt.data((mv.GROUP_REPLICATION, True,
                fields.GroupStatus.CREATING,
                fields.ReplicationStatus.ENABLED,
                webob.exc.HTTPBadRequest),
-              (GROUP_REPLICATION_MICRO_VERSION, True,
+              (mv.GROUP_REPLICATION, True,
                fields.GroupStatus.AVAILABLE,
                fields.ReplicationStatus.DISABLED,
                webob.exc.HTTPBadRequest),
-              (GROUP_REPLICATION_MICRO_VERSION, False,
+              (mv.GROUP_REPLICATION, False,
                fields.GroupStatus.AVAILABLE,
                fields.ReplicationStatus.DISABLED,
                exception.GroupNotFound),
-              (INVALID_GROUP_REPLICATION_MICRO_VERSION, True,
+              (INVALID_GROUP_REPLICATION, True,
                fields.GroupStatus.AVAILABLE,
                fields.ReplicationStatus.ENABLED,
                exception.VersionNotFoundForAPIMethod),
@@ -1337,7 +1340,7 @@ class GroupsAPITestCase(test.TestCase):
                                       mock_rep_grp_type, mock_rep_vol_type):
         req = fakes.HTTPRequest.blank('/v3/%s/groups/%s/action' %
                                       (fake.PROJECT_ID, self.group3.id),
-                                      version=GROUP_REPLICATION_MICRO_VERSION)
+                                      version=mv.GROUP_REPLICATION)
         targets = {
             'replication_targets': [
                 {'backend_id': 'lvm_backend_1'}

cinder/tests/unit/api/v3/test_limits.py

@@ -16,12 +16,16 @@
 import ddt
 import mock
 
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder.api.v3 import limits
 from cinder import test
 from cinder.tests.unit.api import fakes
 from cinder.tests.unit import fake_constants as fake
 
+LIMITS_FILTER = mv.LIMITS_ADMIN_FILTER
+PRE_LIMITS_FILTER = mv.get_prior_version(LIMITS_FILTER)
+
 
 @ddt.ddt
 class LimitsControllerTest(test.TestCase):
@@ -29,7 +33,8 @@ class LimitsControllerTest(test.TestCase):
         super(LimitsControllerTest, self).setUp()
         self.controller = limits.LimitsController()
 
-    @ddt.data(('3.38', True), ('3.38', False), ('3.39', True), ('3.39', False))
+    @ddt.data((PRE_LIMITS_FILTER, True), (PRE_LIMITS_FILTER, False),
+              (LIMITS_FILTER, True), (LIMITS_FILTER, False))
     @mock.patch('cinder.quota.VolumeTypeQuotaEngine.get_project_quotas')
     def test_get_limit_with_project_id(self, ver_project, mock_get_quotas):
         max_ver, has_project = ver_project
@@ -48,9 +53,9 @@ class LimitsControllerTest(test.TestCase):
         mock_get_quotas.side_effect = get_project_quotas
 
         resp_dict = self.controller.index(req)
-        # if admin, only 3.39 and req contains project_id filter, cinder
+        # if admin, only LIMITS_FILTER and req contains project_id filter,
-        # returns the specified project's quota.
+        # cinder returns the specified project's quota.
-        if max_ver == '3.39' and has_project:
+        if max_ver == LIMITS_FILTER and has_project:
             self.assertEqual(
                 5, resp_dict['limits']['absolute']['maxTotalVolumeGigabytes'])
         else:

cinder/tests/unit/api/v3/test_messages.py

@@ -15,6 +15,7 @@ import mock
 from six.moves import http_client
 
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.v3 import messages
 from cinder import context
 from cinder import exception
@@ -66,8 +67,7 @@ class MessageApiTest(test.TestCase):
         self.mock_object(message_api.API, 'get', v3_fakes.fake_message_get)
 
         req = fakes.HTTPRequest.blank(
-            '/v3/messages/%s' % fakes.FAKE_UUID,
+            '/v3/messages/%s' % fakes.FAKE_UUID, version=mv.MESSAGES)
-            version=messages.MESSAGES_BASE_MICRO_VERSION)
         req.environ['cinder.context'] = self.ctxt
 
         res_dict = self.controller.show(req, fakes.FAKE_UUID)
@@ -81,8 +81,7 @@ class MessageApiTest(test.TestCase):
                              message_id=fakes.FAKE_UUID))
 
         req = fakes.HTTPRequest.blank(
-            '/v3/messages/%s' % fakes.FAKE_UUID,
+            '/v3/messages/%s' % fakes.FAKE_UUID, version=mv.MESSAGES)
-            version=messages.MESSAGES_BASE_MICRO_VERSION)
         req.environ['cinder.context'] = self.ctxt
 
         self.assertRaises(exception.MessageNotFound, self.controller.show,
@@ -92,7 +91,7 @@ class MessageApiTest(test.TestCase):
         self.mock_object(message_api.API, 'get', v3_fakes.fake_message_get)
 
         req = fakes.HTTPRequest.blank('/v3/messages/%s' % fakes.FAKE_UUID,
-                                      version='3.0')
+                                      version=mv.BASE_VERSION)
         req.environ['cinder.context'] = self.ctxt
 
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
@@ -103,8 +102,7 @@ class MessageApiTest(test.TestCase):
         self.mock_object(message_api.API, 'delete')
 
         req = fakes.HTTPRequest.blank(
-            '/v3/messages/%s' % fakes.FAKE_UUID,
+            '/v3/messages/%s' % fakes.FAKE_UUID, version=mv.MESSAGES)
-            version=messages.MESSAGES_BASE_MICRO_VERSION)
         req.environ['cinder.context'] = self.ctxt
 
         resp = self.controller.delete(req, fakes.FAKE_UUID)
@@ -118,13 +116,13 @@ class MessageApiTest(test.TestCase):
                              message_id=fakes.FAKE_UUID))
 
         req = fakes.HTTPRequest.blank(
-            '/v3/messages/%s' % fakes.FAKE_UUID,
+            '/v3/messages/%s' % fakes.FAKE_UUID, version=mv.MESSAGES)
-            version=messages.MESSAGES_BASE_MICRO_VERSION)
 
         self.assertRaises(exception.MessageNotFound, self.controller.delete,
                           req, fakes.FAKE_UUID)
 
-    @ddt.data('3.30', '3.31', '3.34')
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER),
+              mv.RESOURCE_FILTER, mv.LIKE_FILTER)
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_message_list_with_general_filter(self, version, mock_update):
         url = '/v3/%s/messages' % fakes.FAKE_UUID
@@ -133,8 +131,8 @@ class MessageApiTest(test.TestCase):
                                       use_admin_context=False)
         self.controller.index(req)
 
-        if version != '3.30':
+        if version != mv.get_prior_version(mv.RESOURCE_FILTER):
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'message',
                                                 support_like)
@@ -143,8 +141,7 @@ class MessageApiTest(test.TestCase):
         self.mock_object(message_api.API, 'get_all',
                          return_value=[v3_fakes.fake_message(fakes.FAKE_UUID)])
         req = fakes.HTTPRequest.blank(
-            '/v3/messages/%s' % fakes.FAKE_UUID,
+            '/v3/messages/%s' % fakes.FAKE_UUID, version=mv.MESSAGES)
-            version=messages.MESSAGES_BASE_MICRO_VERSION)
         req.environ['cinder.context'] = self.ctxt
 
         res_dict = self.controller.index(req)

cinder/tests/unit/api/v3/test_resource_filters.py

@@ -18,13 +18,12 @@ import ddt
 import mock
 import six
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import resource_filters as v3_filters
 from cinder import test
 from cinder.tests.unit.api import fakes
 from cinder.tests.unit import fake_constants as fake
 
-FILTERS_MICRO_VERSION = '3.33'
-
 
 @ddt.ddt
 class ResourceFiltersAPITestCase(test.TestCase):
@@ -53,7 +52,7 @@ class ResourceFiltersAPITestCase(test.TestCase):
         if resource is not None:
             request_url += '?resource=%s' % resource
         req = fakes.HTTPRequest.blank(request_url,
-                                      version=FILTERS_MICRO_VERSION)
+                                      version=mv.RESOURCE_FILTER_CONFIG)
 
         with mock.patch('cinder.api.common._FILTERS_COLLECTION', filters):
             result = self.controller.index(req)

cinder/tests/unit/api/v3/test_snapshot_manage.py

@@ -20,6 +20,7 @@ from six.moves import http_client
 from six.moves.urllib.parse import urlencode
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import router as router_v3
 from cinder import context
 from cinder import objects
@@ -51,13 +52,13 @@ class SnapshotManageTest(test.TestCase):
                                                   fake.PROJECT_ID,
                                                   True)
 
-    def _get_resp_post(self, body, version="3.8"):
+    def _get_resp_post(self, body, version=mv.MANAGE_EXISTING_LIST):
         """Helper to execute a POST manageable_snapshots API call."""
         req = webob.Request.blank('/v3/%s/manageable_snapshots' %
                                   fake.PROJECT_ID)
         req.method = 'POST'
+        req.headers = mv.get_mv_header(version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume ' + version
         req.environ['cinder.context'] = self._admin_ctxt
         req.body = jsonutils.dump_as_bytes(body)
         res = req.get_response(app())
@@ -84,10 +85,12 @@ class SnapshotManageTest(test.TestCase):
 
     def test_manage_snapshot_previous_version(self):
         body = {'snapshot': {'volume_id': fake.VOLUME_ID, 'ref': 'fake_ref'}}
-        res = self._get_resp_post(body, version="3.7")
+        res = self._get_resp_post(
+            body, version=mv.get_prior_version(mv.MANAGE_EXISTING_LIST))
         self.assertEqual(http_client.NOT_FOUND, res.status_int, res)
 
-    def _get_resp_get(self, host, detailed, paging, version="3.8", **kwargs):
+    def _get_resp_get(self, host, detailed, paging,
+                      version=mv.MANAGE_EXISTING_LIST, **kwargs):
         """Helper to execute a GET os-snapshot-manage API call."""
         params = {'host': host} if host else {}
         params.update(kwargs)
@@ -101,8 +104,8 @@ class SnapshotManageTest(test.TestCase):
         req = webob.Request.blank('/v3/%s/manageable_snapshots%s%s' %
                                   (fake.PROJECT_ID, detail, query_string))
         req.method = 'GET'
+        req.headers = mv.get_mv_header(version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume ' + version
         req.environ['cinder.context'] = self._admin_ctxt
         res = req.get_response(app())
         return res
@@ -120,7 +123,9 @@ class SnapshotManageTest(test.TestCase):
         self.assertEqual(http_client.OK, res.status_int)
 
     def test_get_manageable_snapshots_previous_version(self):
-        res = self._get_resp_get('fakehost', False, False, version="3.7")
+        res = self._get_resp_get(
+            'fakehost', False, False,
+            version=mv.get_prior_version(mv.MANAGE_EXISTING_LIST))
         self.assertEqual(http_client.NOT_FOUND, res.status_int)
 
     @mock.patch('cinder.volume.api.API.get_manageable_snapshots',
@@ -136,7 +141,9 @@ class SnapshotManageTest(test.TestCase):
         self.assertEqual(http_client.OK, res.status_int)
 
     def test_get_manageable_snapshots_detail_previous_version(self):
-        res = self._get_resp_get('fakehost', True, True, version="3.7")
+        res = self._get_resp_get(
+            'fakehost', True, True,
+            version=mv.get_prior_version(mv.MANAGE_EXISTING_LIST))
         self.assertEqual(http_client.NOT_FOUND, res.status_int)
 
     @ddt.data((True, True, 'detail_list'), (True, False, 'summary_list'),
@@ -150,12 +157,12 @@ class SnapshotManageTest(test.TestCase):
         if clustered:
             host = None
             cluster_name = 'mycluster'
-            version = '3.17'
+            version = mv.MANAGE_EXISTING_CLUSTER
             kwargs = {'cluster': cluster_name}
         else:
             host = 'fakehost'
             cluster_name = None
-            version = '3.8'
+            version = mv.MANAGE_EXISTING_LIST
             kwargs = {}
         service = objects.Service(disabled=False, host='fakehost',
                                   cluster_name=cluster_name)
@@ -183,12 +190,13 @@ class SnapshotManageTest(test.TestCase):
             mock.ANY, None, host=host, binary='cinder-volume',
             cluster_name=cluster_name)
 
-    @ddt.data('3.8', '3.17')
+    @ddt.data(mv.MANAGE_EXISTING_LIST, mv.MANAGE_EXISTING_CLUSTER)
     def test_get_manageable_missing_host(self, version):
         res = self._get_resp_get(None, True, False, version=version)
         self.assertEqual(http_client.BAD_REQUEST, res.status_int)
 
     def test_get_manageable_both_host_cluster(self):
-        res = self._get_resp_get('host', True, False, version='3.17',
+        res = self._get_resp_get('host', True, False,
+                                 version=mv.MANAGE_EXISTING_CLUSTER,
                                  cluster='cluster')
         self.assertEqual(http_client.BAD_REQUEST, res.status_int)

cinder/tests/unit/api/v3/test_snapshots.py

@@ -17,7 +17,7 @@ import ddt
 
 import mock
 
-from cinder.api.openstack import api_version_request as api_version
+from cinder.api import microversions as mv
 from cinder.api.v3 import snapshots
 from cinder import context
 from cinder import exception
@@ -54,9 +54,8 @@ def create_snapshot_query_with_metadata(metadata_query_string,
     """Helper to create metadata querystring with microversion"""
     req = fakes.HTTPRequest.blank('/v3/snapshots?metadata=' +
                                   metadata_query_string)
-    req.headers["OpenStack-API-Version"] = "volume " + api_microversion
+    req.headers = mv.get_mv_header(api_microversion)
-    req.api_version_request = api_version.APIVersionRequest(
+    req.api_version_request = mv.get_api_version(api_microversion)
-        api_microversion)
 
     return req
 
@@ -69,7 +68,9 @@ class SnapshotApiTest(test.TestCase):
         self.controller = snapshots.SnapshotsController()
         self.ctx = context.RequestContext(fake.USER_ID, fake.PROJECT_ID, True)
 
-    @ddt.data('3.14', '3.13', '3.41')
+    @ddt.data(mv.GROUP_SNAPSHOTS,
+              mv.get_prior_version(mv.GROUP_SNAPSHOTS),
+              mv.SNAPSHOT_LIST_USER_ID)
     @mock.patch('cinder.db.snapshot_metadata_get', return_value=dict())
     @mock.patch('cinder.objects.Volume.get_by_id')
     @mock.patch('cinder.objects.Snapshot.get_by_id')
@@ -91,20 +92,20 @@ class SnapshotApiTest(test.TestCase):
         snapshot_get_by_id.return_value = snapshot_obj
         volume_get_by_id.return_value = fake_volume_obj
         req = fakes.HTTPRequest.blank('/v3/snapshots/%s' % UUID)
-        req.api_version_request = api_version.APIVersionRequest(max_ver)
+        req.api_version_request = mv.get_api_version(max_ver)
         resp_dict = self.controller.show(req, UUID)
 
         self.assertIn('snapshot', resp_dict)
         self.assertEqual(UUID, resp_dict['snapshot']['id'])
         self.assertIn('updated_at', resp_dict['snapshot'])
-        if max_ver == '3.14':
+        if max_ver == mv.SNAPSHOT_LIST_USER_ID:
+            self.assertIn('user_id', resp_dict['snapshot'])
+        elif max_ver == mv.GROUP_SNAPSHOTS:
             self.assertIn('group_snapshot_id', resp_dict['snapshot'])
             self.assertNotIn('user_id', resp_dict['snapshot'])
-        elif max_ver == '3.13':
+        else:
             self.assertNotIn('group_snapshot_id', resp_dict['snapshot'])
             self.assertNotIn('user_id', resp_dict['snapshot'])
-        elif max_ver == '3.41':
-            self.assertIn('user_id', resp_dict['snapshot'])
 
     def test_snapshot_show_invalid_id(self):
         snapshot_id = INVALID_UUID
@@ -144,7 +145,7 @@ class SnapshotApiTest(test.TestCase):
         # Generic filtering is introduced since '3,31' and we add
         # 'availability_zone' support by using generic filtering.
         req = fakes.HTTPRequest.blank(url, use_admin_context=is_admin_user,
-                                      version='3.31')
+                                      version=mv.RESOURCE_FILTER)
         res_dict = self.controller.detail(req)
 
         self.assertEqual(1, len(res_dict['snapshots']))
@@ -154,12 +155,13 @@ class SnapshotApiTest(test.TestCase):
         self._create_snapshot(name='test1')
         self._create_snapshot(name='test2')
 
-        req = fakes.HTTPRequest.blank('/v3/snapshots?sort_key=name',
+        req = fakes.HTTPRequest.blank(
-                                      version='3.29')
+            '/v3/snapshots?sort_key=name',
+            version=mv.get_prior_version(mv.SNAPSHOT_SORT))
         self.assertRaises(exception.InvalidInput, self.controller.detail, req)
 
         req = fakes.HTTPRequest.blank('/v3/snapshots?sort_key=name',
-                                      version='3.30')
+                                      version=mv.SNAPSHOT_SORT)
         res_dict = self.controller.detail(req)
         self.assertEqual(2, len(res_dict['snapshots']))
         self.assertEqual('test2', res_dict['snapshots'][0]['name'])
@@ -171,7 +173,8 @@ class SnapshotApiTest(test.TestCase):
         self._create_snapshot(metadata=metadata)
 
         # Create request with metadata filter key1: value1
-        req = create_snapshot_query_with_metadata('{"key1":"val1"}', '3.22')
+        req = create_snapshot_query_with_metadata(
+            '{"key1":"val1"}', mv.SNAPSHOT_LIST_METADATA_FILTER)
 
         # query controller with above request
         res_dict = self.controller.detail(req)
@@ -184,7 +187,8 @@ class SnapshotApiTest(test.TestCase):
             'metadata'])
 
         # Create request with metadata filter key2: value2
-        req = create_snapshot_query_with_metadata('{"key2":"val2"}', '3.22')
+        req = create_snapshot_query_with_metadata(
+            '{"key2":"val2"}', mv.SNAPSHOT_LIST_METADATA_FILTER)
 
         # query controller with above request
         res_dict = self.controller.detail(req)
@@ -199,7 +203,8 @@ class SnapshotApiTest(test.TestCase):
 
         # Create request with metadata filter key1: value1, key11: value11
         req = create_snapshot_query_with_metadata(
-            '{"key1":"val1", "key11":"val11"}', '3.22')
+            '{"key1":"val1", "key11":"val11"}',
+            mv.SNAPSHOT_LIST_METADATA_FILTER)
 
         # query controller with above request
         res_dict = self.controller.detail(req)
@@ -212,7 +217,8 @@ class SnapshotApiTest(test.TestCase):
             'snapshots'][0]['metadata'])
 
         # Create request with metadata filter key1: value1
-        req = create_snapshot_query_with_metadata('{"key1":"val1"}', '3.22')
+        req = create_snapshot_query_with_metadata(
+            '{"key1":"val1"}', mv.SNAPSHOT_LIST_METADATA_FILTER)
 
         # query controller with above request
         res_dict = self.controller.detail(req)
@@ -224,7 +230,19 @@ class SnapshotApiTest(test.TestCase):
         self.assertDictEqual({"key1": "val1", "key11": "val11"}, res_dict[
             'snapshots'][0]['metadata'])
 
-    @ddt.data('3.30', '3.31', '3.34')
+        # Create request with metadata filter key2: value2
+        req = create_snapshot_query_with_metadata(
+            '{"key2":"val2"}', mv.SNAPSHOT_LIST_METADATA_FILTER)
+
+        # query controller with above request
+        res_dict = self.controller.detail(req)
+
+        # verify no snapshot is returned
+        self.assertEqual(0, len(res_dict['snapshots']))
+
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER),
+              mv.RESOURCE_FILTER,
+              mv.LIKE_FILTER)
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_snapshot_list_with_general_filter(self, version, mock_update):
         url = '/v3/%s/snapshots' % fake.PROJECT_ID
@@ -233,8 +251,8 @@ class SnapshotApiTest(test.TestCase):
                                       use_admin_context=False)
         self.controller.index(req)
 
-        if version != '3.30':
+        if version != mv.get_prior_version(mv.RESOURCE_FILTER):
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'snapshot',
                                                 support_like)
@@ -245,7 +263,9 @@ class SnapshotApiTest(test.TestCase):
         self._create_snapshot(metadata=metadata)
 
         # Create request with metadata filter key2: value2
-        req = create_snapshot_query_with_metadata('{"key2":"val2"}', '3.21')
+        req = create_snapshot_query_with_metadata(
+            '{"key2":"val2"}',
+            mv.get_prior_version(mv.SNAPSHOT_LIST_METADATA_FILTER))
 
         # query controller with above request
         res_dict = self.controller.detail(req)

cinder/tests/unit/api/v3/test_volume_manage.py

@@ -20,6 +20,7 @@ from six.moves import http_client
 from six.moves.urllib.parse import urlencode
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import router as router_v3
 from cinder import context
 from cinder import objects
@@ -56,13 +57,13 @@ class VolumeManageTest(test.TestCase):
                                                   fake.PROJECT_ID,
                                                   True)
 
-    def _get_resp_post(self, body, version="3.8"):
+    def _get_resp_post(self, body, version=mv.MANAGE_EXISTING_LIST):
         """Helper to execute a POST manageable_volumes API call."""
         req = webob.Request.blank('/v3/%s/manageable_volumes' %
                                   fake.PROJECT_ID)
         req.method = 'POST'
+        req.headers = mv.get_mv_header(version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume ' + version
         req.environ['cinder.context'] = self._admin_ctxt
         req.body = jsonutils.dump_as_bytes(body)
         res = req.get_response(app())
@@ -88,7 +89,8 @@ class VolumeManageTest(test.TestCase):
         res = self._get_resp_post(body)
         self.assertEqual(http_client.BAD_REQUEST, res.status_int, res)
 
-    def _get_resp_get(self, host, detailed, paging, version="3.8", **kwargs):
+    def _get_resp_get(self, host, detailed, paging,
+                      version=mv.MANAGE_EXISTING_LIST, **kwargs):
         """Helper to execute a GET os-volume-manage API call."""
         params = {'host': host} if host else {}
         params.update(kwargs)
@@ -103,8 +105,8 @@ class VolumeManageTest(test.TestCase):
         req = webob.Request.blank('/v3/%s/manageable_volumes%s%s' %
                                   (fake.PROJECT_ID, detail, query_string))
         req.method = 'GET'
+        req.headers = mv.get_mv_header(version)
         req.headers['Content-Type'] = 'application/json'
-        req.headers['OpenStack-API-Version'] = 'volume ' + version
         req.environ['cinder.context'] = self._admin_ctxt
         res = req.get_response(app())
         return res
@@ -122,7 +124,9 @@ class VolumeManageTest(test.TestCase):
         self.assertEqual(http_client.OK, res.status_int)
 
     def test_get_manageable_volumes_previous_version(self):
-        res = self._get_resp_get('fakehost', False, True, version="3.7")
+        res = self._get_resp_get(
+            'fakehost', False, True,
+            version=mv.get_prior_version(mv.MANAGE_EXISTING_LIST))
         self.assertEqual(http_client.NOT_FOUND, res.status_int)
 
     @mock.patch('cinder.volume.api.API.get_manageable_volumes',
@@ -138,7 +142,9 @@ class VolumeManageTest(test.TestCase):
         self.assertEqual(http_client.OK, res.status_int)
 
     def test_get_manageable_volumes_detail_previous_version(self):
-        res = self._get_resp_get('fakehost', True, False, version="3.7")
+        res = self._get_resp_get(
+            'fakehost', True, False,
+            version=mv.get_prior_version(mv.MANAGE_EXISTING_LIST))
         self.assertEqual(http_client.NOT_FOUND, res.status_int)
 
     @ddt.data((True, True, 'detail_list'), (True, False, 'summary_list'),
@@ -152,12 +158,12 @@ class VolumeManageTest(test.TestCase):
         if clustered:
             host = None
             cluster_name = 'mycluster'
-            version = '3.17'
+            version = mv.MANAGE_EXISTING_CLUSTER
             kwargs = {'cluster': cluster_name}
         else:
             host = 'fakehost'
             cluster_name = None
-            version = '3.8'
+            version = mv.MANAGE_EXISTING_LIST
             kwargs = {}
         service = objects.Service(disabled=False, host='fakehost',
                                   cluster_name=cluster_name)
@@ -185,12 +191,13 @@ class VolumeManageTest(test.TestCase):
             mock.ANY, None, host=host, binary='cinder-volume',
             cluster_name=cluster_name)
 
-    @ddt.data('3.8', '3.17')
+    @ddt.data(mv.MANAGE_EXISTING_LIST, mv.MANAGE_EXISTING_CLUSTER)
     def test_get_manageable_missing_host(self, version):
         res = self._get_resp_get(None, True, False, version=version)
         self.assertEqual(http_client.BAD_REQUEST, res.status_int)
 
     def test_get_manageable_both_host_cluster(self):
-        res = self._get_resp_get('host', True, False, version='3.17',
+        res = self._get_resp_get('host', True, False,
+                                 version=mv.MANAGE_EXISTING_CLUSTER,
                                  cluster='cluster')
         self.assertEqual(http_client.BAD_REQUEST, res.status_int)

cinder/tests/unit/api/v3/test_volume_metadata.py

@@ -18,6 +18,7 @@ from oslo_serialization import jsonutils
 import webob
 
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.v3 import volume_metadata
 from cinder.api.v3 import volumes
 from cinder import db
@@ -150,7 +151,7 @@ class VolumeMetaDataTest(test.TestCase):
         self.volume_controller.create(req, body)
 
     def test_index(self):
-        req = fakes.HTTPRequest.blank(self.url, version="3.15")
+        req = fakes.HTTPRequest.blank(self.url, version=mv.ETAGS)
         data = self.controller.index(req, self.req_id)
 
         expected = {
@@ -166,14 +167,14 @@ class VolumeMetaDataTest(test.TestCase):
     def test_index_nonexistent_volume(self):
         self.mock_object(db, 'volume_metadata_get',
                          return_volume_nonexistent)
-        req = fakes.HTTPRequest.blank(self.url, version="3.15")
+        req = fakes.HTTPRequest.blank(self.url, version=mv.ETAGS)
         self.assertRaises(exception.VolumeNotFound,
                           self.controller.index, req, self.url)
 
     def test_index_no_data(self):
         self.mock_object(db, 'volume_metadata_get',
                          return_empty_volume_metadata)
-        req = fakes.HTTPRequest.blank(self.url, version="3.15")
+        req = fakes.HTTPRequest.blank(self.url, version=mv.ETAGS)
         data = self.controller.index(req, self.req_id)
         expected = {'metadata': {}}
         result = jsonutils.loads(data.body)
@@ -182,7 +183,7 @@ class VolumeMetaDataTest(test.TestCase):
     def test_validate_etag_true(self):
         self.mock_object(db, 'volume_metadata_get',
                          return_value={'key1': 'vanue1', 'key2': 'value2'})
-        req = fakes.HTTPRequest.blank(self.url, version="3.15")
+        req = fakes.HTTPRequest.blank(self.url, version=mv.ETAGS)
         req.environ['cinder.context'] = mock.Mock()
         req.if_match.etags = ['d5103bf7b26ff0310200d110da3ed186']
         self.assertTrue(self.controller._validate_etag(req, self.req_id))
@@ -192,7 +193,7 @@ class VolumeMetaDataTest(test.TestCase):
         fake_volume = {'id': self.req_id, 'status': 'available'}
         fake_context = mock.Mock()
         metadata_update.side_effect = return_new_volume_metadata
-        req = fakes.HTTPRequest.blank(self.url, version="3.15")
+        req = fakes.HTTPRequest.blank(self.url, version=mv.ETAGS)
         req.method = 'PUT'
         req.content_type = "application/json"
         expected = {
@@ -217,7 +218,7 @@ class VolumeMetaDataTest(test.TestCase):
         fake_volume = {'id': self.req_id, 'status': 'available'}
         fake_context = mock.Mock()
         metadata_update.side_effect = return_create_volume_metadata
-        req = fakes.HTTPRequest.blank(self.url + '/key1', version="3.15")
+        req = fakes.HTTPRequest.blank(self.url + '/key1', version=mv.ETAGS)
         req.method = 'PUT'
         body = {"meta": {"key1": "value1"}}
         req.body = jsonutils.dump_as_bytes(body)
@@ -235,7 +236,7 @@ class VolumeMetaDataTest(test.TestCase):
     def test_create_metadata_keys_value_none(self):
         self.mock_object(db, 'volume_metadata_update',
                          return_create_volume_metadata)
-        req = fakes.HTTPRequest.blank(self.url, version="3.15")
+        req = fakes.HTTPRequest.blank(self.url, version=mv.ETAGS)
         req.method = 'POST'
         req.headers["content-type"] = "application/json"
         body = {"meta": {"key": None}}
@@ -245,7 +246,7 @@ class VolumeMetaDataTest(test.TestCase):
     def test_update_items_value_none(self):
         self.mock_object(db, 'volume_metadata_update',
                          return_create_volume_metadata)
-        req = fakes.HTTPRequest.blank(self.url + '/key1', version="3.15")
+        req = fakes.HTTPRequest.blank(self.url + '/key1', version=mv.ETAGS)
         req.method = 'PUT'
         body = {"metadata": {"key": None}}
         req.body = jsonutils.dump_as_bytes(body)

cinder/tests/unit/api/v3/test_volumes.py

@@ -19,7 +19,7 @@ import mock
 import webob
 
 from cinder.api import extensions
-from cinder.api.openstack import api_version_request as api_version
+from cinder.api import microversions as mv
 from cinder.api.v2.views.volumes import ViewBuilder
 from cinder.api.v3 import volumes
 from cinder import context
@@ -38,10 +38,7 @@ from cinder import utils
 from cinder.volume import api as volume_api
 from cinder.volume import api as vol_get
 
-version_header_name = 'OpenStack-API-Version'
-
 DEFAULT_AZ = "zone1:host1"
-REVERT_TO_SNAPSHOT_VERSION = '3.40'
 
 
 @ddt.ddt
@@ -61,7 +58,7 @@ class VolumeApiTest(test.TestCase):
             req = fakes.HTTPRequest.blank('/v3/volumes?bootable=True')
             req.method = 'GET'
             req.content_type = 'application/json'
-            req.headers = {version_header_name: 'volume 3.0'}
+            req.headers = mv.get_mv_header(mv.BASE_VERSION)
             req.environ['cinder.context'].is_admin = True
 
             self.override_config('query_volume_filters', 'bootable')
@@ -77,9 +74,10 @@ class VolumeApiTest(test.TestCase):
             req = fakes.HTTPRequest.blank('/v3/volumes?bootable=True')
             req.method = 'GET'
             req.content_type = 'application/json'
-            req.headers = {version_header_name: 'volume 3.2'}
+            req.headers = mv.get_mv_header(mv.VOLUME_LIST_BOOTABLE)
             req.environ['cinder.context'].is_admin = True
-            req.api_version_request = api_version.APIVersionRequest('3.29')
+            req.api_version_request = mv.get_api_version(
+                mv.VOLUME_LIST_BOOTABLE)
 
             self.override_config('query_volume_filters', 'bootable')
             self.controller.index(req)
@@ -119,8 +117,9 @@ class VolumeApiTest(test.TestCase):
         vols = self._create_volume_with_glance_metadata()
         req = fakes.HTTPRequest.blank("/v3/volumes?glance_metadata="
                                       "{'image_name': 'imageTestOne'}")
-        req.headers["OpenStack-API-Version"] = "volume 3.4"
+        req.headers = mv.get_mv_header(mv.VOLUME_LIST_GLANCE_METADATA)
-        req.api_version_request = api_version.APIVersionRequest('3.4')
+        req.api_version_request = mv.get_api_version(
+            mv.VOLUME_LIST_GLANCE_METADATA)
         req.environ['cinder.context'] = self.ctxt
         res_dict = self.controller.index(req)
         volumes = res_dict['volumes']
@@ -131,8 +130,8 @@ class VolumeApiTest(test.TestCase):
         self._create_volume_with_glance_metadata()
         req = fakes.HTTPRequest.blank("/v3/volumes?glance_metadata="
                                       "{'image_name': 'imageTestOne'}")
-        req.headers["OpenStack-API-Version"] = "volume 3.0"
+        req.headers = mv.get_mv_header(mv.BASE_VERSION)
-        req.api_version_request = api_version.APIVersionRequest('3.0')
+        req.api_version_request = mv.get_api_version(mv.BASE_VERSION)
         req.environ['cinder.context'] = self.ctxt
         res_dict = self.controller.index(req)
         volumes = res_dict['volumes']
@@ -142,8 +141,8 @@ class VolumeApiTest(test.TestCase):
         vols = self._create_volume_with_group()
         req = fakes.HTTPRequest.blank(("/v3/volumes?group_id=%s") %
                                       fake.GROUP_ID)
-        req.headers["OpenStack-API-Version"] = "volume 3.10"
+        req.headers = mv.get_mv_header(mv.VOLUME_LIST_GROUP)
-        req.api_version_request = api_version.APIVersionRequest('3.10')
+        req.api_version_request = mv.get_api_version(mv.VOLUME_LIST_GROUP)
         req.environ['cinder.context'] = self.ctxt
         res_dict = self.controller.index(req)
         volumes = res_dict['volumes']
@@ -154,26 +153,29 @@ class VolumeApiTest(test.TestCase):
         self._create_volume_with_group()
         req = fakes.HTTPRequest.blank(("/v3/volumes?group_id=%s") %
                                       fake.GROUP_ID)
-        req.headers["OpenStack-API-Version"] = "volume 3.9"
+        req.headers = mv.get_mv_header(mv.BACKUP_UPDATE)
-        req.api_version_request = api_version.APIVersionRequest('3.9')
+        req.api_version_request = mv.get_api_version(mv.BACKUP_UPDATE)
         req.environ['cinder.context'] = self.ctxt
         res_dict = self.controller.index(req)
         volumes = res_dict['volumes']
         self.assertEqual(2, len(volumes))
 
-    def _fake_volumes_summary_request(self, version='3.12', all_tenant=False,
+    def _fake_volumes_summary_request(self,
+                                      version=mv.VOLUME_SUMMARY,
+                                      all_tenant=False,
                                       is_admin=False):
         req_url = '/v3/volumes/summary'
         if all_tenant:
             req_url += '?all_tenants=True'
         req = fakes.HTTPRequest.blank(req_url, use_admin_context=is_admin)
-        req.headers = {'OpenStack-API-Version': 'volume ' + version}
+        req.headers = mv.get_mv_header(version)
-        req.api_version_request = api_version.APIVersionRequest(version)
+        req.api_version_request = mv.get_api_version(version)
         return req
 
     def test_volumes_summary_in_unsupport_version(self):
         """Function call to test summary volumes API in unsupported version"""
-        req = self._fake_volumes_summary_request(version='3.7')
+        req = self._fake_volumes_summary_request(
+            version=mv.get_prior_version(mv.VOLUME_SUMMARY))
         self.assertRaises(exception.VersionNotFoundForAPIMethod,
                           self.controller.summary, req)
 
@@ -196,11 +198,12 @@ class VolumeApiTest(test.TestCase):
         self.assertEqual(expected, res_dict)
 
     @ddt.data(
-        ('3.35', {'volume-summary': {'total_size': 0.0,
+        (mv.get_prior_version(mv.VOLUME_SUMMARY_METADATA),
-                                     'total_count': 0}}),
+         {'volume-summary': {'total_size': 0.0,
-        ('3.36', {'volume-summary': {'total_size': 0.0,
+                             'total_count': 0}}),
-                                     'total_count': 0,
+        (mv.VOLUME_SUMMARY_METADATA, {'volume-summary': {'total_size': 0.0,
-                                     'metadata': {}}}))
+                                                         'total_count': 0,
+                                                         'metadata': {}}}))
     @ddt.unpack
     def test_volume_summary_empty(self, summary_api_version, expect_result):
         req = self._fake_volumes_summary_request(version=summary_api_version)
@@ -208,13 +211,15 @@ class VolumeApiTest(test.TestCase):
         self.assertEqual(expect_result, res_dict)
 
     @ddt.data(
-        ('3.35', {'volume-summary': {'total_size': 2,
+        (mv.get_prior_version(mv.VOLUME_SUMMARY_METADATA),
-                                     'total_count': 2}}),
+         {'volume-summary': {'total_size': 2,
-        ('3.36', {'volume-summary': {'total_size': 2,
+                             'total_count': 2}}),
-                                     'total_count': 2,
+        (mv.VOLUME_SUMMARY_METADATA,
-                                     'metadata': {
+         {'volume-summary': {'total_size': 2,
-                                         'name': ['test_name1', 'test_name2'],
+                             'total_count': 2,
-                                         'age': ['test_age']}}}))
+                             'metadata': {
+                                 'name': ['test_name1', 'test_name2'],
+                                 'age': ['test_age']}}}))
     @ddt.unpack
     def test_volume_summary_return_metadata(self, summary_api_version,
                                             expect_result):
@@ -230,13 +235,15 @@ class VolumeApiTest(test.TestCase):
         self.assertEqual(expect_result, res_dict)
 
     @ddt.data(
-        ('3.35', {'volume-summary': {'total_size': 2,
+        (mv.get_prior_version(mv.VOLUME_SUMMARY_METADATA),
-                                     'total_count': 2}}),
+            {'volume-summary': {'total_size': 2,
-        ('3.36', {'volume-summary': {'total_size': 2,
+                                'total_count': 2}}),
-                                     'total_count': 2,
+        (mv.VOLUME_SUMMARY_METADATA,
-                                     'metadata': {
+            {'volume-summary': {'total_size': 2,
-                                         'name': ['test_name1', 'test_name2'],
+                                'total_count': 2,
-                                         'age': ['test_age']}}}))
+                                'metadata': {
+                                    'name': ['test_name1', 'test_name2'],
+                                    'age': ['test_age']}}}))
     @ddt.unpack
     def test_volume_summary_return_metadata_all_tenant(
             self, summary_api_version, expect_result):
@@ -334,8 +341,9 @@ class VolumeApiTest(test.TestCase):
         if with_migration_status:
             volume['volume']['migration_status'] = None
 
-        # Remove group_id if max version is less than 3.13.
+        # Remove group_id if max version is less than GROUP_VOLUME.
-        if req_version and req_version.matches(None, "3.12"):
+        if req_version and req_version.matches(
+                None, mv.get_prior_version(mv.GROUP_VOLUME)):
             volume['volume'].pop('group_id')
 
         return volume
@@ -356,13 +364,14 @@ class VolumeApiTest(test.TestCase):
             'group': test_group,
         }
 
-        # Remove group_id if max version is less than 3.13.
+        # Remove group_id if max version is less than GROUP_VOLUME.
-        if req_version and req_version.matches(None, "3.12"):
+        if req_version and req_version.matches(
+                None, mv.get_prior_version(mv.GROUP_VOLUME)):
             volume.pop('group')
 
         return volume
 
-    @ddt.data('3.13', '3.12')
+    @ddt.data(mv.GROUP_VOLUME, mv.get_prior_version(mv.GROUP_VOLUME))
     @mock.patch(
         'cinder.api.openstack.wsgi.Controller.validate_name_and_description')
     def test_volume_create(self, max_ver, mock_validate):
@@ -375,14 +384,14 @@ class VolumeApiTest(test.TestCase):
         vol = self._vol_in_request_body()
         body = {"volume": vol}
         req = fakes.HTTPRequest.blank('/v3/volumes')
-        req.api_version_request = api_version.APIVersionRequest(max_ver)
+        req.api_version_request = mv.get_api_version(max_ver)
         res_dict = self.controller.create(req, body)
         ex = self._expected_vol_from_controller(
             req_version=req.api_version_request)
         self.assertEqual(ex, res_dict)
         self.assertTrue(mock_validate.called)
 
-    @ddt.data('3.14', '3.13')
+    @ddt.data(mv.GROUP_SNAPSHOTS, mv.get_prior_version(mv.GROUP_SNAPSHOTS))
     @mock.patch.object(group_api.API, 'get')
     @mock.patch.object(db.sqlalchemy.api, '_volume_type_get_full',
                        autospec=True)
@@ -405,7 +414,7 @@ class VolumeApiTest(test.TestCase):
                                         group_id=fake.GROUP_ID)
         body = {"volume": vol}
         req = fakes.HTTPRequest.blank('/v3/volumes')
-        req.api_version_request = api_version.APIVersionRequest(max_ver)
+        req.api_version_request = mv.get_api_version(max_ver)
         res_dict = self.controller.create(req, body)
         ex = self._expected_vol_from_controller(
             snapshot_id=snapshot_id,
@@ -450,23 +459,26 @@ class VolumeApiTest(test.TestCase):
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.create,
                           req, body)
 
-    @ddt.data('3.30', '3.31', '3.34')
+    @ddt.data(mv.get_prior_version(mv.RESOURCE_FILTER), mv.RESOURCE_FILTER,
+              mv.LIKE_FILTER)
     @mock.patch.object(volume_api.API, 'check_volume_filters', mock.Mock())
     @mock.patch.object(utils, 'add_visible_admin_metadata', mock.Mock())
     @mock.patch('cinder.api.common.reject_invalid_filters')
     def test_list_volume_with_general_filter(self, version, mock_update):
         req = fakes.HTTPRequest.blank('/v3/volumes', version=version)
         self.controller.index(req)
-        if version != '3.30':
+        if version >= mv.RESOURCE_FILTER:
-            support_like = True if version == '3.34' else False
+            support_like = True if version == mv.LIKE_FILTER else False
             mock_update.assert_called_once_with(req.environ['cinder.context'],
                                                 mock.ANY, 'volume',
                                                 support_like)
 
-    @ddt.data({'admin': True, 'version': '3.21'},
+    @ddt.data({'admin': True, 'version': mv.VOLUME_DETAIL_PROVIDER_ID},
-              {'admin': False, 'version': '3.21'},
+              {'admin': False, 'version': mv.VOLUME_DETAIL_PROVIDER_ID},
-              {'admin': True, 'version': '3.20'},
+              {'admin': True,
-              {'admin': False, 'version': '3.20'})
+               'version': mv.get_prior_version(mv.VOLUME_DETAIL_PROVIDER_ID)},
+              {'admin': False,
+               'version': mv.get_prior_version(mv.VOLUME_DETAIL_PROVIDER_ID)})
     @ddt.unpack
     def test_volume_show_provider_id(self, admin, version):
         self.mock_object(volume_api.API, 'get', v2_fakes.fake_volume_api_get)
@@ -482,8 +494,8 @@ class VolumeApiTest(test.TestCase):
         res_dict = self.controller.show(req, fake.VOLUME_ID)
         req_version = req.api_version_request
         # provider_id is in view if min version is greater than or equal to
-        # 3.21 for admin.
+        # VOLUME_DETAIL_PROVIDER_ID for admin.
-        if req_version.matches("3.21", None) and admin:
+        if req_version.matches(mv.VOLUME_DETAIL_PROVIDER_ID, None) and admin:
             self.assertIn('provider_id', res_dict['volume'])
         else:
             self.assertNotIn('provider_id', res_dict['volume'])
@@ -516,10 +528,9 @@ class VolumeApiTest(test.TestCase):
         mock_latest.side_effect = exception.VolumeSnapshotNotFound(volume_id=
                                                                    'fake_id')
         req = fakes.HTTPRequest.blank('/v3/volumes/fake_id/revert')
-        req.headers = {'OpenStack-API-Version':
+        req.headers = mv.get_mv_header(mv.VOLUME_REVERT)
-                       'volume %s' % REVERT_TO_SNAPSHOT_VERSION}
+        req.api_version_request = mv.get_api_version(
-        req.api_version_request = api_version.APIVersionRequest(
+            mv.VOLUME_REVERT)
-            REVERT_TO_SNAPSHOT_VERSION)
 
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.revert,
                           req, 'fake_id', {'revert': {'snapshot_id':
@@ -534,10 +545,9 @@ class VolumeApiTest(test.TestCase):
         fake_snapshot = self._fake_create_snapshot(fake.UUID1)
         mock_latest.return_value = fake_snapshot
         req = fakes.HTTPRequest.blank('/v3/volumes/fake_id/revert')
-        req.headers = {'OpenStack-API-Version':
+        req.headers = mv.get_mv_header(mv.VOLUME_REVERT)
-                       'volume %s' % REVERT_TO_SNAPSHOT_VERSION}
+        req.api_version_request = mv.get_api_version(
-        req.api_version_request = api_version.APIVersionRequest(
+            mv.VOLUME_REVERT)
-            REVERT_TO_SNAPSHOT_VERSION)
 
         self.assertRaises(webob.exc.HTTPBadRequest, self.controller.revert,
                           req, 'fake_id', {'revert': {'snapshot_id':
@@ -557,10 +567,9 @@ class VolumeApiTest(test.TestCase):
         mock_latest.return_value = fake_snapshot
         req = fakes.HTTPRequest.blank('/v3/volumes/%s/revert'
                                       % fake_volume['id'])
-        req.headers = {'OpenStack-API-Version':
+        req.headers = mv.get_mv_header(mv.VOLUME_REVERT)
-                       'volume %s' % REVERT_TO_SNAPSHOT_VERSION}
+        req.api_version_request = mv.get_api_version(
-        req.api_version_request = api_version.APIVersionRequest(
+            mv.VOLUME_REVERT)
-            REVERT_TO_SNAPSHOT_VERSION)
         # update volume's status failed
         mock_update.side_effect = [False, True]
 

cinder/tests/unit/api/v3/test_workers.py

@@ -19,6 +19,7 @@ from oslo_serialization import jsonutils
 from six.moves import http_client
 import webob
 
+from cinder.api import microversions as mv
 from cinder.api.v3 import router as router_v3
 from cinder.api.v3 import workers
 from cinder import context
@@ -61,7 +62,7 @@ class WorkersTestCase(test.TestCase):
                                               overwrite=False)
         self.controller = workers.create_resource()
 
-    def _get_resp_post(self, body, version='3.24', ctxt=None):
+    def _get_resp_post(self, body, version=mv.WORKERS_CLEANUP, ctxt=None):
         """Helper to execute a POST workers API call."""
         req = webob.Request.blank('/v3/%s/workers/cleanup' % fake.PROJECT_ID)
         req.method = 'POST'
@@ -74,7 +75,7 @@ class WorkersTestCase(test.TestCase):
 
     @mock.patch('cinder.scheduler.rpcapi.SchedulerAPI.work_cleanup')
     def test_cleanup_old_api_version(self, rpc_mock):
-        res = self._get_resp_post({}, '3.19')
+        res = self._get_resp_post({}, mv.get_prior_version(mv.WORKERS_CLEANUP))
         self.assertEqual(http_client.NOT_FOUND, res.status_code)
         rpc_mock.assert_not_called()
 

cinder/tests/unit/message/test_api.py

@@ -16,6 +16,7 @@ from oslo_config import cfg
 from oslo_utils import timeutils
 
 from cinder.api import extensions
+from cinder.api import microversions as mv
 from cinder.api.openstack import api_version_request as api_version
 from cinder.api.v3 import messages
 from cinder import context
@@ -128,8 +129,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers = {version_header_name: 'volume 3.5'}
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.30')
+        req.api_version_request = mv.get_api_version(mv.RESOURCE_FILTER)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -139,8 +140,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers = {version_header_name: 'volume 3.5'}
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.30')
+        req.api_version_request = mv.get_api_version(mv.RESOURCE_FILTER)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -149,12 +150,14 @@ class MessageApiTest(test.TestCase):
     def test_get_all_messages_with_limit_wrong_version(self):
         self.create_message_for_tests()
 
+        PRE_MESSAGES_PAGINATION = mv.get_prior_version(mv.MESSAGES_PAGINATION)
+
         url = '/v3/messages?limit=1'
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers["OpenStack-API-Version"] = "volume 3.3"
+        req.headers = mv.get_mv_header(PRE_MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.3')
+        req.api_version_request = mv.get_api_version(PRE_MESSAGES_PAGINATION)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -167,8 +170,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers["OpenStack-API-Version"] = "volume 3.5"
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.5')
+        req.api_version_request = mv.get_api_version(mv.MESSAGES_PAGINATION)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -181,8 +184,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers["OpenStack-API-Version"] = "volume 3.5"
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.5')
+        req.api_version_request = mv.get_api_version(mv.MESSAGES_PAGINATION)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -196,8 +199,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers["OpenStack-API-Version"] = "volume 3.5"
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.5')
+        req.api_version_request = mv.get_api_version(mv.MESSAGES_PAGINATION)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -210,8 +213,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers["OpenStack-API-Version"] = "volume 3.5"
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.5')
+        req.api_version_request = mv.get_api_version(mv.MESSAGES_PAGINATION)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -242,8 +245,8 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers = {version_header_name: 'volume 3.5'}
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
-        req.api_version_request = api_version.APIVersionRequest('3.30')
+        req.api_version_request = mv.get_api_version(mv.RESOURCE_FILTER)
         req.environ['cinder.context'].is_admin = True
 
         res = self.controller.index(req)
@@ -263,7 +266,7 @@ class MessageApiTest(test.TestCase):
         req = fakes.HTTPRequest.blank(url)
         req.method = 'GET'
         req.content_type = 'application/json'
-        req.headers = {version_header_name: 'volume 3.5'}
+        req.headers = mv.get_mv_header(mv.MESSAGES_PAGINATION)
         req.api_version_request = api_version.max_api_version()
         req.environ['cinder.context'].is_admin = True
 

cinder/volume/api.py

@@ -1910,20 +1910,20 @@ class API(base.Base):
     def _check_boolean_filter_value(self, key, val, strict=False):
         """Boolean filter values in Volume GET.
 
-        Before V3.2, all values other than 'False', 'false', 'FALSE' were
+        Before VOLUME_LIST_BOOTABLE, all values other than 'False', 'false',
-        trated as True for specific boolean filter parameters in Volume
+        'FALSE' were trated as True for specific boolean filter parameters in
-        GET request.
+        Volume GET request.
 
-        But V3.2 onwards, only true/True/0/1/False/false parameters are
+        But VOLUME_LIST_BOOTABLE onwards, only true/True/0/1/False/false
-        supported.
+        parameters are supported.
         All other input values to specific boolean filter parameter will
         lead to raising exception.
 
-        This changes API behavior. So, micro version introduced for V3.2
+        This changes API behavior. So, micro version introduced for
-        onwards.
+        VOLUME_LIST_BOOTABLE onwards.
         """
         if strict:
-            # for updated behavior, from V3.2 onwards.
+            # for updated behavior, from VOLUME_LIST_BOOTABLE onwards.
             # To translate any true/false/t/f/0/1 to True/False
             # which is only acceptable format in database queries.
             try:
@@ -1933,7 +1933,7 @@ class API(base.Base):
                                                       'value': val}
                 raise exception.InvalidInput(reason=msg)
         else:
-            # For existing behavior(before version 3.2)
+            # For existing behavior(before version VOLUME_LIST_BOOTABLE)
             accepted_true = ['True', 'true', 'TRUE']
             accepted_false = ['False', 'false', 'FALSE']
 

doc/source/contributor/api_microversion_dev.rst

@@ -278,8 +278,17 @@ necessary to add changes to other places which describe your change:
   be enough information that it could be used by the docs team for
   release notes.
 
+* Constants should be used in the code to minimize errors on microversion
+  merge conflicts. Define a constant for the new microversion in the
+  ``cinder/api/microversions.py`` file and use that in the rest of the code.
+
 * Update the expected versions in affected tests.
 
+* API changes should almost always include a release note announcing the
+  availability of the new API functionality. The description of the API change
+  should indicate which microversion is required for the change, and it should
+  refer to the numerical value of the microversion and not its constant name.
+
 Allocating a microversion
 -------------------------