diff --git a/HACKING.rst b/HACKING.rst
index 9f7487d..0962f80 100644
--- a/HACKING.rst
+++ b/HACKING.rst
@@ -330,24 +330,25 @@
         # The created server should be in the detailed list of all servers
         ...
 
-Tempest includes a ``check_uuid.py`` tool that will test for the existence
-and uniqueness of idempotent_id metadata for every test. By default the
-tool runs against the Tempest package by calling::
+Tempest-lib includes a ``check-uuid`` tool that will test for the existence
+and uniqueness of idempotent_id metadata for every test. If you have
+tempest-lib installed you run the tool against Tempest by calling from the
+tempest repo::
 
-    python check_uuid.py
+    check-uuid
 
 It can be invoked against any test suite by passing a package name::
 
-    python check_uuid.py --package <package_name>
+    check-uuid --package <package_name>
 
 Tests without an ``idempotent_id`` can be automatically fixed by running
 the command with the ``--fix`` flag, which will modify the source package
 by inserting randomly generated uuids for every test that does not have
 one::
 
-    python check_uuid.py --fix
+    check-uuid --fix
 
-The ``check_uuid.py`` tool is used as part of the tempest gate job
+The ``check-uuid`` tool is used as part of the tempest gate job
 to ensure that all tests have an ``idempotent_id`` decorator.
 
 Branchless Tempest Considerations
diff --git a/run_tests.sh b/run_tests.sh
index 9a158e4..908056f 100755
--- a/run_tests.sh
+++ b/run_tests.sh
@@ -90,9 +90,9 @@
   fi
 
   if [ $serial -eq 1 ]; then
-      ${wrapper} testr run --subunit $testrargs | ${wrapper} subunit-2to1 | ${wrapper} tools/colorizer.py
+      ${wrapper} testr run --subunit $testrargs | ${wrapper} subunit-trace -n -f
   else
-      ${wrapper} testr run --parallel --subunit $testrargs | ${wrapper} subunit-2to1 | ${wrapper} tools/colorizer.py
+      ${wrapper} testr run --parallel --subunit $testrargs | ${wrapper} subunit-trace -n -f
   fi
 }
 
diff --git a/tempest/api/compute/base.py b/tempest/api/compute/base.py
index a5c0600..5bc0769 100644
--- a/tempest/api/compute/base.py
+++ b/tempest/api/compute/base.py
@@ -18,6 +18,7 @@
 from oslo_log import log as logging
 from tempest_lib import exceptions as lib_exc
 
+from tempest.common import api_version_utils
 from tempest.common import compute
 from tempest.common.utils import data_utils
 from tempest.common import waiters
@@ -29,7 +30,8 @@
 LOG = logging.getLogger(__name__)
 
 
-class BaseV2ComputeTest(tempest.test.BaseTestCase):
+class BaseV2ComputeTest(api_version_utils.BaseMicroversionTest,
+                        tempest.test.BaseTestCase):
     """Base test case class for all Compute API tests."""
 
     force_tenant_isolation = False
@@ -43,6 +45,12 @@
         super(BaseV2ComputeTest, cls).skip_checks()
         if not CONF.service_available.nova:
             raise cls.skipException("Nova is not available")
+        cfg_min_version = CONF.compute_feature_enabled.min_microversion
+        cfg_max_version = CONF.compute_feature_enabled.max_microversion
+        api_version_utils.check_skip_with_microversion(cls.min_microversion,
+                                                       cls.max_microversion,
+                                                       cfg_min_version,
+                                                       cfg_max_version)
 
     @classmethod
     def setup_credentials(cls):
diff --git a/tempest/api_schema/response/compute/v2_1/agents.py b/tempest/api_schema/response/compute/v2_1/agents.py
deleted file mode 100644
index da38198..0000000
--- a/tempest/api_schema/response/compute/v2_1/agents.py
+++ /dev/null
@@ -1,60 +0,0 @@
-# Copyright 2014 NEC Corporation.  All rights reserved.
-#
-#    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.
-
-common_agent_info = {
-    'type': 'object',
-    'properties': {
-        'agent_id': {'type': ['integer', 'string']},
-        'hypervisor': {'type': 'string'},
-        'os': {'type': 'string'},
-        'architecture': {'type': 'string'},
-        'version': {'type': 'string'},
-        'url': {'type': 'string', 'format': 'uri'},
-        'md5hash': {'type': 'string'}
-    },
-    'additionalProperties': False,
-    'required': ['agent_id', 'hypervisor', 'os', 'architecture',
-                 'version', 'url', 'md5hash']
-}
-
-list_agents = {
-    'status_code': [200],
-    'response_body': {
-        'type': 'object',
-        'properties': {
-            'agents': {
-                'type': 'array',
-                'items': common_agent_info
-            }
-        },
-        'additionalProperties': False,
-        'required': ['agents']
-    }
-}
-
-create_agent = {
-    'status_code': [200],
-    'response_body': {
-        'type': 'object',
-        'properties': {
-            'agent': common_agent_info
-        },
-        'additionalProperties': False,
-        'required': ['agent']
-    }
-}
-
-delete_agent = {
-    'status_code': [200]
-}
diff --git a/tempest/clients.py b/tempest/clients.py
index 8f63ab1..d16b47b 100644
--- a/tempest/clients.py
+++ b/tempest/clients.py
@@ -35,7 +35,8 @@
 from tempest_lib.services.compute.hosts_client import HostsClient
 from tempest_lib.services.compute.hypervisor_client import \
     HypervisorClient
-from tempest_lib.services.compute.images_client import ImagesClient
+from tempest_lib.services.compute.images_client import ImagesClient \
+    as ComputeImagesClient
 from tempest_lib.services.compute.instance_usage_audit_log_client import \
     InstanceUsagesAuditLogClient
 from tempest_lib.services.compute.limits_client import LimitsClient
@@ -102,8 +103,8 @@
     RegionClient as RegionV3Client
 from tempest.services.identity.v3.json.service_client import \
     ServiceClient as ServiceV3Client
-from tempest.services.image.v1.json.image_client import ImageClient
-from tempest.services.image.v2.json.image_client import ImageClientV2
+from tempest.services.image.v1.json.images_client import ImagesClient
+from tempest.services.image.v2.json.images_client import ImagesClientV2
 from tempest.services.messaging.json.messaging_client import \
     MessagingClient
 from tempest.services.network.json.floating_ips_client import FloatingIPsClient
@@ -260,7 +261,7 @@
                 endpoint_type=CONF.alarming.endpoint_type,
                 **self.default_params_with_timeout_values)
         if CONF.service_available.glance:
-            self.image_client = ImageClient(
+            self.image_client = ImagesClient(
                 self.auth_provider,
                 CONF.image.catalog_type,
                 CONF.image.region or CONF.identity.region,
@@ -268,7 +269,7 @@
                 build_interval=CONF.image.build_interval,
                 build_timeout=CONF.image.build_timeout,
                 **self.default_params)
-            self.image_client_v2 = ImageClientV2(
+            self.image_client_v2 = ImagesClientV2(
                 self.auth_provider,
                 CONF.image.catalog_type,
                 CONF.image.region or CONF.identity.region,
@@ -329,7 +330,7 @@
         self.server_groups_client = ServerGroupsClient(
             self.auth_provider, **params)
         self.limits_client = LimitsClient(self.auth_provider, **params)
-        self.images_client = ImagesClient(self.auth_provider, **params)
+        self.images_client = ComputeImagesClient(self.auth_provider, **params)
         self.keypairs_client = KeyPairsClient(self.auth_provider, **params)
         self.quotas_client = QuotasClient(self.auth_provider, **params)
         self.quota_classes_client = QuotaClassesClient(self.auth_provider,
diff --git a/tempest/cmd/javelin.py b/tempest/cmd/javelin.py
index b126ef6..c5e4a7e 100755
--- a/tempest/cmd/javelin.py
+++ b/tempest/cmd/javelin.py
@@ -128,7 +128,7 @@
 from tempest.services.compute.json import security_group_rules_client
 from tempest.services.compute.json import servers_client
 from tempest.services.identity.v2.json import identity_client
-from tempest.services.image.v2.json import image_client
+from tempest.services.image.v2.json import images_client
 from tempest.services.network.json import network_client
 from tempest.services.network.json import subnets_client
 from tempest.services.object_storage import container_client
@@ -213,7 +213,7 @@
                                                   **object_storage_params)
         self.containers = container_client.ContainerClient(
             _auth, **object_storage_params)
-        self.images = image_client.ImageClientV2(
+        self.images = images_client.ImagesClientV2(
             _auth,
             CONF.image.catalog_type,
             CONF.image.region or CONF.identity.region,
diff --git a/tempest/common/api_version_request.py b/tempest/common/api_version_request.py
new file mode 100644
index 0000000..72a11ea
--- /dev/null
+++ b/tempest/common/api_version_request.py
@@ -0,0 +1,152 @@
+# Copyright 2014 IBM Corp.
+#
+#    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.
+
+import re
+
+from tempest import exceptions
+
+
+# Define the minimum and maximum version of the API across all of the
+# REST API. The format of the version is:
+# X.Y where:
+#
+# - X will only be changed if a significant backwards incompatible API
+# change is made which affects the API as whole. That is, something
+# that is only very very rarely incremented.
+#
+# - Y when you make any change to the API. Note that this includes
+# semantic changes which may not affect the input or output formats or
+# even originate in the API code layer. We are not distinguishing
+# between backwards compatible and backwards incompatible changes in
+# the versioning system. It must be made clear in the documentation as
+# to what is a backwards compatible change and what is a backwards
+# incompatible one.
+
+class APIVersionRequest(object):
+    """This class represents an API Version Request.
+
+    This class provides convenience methods for manipulation
+    and comparison of version numbers that we need to do to
+    implement microversions.
+    """
+
+    # NOTE: This 'latest' version is a magic number, we assume any
+    # projects(Nova, etc.) never achieve this number.
+    latest_ver_major = 99999
+    latest_ver_minor = 99999
+
+    def __init__(self, version_string=None):
+        """Create an API version request object.
+
+        :param version_string: String representation of APIVersionRequest.
+            Correct format is 'X.Y', where 'X' and 'Y' are int values.
+            None value should be used to create Null APIVersionRequest,
+            which is equal to 0.0
+        """
+        self.ver_major = 0
+        self.ver_minor = 0
+
+        if version_string is not None:
+            match = re.match(r"^([1-9]\d*)\.([1-9]\d*|0)$",
+                             version_string)
+            if match:
+                self.ver_major = int(match.group(1))
+                self.ver_minor = int(match.group(2))
+            elif version_string == 'latest':
+                self.ver_major = self.latest_ver_major
+                self.ver_minor = self.latest_ver_minor
+            else:
+                raise exceptions.InvalidAPIVersionString(
+                    version=version_string)
+
+    def __str__(self):
+        """Debug/Logging representation of object."""
+        return ("API Version Request: %s" % self.get_string())
+
+    def is_null(self):
+        return self.ver_major == 0 and self.ver_minor == 0
+
+    def _format_type_error(self, other):
+        return TypeError("'%(other)s' should be an instance of '%(cls)s'" %
+                         {"other": other, "cls": self.__class__})
+
+    def __lt__(self, other):
+        if not isinstance(other, APIVersionRequest):
+            raise self._format_type_error(other)
+
+        return ((self.ver_major, self.ver_minor) <
+                (other.ver_major, other.ver_minor))
+
+    def __eq__(self, other):
+        if not isinstance(other, APIVersionRequest):
+            raise self._format_type_error(other)
+
+        return ((self.ver_major, self.ver_minor) ==
+                (other.ver_major, other.ver_minor))
+
+    def __gt__(self, other):
+        if not isinstance(other, APIVersionRequest):
+            raise self._format_type_error(other)
+
+        return ((self.ver_major, self.ver_minor) >
+                (other.ver_major, other.ver_minor))
+
+    def __le__(self, other):
+        return self < other or self == other
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __ge__(self, other):
+        return self > other or self == other
+
+    def matches(self, min_version, max_version):
+        """Matches the version object.
+
+        Returns whether the version object represents a version
+        greater than or equal to the minimum version and less than
+        or equal to the maximum version.
+
+        @param min_version: Minimum acceptable version.
+        @param max_version: Maximum acceptable version.
+        @returns: boolean
+
+        If min_version is null then there is no minimum limit.
+        If max_version is null then there is no maximum limit.
+        If self is null then raise ValueError
+        """
+
+        if self.is_null():
+            raise ValueError
+        if max_version.is_null() and min_version.is_null():
+            return True
+        elif max_version.is_null():
+            return min_version <= self
+        elif min_version.is_null():
+            return self <= max_version
+        else:
+            return min_version <= self <= max_version
+
+    def get_string(self):
+        """Version string representation.
+
+        Converts object to string representation which if used to create
+        an APIVersionRequest object results in the same version request.
+        """
+        if self.is_null():
+            return None
+        if (self.ver_major == self.latest_ver_major and
+            self.ver_minor == self.latest_ver_minor):
+            return 'latest'
+        return "%s.%s" % (self.ver_major, self.ver_minor)
diff --git a/tempest/common/api_version_utils.py b/tempest/common/api_version_utils.py
new file mode 100644
index 0000000..c499f23
--- /dev/null
+++ b/tempest/common/api_version_utils.py
@@ -0,0 +1,64 @@
+# Copyright 2015 NEC Corporation.  All rights reserved.
+#
+#    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.
+
+import testtools
+
+from tempest.common import api_version_request
+from tempest import exceptions
+
+
+class BaseMicroversionTest(object):
+    """Mixin class for API microversion test class."""
+
+    # NOTE: Basically, each microversion is small API change and we
+    # can use the same tests for most microversions in most cases.
+    # So it is nice to define the test class as possible to run
+    # for all microversions. We need to define microversion range
+    # (min_microversion, max_microversion) on each test class if necessary.
+    min_microversion = None
+    max_microversion = 'latest'
+
+
+def check_skip_with_microversion(test_min_version, test_max_version,
+                                 cfg_min_version, cfg_max_version):
+    min_version = api_version_request.APIVersionRequest(test_min_version)
+    max_version = api_version_request.APIVersionRequest(test_max_version)
+    config_min_version = api_version_request.APIVersionRequest(cfg_min_version)
+    config_max_version = api_version_request.APIVersionRequest(cfg_max_version)
+    if ((min_version > max_version) or
+       (config_min_version > config_max_version)):
+        msg = ("Min version is greater than Max version. Test Class versions "
+               "[%s - %s]. configration versions [%s - %s]."
+               % (min_version.get_string(),
+                  max_version.get_string(),
+                  config_min_version.get_string(),
+                  config_max_version.get_string()))
+        raise exceptions.InvalidConfiguration(msg)
+
+    # NOTE: Select tests which are in range of configuration like
+    #               config min           config max
+    # ----------------+--------------------------+----------------
+    # ...don't-select|
+    #            ...select...  ...select...  ...select...
+    #                                             |don't-select...
+    # ......................select............................
+    if (max_version < config_min_version or
+        config_max_version < min_version):
+        msg = ("The microversion range[%s - %s] of this test is out of the "
+               "configration range[%s - %s]."
+               % (min_version.get_string(),
+                  max_version.get_string(),
+                  config_min_version.get_string(),
+                  config_max_version.get_string()))
+        raise testtools.TestCase.skipException(msg)
diff --git a/tempest/common/glance_http.py b/tempest/common/glance_http.py
index e5431a0..800e977 100644
--- a/tempest/common/glance_http.py
+++ b/tempest/common/glance_http.py
@@ -24,12 +24,10 @@
 
 import OpenSSL
 from oslo_log import log as logging
-from oslo_serialization import jsonutils as json
 import six
 from six import moves
 from six.moves import http_client as httplib
 from six.moves.urllib import parse as urlparse
-from tempest_lib import exceptions as lib_exc
 
 from tempest import exceptions as exc
 
@@ -51,19 +49,20 @@
         self.endpoint_port = endpoint_parts.port
         self.endpoint_path = endpoint_parts.path
 
-        self.connection_class = self.get_connection_class(self.endpoint_scheme)
-        self.connection_kwargs = self.get_connection_kwargs(
+        self.connection_class = self._get_connection_class(
+            self.endpoint_scheme)
+        self.connection_kwargs = self._get_connection_kwargs(
             self.endpoint_scheme, **kwargs)
 
     @staticmethod
-    def get_connection_class(scheme):
+    def _get_connection_class(scheme):
         if scheme == 'https':
             return VerifiedHTTPSConnection
         else:
             return httplib.HTTPConnection
 
     @staticmethod
-    def get_connection_kwargs(scheme, **kwargs):
+    def _get_connection_kwargs(scheme, **kwargs):
         _kwargs = {'timeout': float(kwargs.get('timeout', 600))}
 
         if scheme == 'https':
@@ -75,7 +74,7 @@
 
         return _kwargs
 
-    def get_connection(self):
+    def _get_connection(self):
         _class = self.connection_class
         try:
             return _class(self.endpoint_hostname, self.endpoint_port,
@@ -95,7 +94,7 @@
 
         self._log_request(method, url, kwargs['headers'])
 
-        conn = self.get_connection()
+        conn = self._get_connection()
 
         try:
             url_parts = urlparse.urlparse(url)
@@ -159,30 +158,6 @@
                 self.LOG.debug("Large body (%d) md5 summary: %s", length,
                                hashlib.md5(str_body).hexdigest())
 
-    def json_request(self, method, url, **kwargs):
-        kwargs.setdefault('headers', {})
-        kwargs['headers'].setdefault('Content-Type', 'application/json')
-        if kwargs['headers']['Content-Type'] != 'application/json':
-            msg = "Only application/json content-type is supported."
-            raise lib_exc.InvalidContentType(msg)
-
-        if 'body' in kwargs:
-            kwargs['body'] = json.dumps(kwargs['body'])
-
-        resp, body_iter = self._http_request(url, method, **kwargs)
-
-        if 'application/json' in resp.getheader('content-type', ''):
-            body = ''.join([chunk for chunk in body_iter])
-            try:
-                body = json.loads(body)
-            except ValueError:
-                LOG.error('Could not decode response body as JSON')
-        else:
-            msg = "Only json/application content-type is supported."
-            raise lib_exc.InvalidContentType(msg)
-
-        return resp, body
-
     def raw_request(self, method, url, **kwargs):
         kwargs.setdefault('headers', {})
         kwargs['headers'].setdefault('Content-Type',
diff --git a/tempest/config.py b/tempest/config.py
index 8c3656f..26dda2d 100644
--- a/tempest/config.py
+++ b/tempest/config.py
@@ -341,6 +341,22 @@
                                       title="Enabled Compute Service Features")
 
 ComputeFeaturesGroup = [
+    cfg.StrOpt('min_microversion',
+               default=None,
+               help="Lower version of the test target microversion range. "
+                    "The format is 'X.Y', where 'X' and 'Y' are int values. "
+                    "Tempest selects tests based on the range between "
+                    "min_microversion and max_microversion. "
+                    "If both values are None, Tempest avoids tests which "
+                    "require a microversion."),
+    cfg.StrOpt('max_microversion',
+               default=None,
+               help="Upper version of the test target microversion range. "
+                    "The format is 'X.Y', where 'X' and 'Y' are int values. "
+                    "Tempest selects tests based on the range between "
+                    "min_microversion and max_microversion. "
+                    "If both values are None, Tempest avoids tests which "
+                    "require a microversion."),
     cfg.BoolOpt('disk_config',
                 default=True,
                 help="If false, skip disk config tests"),
diff --git a/tempest/exceptions.py b/tempest/exceptions.py
index 031df7f..8537898 100644
--- a/tempest/exceptions.py
+++ b/tempest/exceptions.py
@@ -176,6 +176,11 @@
     message = "Invalid structure of table with details"
 
 
+class InvalidAPIVersionString(TempestException):
+    msg_fmt = ("API Version String %(version)s is of invalid format. Must "
+               "be of format MajorNum.MinorNum.")
+
+
 class CommandFailed(Exception):
     def __init__(self, returncode, cmd, output, stderr):
         super(CommandFailed, self).__init__()
diff --git a/tempest/services/image/v1/json/image_client.py b/tempest/services/image/v1/json/images_client.py
similarity index 99%
rename from tempest/services/image/v1/json/image_client.py
rename to tempest/services/image/v1/json/images_client.py
index d97da36..4884106 100644
--- a/tempest/services/image/v1/json/image_client.py
+++ b/tempest/services/image/v1/json/images_client.py
@@ -32,13 +32,13 @@
 LOG = logging.getLogger(__name__)
 
 
-class ImageClient(service_client.ServiceClient):
+class ImagesClient(service_client.ServiceClient):
 
     def __init__(self, auth_provider, catalog_type, region, endpoint_type=None,
                  build_interval=None, build_timeout=None,
                  disable_ssl_certificate_validation=None,
                  ca_certs=None, trace_requests=None):
-        super(ImageClient, self).__init__(
+        super(ImagesClient, self).__init__(
             auth_provider,
             catalog_type,
             region,
diff --git a/tempest/services/image/v2/json/image_client.py b/tempest/services/image/v2/json/images_client.py
similarity index 98%
rename from tempest/services/image/v2/json/image_client.py
rename to tempest/services/image/v2/json/images_client.py
index f7d70ea..33bfcb8 100644
--- a/tempest/services/image/v2/json/image_client.py
+++ b/tempest/services/image/v2/json/images_client.py
@@ -22,13 +22,13 @@
 from tempest.common import service_client
 
 
-class ImageClientV2(service_client.ServiceClient):
+class ImagesClientV2(service_client.ServiceClient):
 
     def __init__(self, auth_provider, catalog_type, region, endpoint_type=None,
                  build_interval=None, build_timeout=None,
                  disable_ssl_certificate_validation=None, ca_certs=None,
                  trace_requests=None):
-        super(ImageClientV2, self).__init__(
+        super(ImagesClientV2, self).__init__(
             auth_provider,
             catalog_type,
             region,
diff --git a/tempest/test.py b/tempest/test.py
index 435d10a..30eb93d 100644
--- a/tempest/test.py
+++ b/tempest/test.py
@@ -27,6 +27,7 @@
 from oslo_serialization import jsonutils as json
 from oslo_utils import importutils
 import six
+from tempest_lib import decorators
 import testscenarios
 import testtools
 
@@ -43,6 +44,8 @@
 
 CONF = config.CONF
 
+idempotent_id = decorators.idempotent_id
+
 
 def attr(**kwargs):
     """A decorator which applies the testtools attr decorator
@@ -62,23 +65,6 @@
     return decorator
 
 
-def idempotent_id(id):
-    """Stub for metadata decorator"""
-    if not isinstance(id, six.string_types):
-        raise TypeError('Test idempotent_id must be string not %s'
-                        '' % type(id).__name__)
-    uuid.UUID(id)
-
-    def decorator(f):
-        f = testtools.testcase.attr('id-%s' % id)(f)
-        if f.__doc__:
-            f.__doc__ = 'Test idempotent id: %s\n%s' % (id, f.__doc__)
-        else:
-            f.__doc__ = 'Test idempotent id: %s' % id
-        return f
-    return decorator
-
-
 def get_service_list():
     service_list = {
         'compute': CONF.service_available.nova,
diff --git a/tempest/tests/common/test_api_version_request.py b/tempest/tests/common/test_api_version_request.py
new file mode 100644
index 0000000..38fbfc1
--- /dev/null
+++ b/tempest/tests/common/test_api_version_request.py
@@ -0,0 +1,146 @@
+# Copyright 2014 IBM Corp.
+#
+#    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.
+
+from tempest.common import api_version_request
+from tempest import exceptions
+from tempest.tests import base
+
+
+class APIVersionRequestTests(base.TestCase):
+    def test_valid_version_strings(self):
+        def _test_string(version, exp_major, exp_minor):
+            v = api_version_request.APIVersionRequest(version)
+            self.assertEqual(v.ver_major, exp_major)
+            self.assertEqual(v.ver_minor, exp_minor)
+
+        _test_string("1.1", 1, 1)
+        _test_string("2.10", 2, 10)
+        _test_string("5.234", 5, 234)
+        _test_string("12.5", 12, 5)
+        _test_string("2.0", 2, 0)
+        _test_string("2.200", 2, 200)
+
+    def test_null_version(self):
+        v = api_version_request.APIVersionRequest()
+        self.assertTrue(v.is_null())
+
+    def test_invalid_version_strings(self):
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "2")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "200")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "2.1.4")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "200.23.66.3")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "5 .3")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "5. 3")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "5.03")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "02.1")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "2.001")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, " 2.1")
+
+        self.assertRaises(exceptions.InvalidAPIVersionString,
+                          api_version_request.APIVersionRequest, "2.1 ")
+
+    def test_version_comparisons(self):
+        vers2_0 = api_version_request.APIVersionRequest("2.0")
+        vers2_5 = api_version_request.APIVersionRequest("2.5")
+        vers5_23 = api_version_request.APIVersionRequest("5.23")
+        v_null = api_version_request.APIVersionRequest()
+        v_latest = api_version_request.APIVersionRequest('latest')
+
+        self.assertTrue(v_null < vers2_5)
+        self.assertTrue(vers2_0 < vers2_5)
+        self.assertTrue(vers2_0 <= vers2_5)
+        self.assertTrue(vers2_0 <= vers2_0)
+        self.assertTrue(vers2_5 > v_null)
+        self.assertTrue(vers5_23 > vers2_5)
+        self.assertTrue(vers2_0 >= vers2_0)
+        self.assertTrue(vers5_23 >= vers2_5)
+        self.assertTrue(vers2_0 != vers2_5)
+        self.assertTrue(vers2_0 == vers2_0)
+        self.assertTrue(vers2_0 != v_null)
+        self.assertTrue(v_null == v_null)
+        self.assertTrue(vers2_0 <= v_latest)
+        self.assertTrue(vers2_0 != v_latest)
+        self.assertTrue(v_latest == v_latest)
+        self.assertRaises(TypeError, vers2_0.__lt__, "2.1")
+
+    def test_version_matches(self):
+        vers2_0 = api_version_request.APIVersionRequest("2.0")
+        vers2_5 = api_version_request.APIVersionRequest("2.5")
+        vers2_45 = api_version_request.APIVersionRequest("2.45")
+        vers3_3 = api_version_request.APIVersionRequest("3.3")
+        vers3_23 = api_version_request.APIVersionRequest("3.23")
+        vers4_0 = api_version_request.APIVersionRequest("4.0")
+        v_null = api_version_request.APIVersionRequest()
+        v_latest = api_version_request.APIVersionRequest('latest')
+
+        def _check_version_matches(version, version1, version2, check=True):
+            if check:
+                msg = "Version %s does not matches with [%s - %s] range"
+                self.assertTrue(version.matches(version1, version2),
+                                msg % (version.get_string(),
+                                       version1.get_string(),
+                                       version2.get_string()))
+            else:
+                msg = "Version %s matches with [%s - %s] range"
+                self.assertFalse(version.matches(version1, version2),
+                                 msg % (version.get_string(),
+                                        version1.get_string(),
+                                        version2.get_string()))
+
+        _check_version_matches(vers2_5, vers2_0, vers2_45)
+        _check_version_matches(vers2_5, vers2_0, v_null)
+        _check_version_matches(vers2_0, vers2_0, vers2_5)
+        _check_version_matches(vers3_3, vers2_5, vers3_3)
+        _check_version_matches(vers3_3, v_null, vers3_3)
+        _check_version_matches(vers3_3, v_null, vers4_0)
+        _check_version_matches(vers2_0, vers2_5, vers2_45, False)
+        _check_version_matches(vers3_23, vers2_5, vers3_3, False)
+        _check_version_matches(vers2_5, vers2_45, vers2_0, False)
+        _check_version_matches(vers2_5, vers2_0, v_latest)
+        _check_version_matches(v_latest, v_latest, v_latest)
+        _check_version_matches(vers2_5, v_latest, v_latest, False)
+        _check_version_matches(v_latest, vers2_0, vers4_0, False)
+
+        self.assertRaises(ValueError, v_null.matches, vers2_0, vers2_45)
+
+    def test_get_string(self):
+        vers_string = ["3.23", "latest"]
+        for ver in vers_string:
+            ver_obj = api_version_request.APIVersionRequest(ver)
+            self.assertEqual(ver, ver_obj.get_string())
+
+        self.assertIsNotNone(
+            api_version_request.APIVersionRequest().get_string)
diff --git a/tempest/tests/common/test_api_version_utils.py b/tempest/tests/common/test_api_version_utils.py
new file mode 100644
index 0000000..33024b6
--- /dev/null
+++ b/tempest/tests/common/test_api_version_utils.py
@@ -0,0 +1,194 @@
+# Copyright 2015 NEC Corporation.  All rights reserved.
+#
+#    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.
+
+from oslo_config import cfg
+import testtools
+
+from tempest.api.compute import base as compute_base
+from tempest.common import api_version_utils
+from tempest import config
+from tempest import exceptions
+from tempest.tests import base
+from tempest.tests import fake_config
+
+
+class VersionTestNoneTolatest(compute_base.BaseV2ComputeTest):
+    min_microversion = None
+    max_microversion = 'latest'
+
+
+class VersionTestNoneTo2_2(compute_base.BaseV2ComputeTest):
+    min_microversion = None
+    max_microversion = '2.2'
+
+
+class VersionTest2_3ToLatest(compute_base.BaseV2ComputeTest):
+    min_microversion = '2.3'
+    max_microversion = 'latest'
+
+
+class VersionTest2_5To2_10(compute_base.BaseV2ComputeTest):
+    min_microversion = '2.5'
+    max_microversion = '2.10'
+
+
+class VersionTest2_10To2_10(compute_base.BaseV2ComputeTest):
+    min_microversion = '2.10'
+    max_microversion = '2.10'
+
+
+class InvalidVersionTest(compute_base.BaseV2ComputeTest):
+    min_microversion = '2.11'
+    max_microversion = '2.1'
+
+
+class TestMicroversionsTestsClass(base.TestCase):
+
+    def setUp(self):
+        super(TestMicroversionsTestsClass, self).setUp()
+        self.useFixture(fake_config.ConfigFixture())
+        self.stubs.Set(config, 'TempestConfigPrivate',
+                       fake_config.FakePrivate)
+
+    def _test_version(self, cfg_min, cfg_max,
+                      expected_pass_tests,
+                      expected_skip_tests):
+        cfg.CONF.set_default('min_microversion',
+                             cfg_min, group='compute-feature-enabled')
+        cfg.CONF.set_default('max_microversion',
+                             cfg_max, group='compute-feature-enabled')
+        try:
+            for test_class in expected_pass_tests:
+                test_class.skip_checks()
+            for test_class in expected_skip_tests:
+                self.assertRaises(testtools.TestCase.skipException,
+                                  test_class.skip_checks)
+        except testtools.TestCase.skipException as e:
+            raise testtools.TestCase.failureException(e.message)
+
+    def test_config_version_none_none(self):
+        expected_pass_tests = [VersionTestNoneTolatest, VersionTestNoneTo2_2]
+        expected_skip_tests = [VersionTest2_3ToLatest, VersionTest2_5To2_10,
+                               VersionTest2_10To2_10]
+        self._test_version(None, None,
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_version_none_23(self):
+        expected_pass_tests = [VersionTestNoneTolatest, VersionTestNoneTo2_2,
+                               VersionTest2_3ToLatest]
+        expected_skip_tests = [VersionTest2_5To2_10, VersionTest2_10To2_10]
+        self._test_version(None, '2.3',
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_version_22_latest(self):
+        expected_pass_tests = [VersionTestNoneTolatest, VersionTestNoneTo2_2,
+                               VersionTest2_3ToLatest, VersionTest2_5To2_10,
+                               VersionTest2_10To2_10]
+        expected_skip_tests = []
+        self._test_version('2.2', 'latest',
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_version_22_23(self):
+        expected_pass_tests = [VersionTestNoneTolatest, VersionTestNoneTo2_2,
+                               VersionTest2_3ToLatest]
+        expected_skip_tests = [VersionTest2_5To2_10, VersionTest2_10To2_10]
+        self._test_version('2.2', '2.3',
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_version_210_210(self):
+        expected_pass_tests = [VersionTestNoneTolatest,
+                               VersionTest2_3ToLatest,
+                               VersionTest2_5To2_10,
+                               VersionTest2_10To2_10]
+        expected_skip_tests = [VersionTestNoneTo2_2]
+        self._test_version('2.10', '2.10',
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_version_none_latest(self):
+        expected_pass_tests = [VersionTestNoneTolatest, VersionTestNoneTo2_2,
+                               VersionTest2_3ToLatest, VersionTest2_5To2_10,
+                               VersionTest2_10To2_10]
+        expected_skip_tests = []
+        self._test_version(None, 'latest',
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_version_latest_latest(self):
+        expected_pass_tests = [VersionTestNoneTolatest, VersionTest2_3ToLatest]
+        expected_skip_tests = [VersionTestNoneTo2_2, VersionTest2_5To2_10,
+                               VersionTest2_10To2_10]
+        self._test_version('latest', 'latest',
+                           expected_pass_tests,
+                           expected_skip_tests)
+
+    def test_config_invalid_version(self):
+        cfg.CONF.set_default('min_microversion',
+                             '2.5', group='compute-feature-enabled')
+        cfg.CONF.set_default('max_microversion',
+                             '2.1', group='compute-feature-enabled')
+        self.assertRaises(exceptions.InvalidConfiguration,
+                          VersionTestNoneTolatest.skip_checks)
+
+    def test_config_version_invalid_test_version(self):
+        cfg.CONF.set_default('min_microversion',
+                             None, group='compute-feature-enabled')
+        cfg.CONF.set_default('max_microversion',
+                             '2.13', group='compute-feature-enabled')
+        self.assertRaises(exceptions.InvalidConfiguration,
+                          InvalidVersionTest.skip_checks)
+
+
+class TestVersionSkipLogic(base.TestCase):
+
+    def _test_version(self, test_min_version, test_max_version,
+                      cfg_min_version, cfg_max_version, expected_skip=False):
+        try:
+            api_version_utils.check_skip_with_microversion(test_min_version,
+                                                           test_max_version,
+                                                           cfg_min_version,
+                                                           cfg_max_version)
+        except testtools.TestCase.skipException as e:
+            if not expected_skip:
+                raise testtools.TestCase.failureException(e.message)
+
+    def test_version_min_in_range(self):
+        self._test_version('2.2', '2.10', '2.1', '2.7')
+
+    def test_version_max_in_range(self):
+        self._test_version('2.1', '2.3', '2.2', '2.7')
+
+    def test_version_cfg_in_range(self):
+        self._test_version('2.2', '2.9', '2.3', '2.7')
+
+    def test_version_equal(self):
+        self._test_version('2.2', '2.2', '2.2', '2.2')
+
+    def test_version_below_cfg_min(self):
+        self._test_version('2.2', '2.4', '2.5', '2.7', expected_skip=True)
+
+    def test_version_above_cfg_max(self):
+        self._test_version('2.8', '2.9', '2.3', '2.7', expected_skip=True)
+
+    def test_version_min_greater_than_max(self):
+        self.assertRaises(exceptions.InvalidConfiguration,
+                          self._test_version, '2.8', '2.7', '2.3', '2.7')
+
+    def test_cfg_version_min_greater_than_max(self):
+        self.assertRaises(exceptions.InvalidConfiguration,
+                          self._test_version, '2.2', '2.7', '2.9', '2.7')
diff --git a/tempest/tests/common/test_service_clients.py b/tempest/tests/common/test_service_clients.py
index 272eba4..8de014f 100644
--- a/tempest/tests/common/test_service_clients.py
+++ b/tempest/tests/common/test_service_clients.py
@@ -36,8 +36,8 @@
 from tempest.services.identity.v3.json import policy_client
 from tempest.services.identity.v3.json import region_client
 from tempest.services.identity.v3.json import service_client
-from tempest.services.image.v1.json import image_client
-from tempest.services.image.v2.json import image_client as image_v2_client
+from tempest.services.image.v1.json import images_client
+from tempest.services.image.v2.json import images_client as images_v2_client
 from tempest.services.messaging.json import messaging_client
 from tempest.services.network.json import network_client
 from tempest.services.object_storage import account_client
@@ -130,8 +130,8 @@
             policy_client.PolicyClient,
             region_client.RegionClient,
             service_client.ServiceClient,
-            image_client.ImageClient,
-            image_v2_client.ImageClientV2
+            images_client.ImagesClient,
+            images_v2_client.ImagesClientV2
         ]
 
         for client in test_clients:
diff --git a/tempest/tests/test_glance_http.py b/tempest/tests/test_glance_http.py
index 105caec..ed886da 100644
--- a/tempest/tests/test_glance_http.py
+++ b/tempest/tests/test_glance_http.py
@@ -13,14 +13,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import socket
-
 import mock
-from oslo_serialization import jsonutils as json
 from oslotest import mockpatch
 import six
 from six.moves import http_client as httplib
-from tempest_lib import exceptions as lib_exc
 
 from tempest.common import glance_http
 from tempest import exceptions
@@ -56,60 +52,6 @@
                         'getresponse', return_value=resp))
         return resp
 
-    def test_json_request_without_content_type_header_in_response(self):
-        self._set_response_fixture({}, 200, 'fake_response_body')
-        self.assertRaises(lib_exc.InvalidContentType,
-                          self.client.json_request, 'GET', '/images')
-
-    def test_json_request_with_xml_content_type_header_in_request(self):
-        self.assertRaises(lib_exc.InvalidContentType,
-                          self.client.json_request, 'GET', '/images',
-                          headers={'Content-Type': 'application/xml'})
-
-    def test_json_request_with_xml_content_type_header_in_response(self):
-        self._set_response_fixture({'content-type': 'application/xml'},
-                                   200, 'fake_response_body')
-        self.assertRaises(lib_exc.InvalidContentType,
-                          self.client.json_request, 'GET', '/images')
-
-    def test_json_request_with_json_content_type_header_only_in_resp(self):
-        self._set_response_fixture({'content-type': 'application/json'},
-                                   200, 'fake_response_body')
-        resp, body = self.client.json_request('GET', '/images')
-        self.assertEqual(200, resp.status)
-        self.assertEqual('fake_response_body', body)
-
-    def test_json_request_with_json_content_type_header_in_req_and_resp(self):
-        self._set_response_fixture({'content-type': 'application/json'},
-                                   200, 'fake_response_body')
-        resp, body = self.client.json_request('GET', '/images', headers={
-            'Content-Type': 'application/json'})
-        self.assertEqual(200, resp.status)
-        self.assertEqual('fake_response_body', body)
-
-    def test_json_request_fails_to_json_loads(self):
-        self._set_response_fixture({'content-type': 'application/json'},
-                                   200, 'fake_response_body')
-        self.useFixture(mockpatch.PatchObject(json, 'loads',
-                        side_effect=ValueError()))
-        resp, body = self.client.json_request('GET', '/images')
-        self.assertEqual(200, resp.status)
-        self.assertEqual(body, 'fake_response_body')
-
-    def test_json_request_socket_timeout(self):
-        self.useFixture(mockpatch.PatchObject(httplib.HTTPConnection,
-                                              'request',
-                                              side_effect=socket.timeout()))
-        self.assertRaises(exceptions.TimeoutException,
-                          self.client.json_request, 'GET', '/images')
-
-    def test_json_request_endpoint_not_found(self):
-        self.useFixture(mockpatch.PatchObject(httplib.HTTPConnection,
-                                              'request',
-                                              side_effect=socket.gaierror()))
-        self.assertRaises(exceptions.EndpointNotFound,
-                          self.client.json_request, 'GET', '/images')
-
     def test_raw_request(self):
         self._set_response_fixture({}, 200, 'fake_response_body')
         resp, body = self.client.raw_request('GET', '/images')
@@ -141,22 +83,22 @@
         self.assertEqual(call_count - 1, req_body.tell())
 
     def test_get_connection_class_for_https(self):
-        conn_class = self.client.get_connection_class('https')
+        conn_class = self.client._get_connection_class('https')
         self.assertEqual(glance_http.VerifiedHTTPSConnection, conn_class)
 
     def test_get_connection_class_for_http(self):
-        conn_class = (self.client.get_connection_class('http'))
+        conn_class = (self.client._get_connection_class('http'))
         self.assertEqual(httplib.HTTPConnection, conn_class)
 
     def test_get_connection_http(self):
-        self.assertTrue(isinstance(self.client.get_connection(),
+        self.assertTrue(isinstance(self.client._get_connection(),
                                    httplib.HTTPConnection))
 
     def test_get_connection_https(self):
         endpoint = 'https://fake_url.com'
         self.fake_auth.base_url = mock.MagicMock(return_value=endpoint)
         self.client = glance_http.HTTPClient(self.fake_auth, {})
-        self.assertTrue(isinstance(self.client.get_connection(),
+        self.assertTrue(isinstance(self.client._get_connection(),
                                    glance_http.VerifiedHTTPSConnection))
 
     def test_get_connection_url_not_fount(self):
@@ -164,22 +106,22 @@
                                               side_effect=httplib.InvalidURL()
                                               ))
         self.assertRaises(exceptions.EndpointNotFound,
-                          self.client.get_connection)
+                          self.client._get_connection)
 
     def test_get_connection_kwargs_default_for_http(self):
-        kwargs = self.client.get_connection_kwargs('http')
+        kwargs = self.client._get_connection_kwargs('http')
         self.assertEqual(600, kwargs['timeout'])
         self.assertEqual(1, len(kwargs.keys()))
 
     def test_get_connection_kwargs_set_timeout_for_http(self):
-        kwargs = self.client.get_connection_kwargs('http', timeout=10,
-                                                   ca_certs='foo')
+        kwargs = self.client._get_connection_kwargs('http', timeout=10,
+                                                    ca_certs='foo')
         self.assertEqual(10, kwargs['timeout'])
         # nothing more than timeout is evaluated for http connections
         self.assertEqual(1, len(kwargs.keys()))
 
     def test_get_connection_kwargs_default_for_https(self):
-        kwargs = self.client.get_connection_kwargs('https')
+        kwargs = self.client._get_connection_kwargs('https')
         self.assertEqual(600, kwargs['timeout'])
         self.assertEqual(None, kwargs['ca_certs'])
         self.assertEqual(None, kwargs['cert_file'])
@@ -189,12 +131,12 @@
         self.assertEqual(6, len(kwargs.keys()))
 
     def test_get_connection_kwargs_set_params_for_https(self):
-        kwargs = self.client.get_connection_kwargs('https', timeout=10,
-                                                   ca_certs='foo',
-                                                   cert_file='/foo/bar.cert',
-                                                   key_file='/foo/key.pem',
-                                                   insecure=True,
-                                                   ssl_compression=False)
+        kwargs = self.client._get_connection_kwargs('https', timeout=10,
+                                                    ca_certs='foo',
+                                                    cert_file='/foo/bar.cert',
+                                                    key_file='/foo/key.pem',
+                                                    insecure=True,
+                                                    ssl_compression=False)
         self.assertEqual(10, kwargs['timeout'])
         self.assertEqual('foo', kwargs['ca_certs'])
         self.assertEqual('/foo/bar.cert', kwargs['cert_file'])
diff --git a/tools/check_uuid.py b/tools/check_uuid.py
deleted file mode 100755
index a71ad39..0000000
--- a/tools/check_uuid.py
+++ /dev/null
@@ -1,358 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright 2014 Mirantis, Inc.
-#
-# 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.
-
-import argparse
-import ast
-import importlib
-import inspect
-import os
-import sys
-import unittest
-import urllib
-import uuid
-
-DECORATOR_MODULE = 'test'
-DECORATOR_NAME = 'idempotent_id'
-DECORATOR_IMPORT = 'tempest.%s' % DECORATOR_MODULE
-IMPORT_LINE = 'from tempest import %s' % DECORATOR_MODULE
-DECORATOR_TEMPLATE = "@%s.%s('%%s')" % (DECORATOR_MODULE,
-                                        DECORATOR_NAME)
-UNIT_TESTS_EXCLUDE = 'tempest.tests'
-
-
-class SourcePatcher(object):
-
-    """"Lazy patcher for python source files"""
-
-    def __init__(self):
-        self.source_files = None
-        self.patches = None
-        self.clear()
-
-    def clear(self):
-        """Clear inner state"""
-        self.source_files = {}
-        self.patches = {}
-
-    @staticmethod
-    def _quote(s):
-        return urllib.quote(s)
-
-    @staticmethod
-    def _unquote(s):
-        return urllib.unquote(s)
-
-    def add_patch(self, filename, patch, line_no):
-        """Add lazy patch"""
-        if filename not in self.source_files:
-            with open(filename) as f:
-                self.source_files[filename] = self._quote(f.read())
-        patch_id = str(uuid.uuid4())
-        if not patch.endswith('\n'):
-            patch += '\n'
-        self.patches[patch_id] = self._quote(patch)
-        lines = self.source_files[filename].split(self._quote('\n'))
-        lines[line_no - 1] = ''.join(('{%s:s}' % patch_id, lines[line_no - 1]))
-        self.source_files[filename] = self._quote('\n').join(lines)
-
-    def _save_changes(self, filename, source):
-        print('%s fixed' % filename)
-        with open(filename, 'w') as f:
-            f.write(source)
-
-    def apply_patches(self):
-        """Apply all patches"""
-        for filename in self.source_files:
-            patched_source = self._unquote(
-                self.source_files[filename].format(**self.patches)
-            )
-            self._save_changes(filename, patched_source)
-        self.clear()
-
-
-class TestChecker(object):
-
-    def __init__(self, package):
-        self.package = package
-        self.base_path = os.path.abspath(os.path.dirname(package.__file__))
-
-    def _path_to_package(self, path):
-        relative_path = path[len(self.base_path) + 1:]
-        if relative_path:
-            return '.'.join((self.package.__name__,) +
-                            tuple(relative_path.split('/')))
-        else:
-            return self.package.__name__
-
-    def _modules_search(self):
-        """Recursive search for python modules in base package"""
-        modules = []
-        for root, dirs, files in os.walk(self.base_path):
-            if not os.path.exists(os.path.join(root, '__init__.py')):
-                continue
-            root_package = self._path_to_package(root)
-            for item in files:
-                if item.endswith('.py'):
-                    module_name = '.'.join((root_package,
-                                           os.path.splitext(item)[0]))
-                    if not module_name.startswith(UNIT_TESTS_EXCLUDE):
-                        modules.append(module_name)
-        return modules
-
-    @staticmethod
-    def _get_idempotent_id(test_node):
-        # Return key-value dict with all metadata from @test.idempotent_id
-        # decorators for test method
-        idempotent_id = None
-        for decorator in test_node.decorator_list:
-            if (hasattr(decorator, 'func') and
-                hasattr(decorator.func, 'attr') and
-                decorator.func.attr == DECORATOR_NAME and
-                hasattr(decorator.func, 'value') and
-                decorator.func.value.id == DECORATOR_MODULE):
-                for arg in decorator.args:
-                    idempotent_id = ast.literal_eval(arg)
-        return idempotent_id
-
-    @staticmethod
-    def _is_decorator(line):
-        return line.strip().startswith('@')
-
-    @staticmethod
-    def _is_def(line):
-        return line.strip().startswith('def ')
-
-    def _add_uuid_to_test(self, patcher, test_node, source_path):
-        with open(source_path) as src:
-            src_lines = src.read().split('\n')
-        lineno = test_node.lineno
-        insert_position = lineno
-        while True:
-            if (self._is_def(src_lines[lineno - 1]) or
-                    (self._is_decorator(src_lines[lineno - 1]) and
-                        (DECORATOR_TEMPLATE.split('(')[0] <=
-                            src_lines[lineno - 1].strip().split('(')[0]))):
-                insert_position = lineno
-                break
-            lineno += 1
-        patcher.add_patch(
-            source_path,
-            ' ' * test_node.col_offset + DECORATOR_TEMPLATE % uuid.uuid4(),
-            insert_position
-        )
-
-    @staticmethod
-    def _is_test_case(module, node):
-        if (node.__class__ is ast.ClassDef and
-                hasattr(module, node.name) and
-                inspect.isclass(getattr(module, node.name))):
-            return issubclass(getattr(module, node.name), unittest.TestCase)
-
-    @staticmethod
-    def _is_test_method(node):
-        return (node.__class__ is ast.FunctionDef
-                and node.name.startswith('test_'))
-
-    @staticmethod
-    def _next_node(body, node):
-        if body.index(node) < len(body):
-            return body[body.index(node) + 1]
-
-    @staticmethod
-    def _import_name(node):
-        if type(node) == ast.Import:
-            return node.names[0].name
-        elif type(node) == ast.ImportFrom:
-            return '%s.%s' % (node.module, node.names[0].name)
-
-    def _add_import_for_test_uuid(self, patcher, src_parsed, source_path):
-        with open(source_path) as f:
-            src_lines = f.read().split('\n')
-        line_no = 0
-        tempest_imports = [node for node in src_parsed.body
-                           if self._import_name(node) and
-                           'tempest.' in self._import_name(node)]
-        if not tempest_imports:
-            import_snippet = '\n'.join(('', IMPORT_LINE, ''))
-        else:
-            for node in tempest_imports:
-                if self._import_name(node) < DECORATOR_IMPORT:
-                    continue
-                else:
-                    line_no = node.lineno
-                    import_snippet = IMPORT_LINE
-                    break
-            else:
-                line_no = tempest_imports[-1].lineno
-                while True:
-                    if (not src_lines[line_no - 1] or
-                            getattr(self._next_node(src_parsed.body,
-                                                    tempest_imports[-1]),
-                                    'lineno') == line_no or
-                            line_no == len(src_lines)):
-                        break
-                    line_no += 1
-                import_snippet = '\n'.join((IMPORT_LINE, ''))
-        patcher.add_patch(source_path, import_snippet, line_no)
-
-    def get_tests(self):
-        """Get test methods with sources from base package with metadata"""
-        tests = {}
-        for module_name in self._modules_search():
-            tests[module_name] = {}
-            module = importlib.import_module(module_name)
-            source_path = '.'.join(
-                (os.path.splitext(module.__file__)[0], 'py')
-            )
-            with open(source_path, 'r') as f:
-                source = f.read()
-            tests[module_name]['source_path'] = source_path
-            tests[module_name]['tests'] = {}
-            source_parsed = ast.parse(source)
-            tests[module_name]['ast'] = source_parsed
-            tests[module_name]['import_valid'] = (
-                hasattr(module, DECORATOR_MODULE) and
-                inspect.ismodule(getattr(module, DECORATOR_MODULE))
-            )
-            test_cases = (node for node in source_parsed.body
-                          if self._is_test_case(module, node))
-            for node in test_cases:
-                for subnode in filter(self._is_test_method, node.body):
-                        test_name = '%s.%s' % (node.name, subnode.name)
-                        tests[module_name]['tests'][test_name] = subnode
-        return tests
-
-    @staticmethod
-    def _filter_tests(function, tests):
-        """Filter tests with condition 'function(test_node) == True'"""
-        result = {}
-        for module_name in tests:
-            for test_name in tests[module_name]['tests']:
-                if function(module_name, test_name, tests):
-                    if module_name not in result:
-                        result[module_name] = {
-                            'ast': tests[module_name]['ast'],
-                            'source_path': tests[module_name]['source_path'],
-                            'import_valid': tests[module_name]['import_valid'],
-                            'tests': {}
-                        }
-                    result[module_name]['tests'][test_name] = \
-                        tests[module_name]['tests'][test_name]
-        return result
-
-    def find_untagged(self, tests):
-        """Filter all tests without uuid in metadata"""
-        def check_uuid_in_meta(module_name, test_name, tests):
-            idempotent_id = self._get_idempotent_id(
-                tests[module_name]['tests'][test_name])
-            return not idempotent_id
-        return self._filter_tests(check_uuid_in_meta, tests)
-
-    def report_collisions(self, tests):
-        """Reports collisions if there are any.
-
-        Returns true if collisions exist.
-        """
-        uuids = {}
-
-        def report(module_name, test_name, tests):
-            test_uuid = self._get_idempotent_id(
-                tests[module_name]['tests'][test_name])
-            if not test_uuid:
-                return
-            if test_uuid in uuids:
-                error_str = "%s:%s\n uuid %s collision: %s<->%s\n%s:%s" % (
-                    tests[module_name]['source_path'],
-                    tests[module_name]['tests'][test_name].lineno,
-                    test_uuid,
-                    test_name,
-                    uuids[test_uuid]['test_name'],
-                    uuids[test_uuid]['source_path'],
-                    uuids[test_uuid]['test_node'].lineno,
-                )
-                print(error_str)
-                print("cannot automatically resolve the collision, please "
-                      "manually remove the duplicate value on the new test.")
-                return True
-            else:
-                uuids[test_uuid] = {
-                    'module': module_name,
-                    'test_name': test_name,
-                    'test_node': tests[module_name]['tests'][test_name],
-                    'source_path': tests[module_name]['source_path']
-                }
-        return bool(self._filter_tests(report, tests))
-
-    def report_untagged(self, tests):
-        """Reports untagged tests if there are any.
-
-        Returns true if untagged tests exist.
-        """
-        def report(module_name, test_name, tests):
-            error_str = "%s:%s\nmissing @test.idempotent_id('...')\n%s\n" % (
-                tests[module_name]['source_path'],
-                tests[module_name]['tests'][test_name].lineno,
-                test_name
-            )
-            print(error_str)
-            return True
-        return bool(self._filter_tests(report, tests))
-
-    def fix_tests(self, tests):
-        """Add uuids to all tests specified in tests and fix it"""
-        patcher = SourcePatcher()
-        for module_name in tests:
-            add_import_once = True
-            for test_name in tests[module_name]['tests']:
-                if not tests[module_name]['import_valid'] and add_import_once:
-                    self._add_import_for_test_uuid(
-                        patcher,
-                        tests[module_name]['ast'],
-                        tests[module_name]['source_path']
-                    )
-                    add_import_once = False
-                self._add_uuid_to_test(
-                    patcher, tests[module_name]['tests'][test_name],
-                    tests[module_name]['source_path'])
-        patcher.apply_patches()
-
-
-def run():
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--package', action='store', dest='package',
-                        default='tempest', type=str,
-                        help='Package with tests')
-    parser.add_argument('--fix', action='store_true', dest='fix_tests',
-                        help='Attempt to fix tests without UUIDs')
-    args = parser.parse_args()
-    sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-    pkg = importlib.import_module(args.package)
-    checker = TestChecker(pkg)
-    errors = False
-    tests = checker.get_tests()
-    untagged = checker.find_untagged(tests)
-    errors = checker.report_collisions(tests) or errors
-    if args.fix_tests and untagged:
-        checker.fix_tests(untagged)
-    else:
-        errors = checker.report_untagged(untagged) or errors
-    if errors:
-        sys.exit("@test.idempotent_id existence and uniqueness checks failed\n"
-                 "Run 'tox -v -euuidgen' to automatically fix tests with\n"
-                 "missing @test.idempotent_id decorators.")
-
-if __name__ == '__main__':
-    run()
diff --git a/tools/use_tempest_lib.sh b/tools/use_tempest_lib.sh
new file mode 100755
index 0000000..ca62c4a
--- /dev/null
+++ b/tools/use_tempest_lib.sh
@@ -0,0 +1,141 @@
+#!/bin/bash
+#
+# Use this script to use interfaces/files from tempest-lib.
+# Many files have been migrated to tempest-lib and tempest has
+# its own copy too.
+# This script helps to remove those from tempest and make use of tempest-lib.
+# It adds the change-id of each file on which they were migrated in lib.
+# This should only be done for files which were migrated to lib with
+# "Migrated" in commit message as done by tempest-lib/tools/migrate_from_tempest.sh script.
+# "Migrated" keyword is used to fetch the migration commit history from lib.
+# To use:
+#  1. Create a new branch in the tempest repo so not to destroy your current
+#     working branch
+#  2. Run the script from the repo dir and specify the file paths relative to
+#     the root tempest dir(only code and unit tests):
+#
+#   tools/use_tempest_lib.sh.sh tempest/file1.py tempest/file2.py
+
+
+function usage {
+    echo "Usage: $0 [OPTION] file1 file2 .."
+    echo "Use files from tempest-lib"
+    echo -e "Input files should be tempest files with path. \n  Example- tempest/file1.py tempest/file2.py .."
+    echo ""
+    echo "-s, --service_client Specify if files are service clients."
+    echo "-u, --tempest_lib_git_url Specify the repo to clone tempest-lib from."
+}
+
+function check_all_files_valid {
+    failed=0
+    for file in $files; do
+        # Get the latest change-id for each file
+        latest_commit_id=`git log -n1 -- $file | grep "^commit" | awk '{print $2}'`
+        cd $tmpdir
+        filename=`basename $file`
+        lib_path=`find ./ -name $filename`
+        if [ -z $lib_path ]; then
+            echo "ERROR: $filename does not exist in tempest-lib."
+            failed=$(( failed + 1))
+            cd - > /dev/null
+            continue
+        fi
+        # Get the CHANGE_ID of tempest-lib patch where file was migrated
+        migration_change_id=`git log  -n1 --grep "Migrated" -- $lib_path | grep "Change-Id: " | awk '{print $2}'`
+        MIGRATION_IDS=`echo -e "$MIGRATION_IDS\n * $filename: $migration_change_id"`
+        # Get tempest CHANGE_ID of file which was migrated to lib
+        migrated_change_id=`git log  -n1 --grep "Migrated" -- $lib_path | grep "* $filename"`
+        migrated_change_id=${migrated_change_id#*:}
+        cd - > /dev/null
+        # Get the commit-id of tempest which was migrated to tempest-lib
+        migrated_commit_id=`git log --grep "$migrated_change_id" -- $file | grep "^commit" | awk '{print $2}'`
+        DIFF=$(git diff $latest_commit_id $migrated_commit_id $file)
+        if [ "$DIFF" != "" ]; then
+            echo "ERROR: $filename in tempest has been updated after migration to tempest-lib. First sync the file to tempest-lib."
+            failed=$(( failed + 1))
+        fi
+    done
+    if [[ $failed -gt 0 ]]; then
+        echo "$failed files had issues"
+        exit $failed
+    fi
+}
+
+set -e
+
+service_client=0
+file_list=''
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        -h|--help) usage; exit;;
+        -u|--tempest_lib_git_url) tempest_lib_git_url="$2"; shift;;
+        -s|--service_client) service_client=1;;
+        *) files="$files $1";;
+    esac
+    shift
+done
+
+if [ -z "$files" ]; then
+    usage; exit
+fi
+
+TEMPEST_LIB_GIT_URL=${tempest_lib_git_url:-git://git.openstack.org/openstack/tempest-lib}
+
+tmpdir=$(mktemp -d -t use-tempest-lib.XXXX)
+
+# Clone tempest-lib
+git clone $TEMPEST_LIB_GIT_URL $tmpdir
+
+# Checks all provided files are present in lib and
+# not updated in tempest after migration to lib.
+check_all_files_valid
+
+for file in $files; do
+    rm -f $file
+    tempest_dir=`pwd`
+    tempest_dir="$tempest_dir/tempest/"
+    tempest_dirname=`dirname $file`
+    lib_dirname=`echo $tempest_dirname | sed s@tempest\/@tempest_lib/\@`
+    # Convert tempest dirname to import string
+    tempest_import="${tempest_dirname//\//.}"
+    tempest_import=${tempest_import:2:${#tempest_import}}
+    if [ $service_client -eq 1 ]; then
+        # Remove /json path because tempest-lib supports JSON only without XML
+        lib_dirname=`echo $lib_dirname | sed s@\/json@@`
+    fi
+    # Convert tempest-lib dirname to import string
+    tempest_lib_import="${lib_dirname//\//.}"
+    tempest_lib_import=${tempest_lib_import:2:${#tempest_lib_import}}
+    module_name=`basename $file .py`
+    tempest_import1="from $tempest_import.$module_name"
+    tempest_lib_import1="from $tempest_lib_import.$module_name"
+    tempest_import2="from $tempest_import import $module_name"
+    tempest_lib_import2="from $tempest_lib_import import $module_name"
+    set +e
+    grep -rl "$tempest_import1" $tempest_dir | xargs sed -i'' s/"$tempest_import1"/"$tempest_lib_import1"/g 2> /dev/null
+    grep -rl "$tempest_import2" $tempest_dir | xargs sed -i'' s/"$tempest_import2"/"$tempest_lib_import2"/g 2> /dev/null
+    set -e
+    if [[ -z "$file_list" ]]; then
+        file_list="$module_name"
+    else
+        tmp_file_list="$file_list, $module_name"
+        char_size=`echo $tmp_file_list | wc -c`
+        if [ $char_size -lt 27 ]; then
+            file_list="$file_list, $module_name"
+        fi
+    fi
+done
+
+rm -rf $tmpdir
+echo "Completed. Run pep8 and fix error if any"
+
+git add -A tempest/
+# Generate a migration commit
+commit_message="Use $file_list from tempest-lib"
+pre_list=$"The files below have been migrated to tempest-lib\n"
+pre_list=`echo -e $pre_list`
+post_list=$"Now Tempest-lib provides those as stable interfaces. So Tempest should\nstart using those from lib and remove its own copy."
+post_list=`echo -e $post_list`
+
+git commit -m "$commit_message" -m "$pre_list" -m "$MIGRATION_IDS" -m "$post_list"
diff --git a/tox.ini b/tox.ini
index ecd4f24..41eece1 100644
--- a/tox.ini
+++ b/tox.ini
@@ -114,11 +114,11 @@
 [testenv:pep8]
 commands =
    flake8 {posargs}
-   python tools/check_uuid.py
+   check-uuid
 
 [testenv:uuidgen]
 commands =
-   python tools/check_uuid.py --fix
+   check-uuid --fix
 
 [hacking]
 local-check-factory = tempest.hacking.checks.factory