diff --git a/tempest/api/identity/admin/v3/test_list_users.py b/tempest/api/identity/admin/v3/test_list_users.py
index ca91ce5..4921c00 100644
--- a/tempest/api/identity/admin/v3/test_list_users.py
+++ b/tempest/api/identity/admin/v3/test_list_users.py
@@ -42,13 +42,13 @@
         cls.domain_enabled_user = cls.client.create_user(
             u1_name, password=alt_password,
             email=cls.alt_email, domain_id=cls.data.domain['id'])['user']
-        cls.data.v3_users.append(cls.domain_enabled_user)
+        cls.data.users.append(cls.domain_enabled_user)
         # Create default not enabled user
         u2_name = data_utils.rand_name('test_user')
         cls.non_domain_enabled_user = cls.client.create_user(
             u2_name, password=alt_password,
             email=cls.alt_email, enabled=False)['user']
-        cls.data.v3_users.append(cls.non_domain_enabled_user)
+        cls.data.users.append(cls.non_domain_enabled_user)
 
     @test.idempotent_id('08f9aabb-dcfe-41d0-8172-82b5fa0bd73d')
     def test_list_user_domains(self):
@@ -79,7 +79,7 @@
         # List users
         body = self.client.list_users()['users']
         fetched_ids = [u['id'] for u in body]
-        missing_users = [u['id'] for u in self.data.v3_users
+        missing_users = [u['id'] for u in self.data.users
                          if u['id'] not in fetched_ids]
         self.assertEqual(0, len(missing_users),
                          "Failed to find user %s in fetched list" %
@@ -88,8 +88,8 @@
     @test.idempotent_id('b4baa3ae-ac00-4b4e-9e27-80deaad7771f')
     def test_get_user(self):
         # Get a user detail
-        user = self.client.show_user(self.data.v3_users[0]['id'])['user']
-        self.assertEqual(self.data.v3_users[0]['id'], user['id'])
-        self.assertEqual(self.data.v3_users[0]['name'], user['name'])
+        user = self.client.show_user(self.data.users[0]['id'])['user']
+        self.assertEqual(self.data.users[0]['id'], user['id'])
+        self.assertEqual(self.data.users[0]['name'], user['name'])
         self.assertEqual(self.alt_email, user['email'])
         self.assertEqual(self.data.domain['id'], user['domain_id'])
diff --git a/tempest/api/identity/admin/v3/test_roles.py b/tempest/api/identity/admin/v3/test_roles.py
index ae714aa..1c97f16 100644
--- a/tempest/api/identity/admin/v3/test_roles.py
+++ b/tempest/api/identity/admin/v3/test_roles.py
@@ -26,7 +26,7 @@
         for _ in range(3):
             role_name = data_utils.rand_name(name='role')
             role = cls.client.create_role(name=role_name)['role']
-            cls.data.v3_roles.append(role)
+            cls.data.roles.append(role)
         cls.fetched_role_ids = list()
         u_name = data_utils.rand_name('user')
         u_desc = '%s description' % u_name
@@ -175,5 +175,5 @@
     def test_list_roles(self):
         # Return a list of all roles
         body = self.client.list_roles()['roles']
-        found = [role for role in body if role in self.data.v3_roles]
-        self.assertEqual(len(found), len(self.data.v3_roles))
+        found = [role for role in body if role in self.data.roles]
+        self.assertEqual(len(found), len(self.data.roles))
diff --git a/tempest/api/identity/admin/v3/test_users.py b/tempest/api/identity/admin/v3/test_users.py
index a402b3f..894a7a9 100644
--- a/tempest/api/identity/admin/v3/test_users.py
+++ b/tempest/api/identity/admin/v3/test_users.py
@@ -151,6 +151,6 @@
     @test.idempotent_id('c10dcd90-461d-4b16-8e23-4eb836c00644')
     def test_get_user(self):
         # Get a user detail
-        self.data.setup_test_v3_user()
-        user = self.client.show_user(self.data.v3_user['id'])['user']
-        self.assertEqual(self.data.v3_user['id'], user['id'])
+        self.data.setup_test_user()
+        user = self.client.show_user(self.data.user['id'])['user']
+        self.assertEqual(self.data.user['id'], user['id'])
diff --git a/tempest/api/identity/admin/v3/test_users_negative.py b/tempest/api/identity/admin/v3/test_users_negative.py
index 4c80bda..b2fb6e0 100644
--- a/tempest/api/identity/admin/v3/test_users_negative.py
+++ b/tempest/api/identity/admin/v3/test_users_negative.py
@@ -38,7 +38,7 @@
     @test.idempotent_id('b3c9fccc-4134-46f5-b600-1da6fb0a3b1f')
     def test_authentication_for_disabled_user(self):
         # Attempt to authenticate for disabled user should fail
-        self.data.setup_test_v3_user()
+        self.data.setup_test_user()
         self.disable_user(self.data.test_user)
         self.assertRaises(lib_exc.Unauthorized, self.token.auth,
                           username=self.data.test_user,
diff --git a/tempest/api/identity/base.py b/tempest/api/identity/base.py
index e317ed0..028e9f2 100644
--- a/tempest/api/identity/base.py
+++ b/tempest/api/identity/base.py
@@ -16,7 +16,6 @@
 from oslo_log import log as logging
 from tempest_lib import exceptions as lib_exc
 
-from tempest.common import credentials_factory as common_creds
 from tempest.common.utils import data_utils
 from tempest import config
 import tempest.test
@@ -109,8 +108,8 @@
     @classmethod
     def resource_setup(cls):
         super(BaseIdentityV2AdminTest, cls).resource_setup()
-        cls.data = DataGenerator(cls.client, cls.tenants_client,
-                                 cls.roles_client, cls.users_client)
+        cls.data = DataGeneratorV2(cls.client, cls.tenants_client,
+                                   cls.users_client, cls.roles_client)
 
     @classmethod
     def resource_cleanup(cls):
@@ -153,7 +152,10 @@
         cls.creds_client = cls.os_adm.credentials_client
         cls.groups_client = cls.os_adm.groups_client
 
-        cls.data = DataGenerator(cls.client)
+    @classmethod
+    def resource_setup(cls):
+        super(BaseIdentityV3AdminTest, cls).resource_setup()
+        cls.data = DataGeneratorV3(cls.client)
 
     @classmethod
     def resource_cleanup(cls):
@@ -193,127 +195,107 @@
         self.client.delete_domain(domain_id)
 
 
-class DataGenerator(object):
+class BaseDataGenerator(object):
 
-        def __init__(self, client, tenants_client=None, roles_client=None,
-                     users_client=None):
-            self.client = client
-            # TODO(dmellado) split Datagenerator for v2 and v3
-            self.tenants_client = tenants_client
-            self.roles_client = roles_client
-            self.users_client = users_client
-            self.users = []
-            self.tenants = []
-            self.roles = []
-            self.role_name = None
-            self.v3_users = []
-            self.projects = []
-            self.v3_roles = []
-            self.domains = []
+    def __init__(self, client, projects_client=None,
+                 users_client=None, roles_client=None):
+        self.client = client
+        self.projects_client = projects_client or client
+        self.users_client = users_client or client
+        self.roles_client = roles_client or client
 
-        @property
-        def test_credentials(self):
-            return common_creds.get_credentials(username=self.test_user,
-                                                user_id=self.user['id'],
-                                                password=self.test_password,
-                                                tenant_name=self.test_tenant,
-                                                tenant_id=self.tenant['id'])
+        self.test_user = ''
+        self.test_password = ''
+        self.test_tenant = ''
+        self.test_project = ''
+        self.test_role = ''
+        self.test_email = ''
 
-        def setup_test_user(self):
-            """Set up a test user."""
-            self.setup_test_tenant()
-            self.test_user = data_utils.rand_name('test_user')
-            self.test_password = data_utils.rand_password()
-            self.test_email = self.test_user + '@testmail.tm'
-            self.user = self.users_client.create_user(self.test_user,
-                                                      self.test_password,
-                                                      self.tenant['id'],
-                                                      self.test_email)['user']
-            self.users.append(self.user)
+        self.user = None
+        self.tenant = None
+        self.project = None
+        self.role = None
+        self.domain = None
 
-        def setup_test_tenant(self):
-            """Set up a test tenant."""
-            self.test_tenant = data_utils.rand_name('test_tenant')
-            self.test_description = data_utils.rand_name('desc')
-            self.tenant = self.tenants_client.create_tenant(
-                name=self.test_tenant,
-                description=self.test_description)['tenant']
-            self.tenants.append(self.tenant)
+        self.users = []
+        self.tenants = []
+        self.projects = []
+        self.roles = []
+        self.domains = []
 
-        def setup_test_role(self):
-            """Set up a test role."""
-            self.test_role = data_utils.rand_name('role')
-            self.role = self.roles_client.create_role(
-                name=self.test_role)['role']
-            self.roles.append(self.role)
+    def _create_test_user(self, **kwargs):
+        self.test_user = data_utils.rand_name('test_user')
+        self.test_password = data_utils.rand_password()
+        self.test_email = self.test_user + '@testmail.tm'
+        self.user = self.users_client.create_user(
+            self.test_user, password=self.test_password,
+            email=self.test_email, **kwargs)['user']
+        self.users.append(self.user)
 
-        def setup_test_v3_user(self):
-            """Set up a test v3 user."""
-            self.setup_test_project()
-            self.test_user = data_utils.rand_name('test_user')
-            self.test_password = data_utils.rand_password()
-            self.test_email = self.test_user + '@testmail.tm'
-            self.v3_user = self.client.create_user(
-                self.test_user,
-                password=self.test_password,
-                project_id=self.project['id'],
-                email=self.test_email)['user']
-            self.v3_users.append(self.v3_user)
+    def setup_test_role(self):
+        """Set up a test role."""
+        self.test_role = data_utils.rand_name('role')
+        self.role = self.roles_client.create_role(name=self.test_role)['role']
+        self.roles.append(self.role)
 
-        def setup_test_project(self):
-            """Set up a test project."""
-            self.test_project = data_utils.rand_name('test_project')
-            self.test_description = data_utils.rand_name('desc')
-            self.project = self.client.create_project(
-                name=self.test_project,
-                description=self.test_description)['project']
-            self.projects.append(self.project)
+    @staticmethod
+    def _try_wrapper(func, item, **kwargs):
+        try:
+            func(item['id'], **kwargs)
+        except lib_exc.NotFound:
+            pass
+        except Exception:
+            LOG.exception("Unexpected exception occurred in %s deletion. "
+                          "But ignored here." % item['id'])
 
-        def setup_test_v3_role(self):
-            """Set up a test v3 role."""
-            self.test_role = data_utils.rand_name('role')
-            self.v3_role = self.client.create_role(name=self.test_role)['role']
-            self.v3_roles.append(self.v3_role)
+    def teardown_all(self):
+        for user in self.users:
+            self._try_wrapper(self.users_client.delete_user, user)
+        for tenant in self.tenants:
+            self._try_wrapper(self.projects_client.delete_tenant, tenant)
+        for project in self.projects:
+            self._try_wrapper(self.projects_client.delete_project, project)
+        for role in self.roles:
+            self._try_wrapper(self.roles_client.delete_role, role)
+        for domain in self.domains:
+            self._try_wrapper(self.client.update_domain, domain, enabled=False)
+            self._try_wrapper(self.client.delete_domain, domain)
 
-        def setup_test_domain(self):
-            """Set up a test domain."""
-            self.test_domain = data_utils.rand_name('test_domain')
-            self.test_description = data_utils.rand_name('desc')
-            self.domain = self.client.create_domain(
-                name=self.test_domain,
-                description=self.test_description)['domain']
-            self.domains.append(self.domain)
 
-        @staticmethod
-        def _try_wrapper(func, item, **kwargs):
-            try:
-                if kwargs:
-                    func(item['id'], **kwargs)
-                else:
-                    func(item['id'])
-            except lib_exc.NotFound:
-                pass
-            except Exception:
-                LOG.exception("Unexpected exception occurred in %s deletion."
-                              " But ignored here." % item['id'])
+class DataGeneratorV2(BaseDataGenerator):
 
-        def teardown_all(self):
-            # NOTE(masayukig): v3 client doesn't have v2 method.
-            # (e.g. delete_tenant) So we need to check resources existence
-            # before using client methods.
-            for user in self.users:
-                self._try_wrapper(self.users_client.delete_user, user)
-            for tenant in self.tenants:
-                self._try_wrapper(self.tenants_client.delete_tenant, tenant)
-            for role in self.roles:
-                self._try_wrapper(self.roles_client.delete_role, role)
-            for v3_user in self.v3_users:
-                self._try_wrapper(self.client.delete_user, v3_user)
-            for v3_project in self.projects:
-                self._try_wrapper(self.client.delete_project, v3_project)
-            for v3_role in self.v3_roles:
-                self._try_wrapper(self.client.delete_role, v3_role)
-            for domain in self.domains:
-                self._try_wrapper(self.client.update_domain, domain,
-                                  enabled=False)
-                self._try_wrapper(self.client.delete_domain, domain)
+    def setup_test_user(self):
+        """Set up a test user."""
+        self.setup_test_tenant()
+        self._create_test_user(tenant_id=self.tenant['id'])
+
+    def setup_test_tenant(self):
+        """Set up a test tenant."""
+        self.test_tenant = data_utils.rand_name('test_tenant')
+        self.tenant = self.projects_client.create_tenant(
+            name=self.test_tenant,
+            description=data_utils.rand_name('desc'))['tenant']
+        self.tenants.append(self.tenant)
+
+
+class DataGeneratorV3(BaseDataGenerator):
+
+    def setup_test_user(self):
+        """Set up a test user."""
+        self.setup_test_project()
+        self._create_test_user(project_id=self.project['id'])
+
+    def setup_test_project(self):
+        """Set up a test project."""
+        self.test_project = data_utils.rand_name('test_project')
+        self.project = self.projects_client.create_project(
+            name=self.test_project,
+            description=data_utils.rand_name('desc'))['project']
+        self.projects.append(self.project)
+
+    def setup_test_domain(self):
+        """Set up a test domain."""
+        self.domain = self.client.create_domain(
+            name=data_utils.rand_name('test_domain'),
+            description=data_utils.rand_name('desc'))['domain']
+        self.domains.append(self.domain)
diff --git a/tempest/api/orchestration/stacks/test_neutron_resources.py b/tempest/api/orchestration/stacks/test_neutron_resources.py
index 8466e11..09e863e 100644
--- a/tempest/api/orchestration/stacks/test_neutron_resources.py
+++ b/tempest/api/orchestration/stacks/test_neutron_resources.py
@@ -16,7 +16,6 @@
 import netaddr
 
 from tempest.api.orchestration import base
-from tempest.common import credentials_factory as credentials
 from tempest.common.utils import data_utils
 from tempest import config
 from tempest import exceptions
@@ -37,8 +36,8 @@
 
     @classmethod
     def setup_credentials(cls):
+        cls.set_network_resources()
         super(NeutronResourcesTestJSON, cls).setup_credentials()
-        cls.os = credentials.ConfiguredUserManager()
 
     @classmethod
     def setup_clients(cls):
diff --git a/tempest/common/api_version_utils.py b/tempest/common/api_version_utils.py
index ac3322e..98601a7 100644
--- a/tempest/common/api_version_utils.py
+++ b/tempest/common/api_version_utils.py
@@ -69,3 +69,27 @@
     cfg_version = api_version_request.APIVersionRequest(cfg_min_version)
     max_version = cfg_version if cfg_version >= test_version else test_version
     return max_version.get_string()
+
+
+def assert_version_header_matches_request(api_microversion_header_name,
+                                          api_microversion,
+                                          response_header):
+    """Checks API microversion in resposne header
+
+    Verify whether microversion is present in response header
+    and with specified 'api_microversion' value.
+
+    @param: api_microversion_header_name: Microversion header name
+            Example- "X-OpenStack-Nova-API-Version"
+    @param: api_microversion: Microversion number like "2.10"
+    @param: response_header: Response header where microversion is
+            expected to be present.
+    """
+    api_microversion_header_name = api_microversion_header_name.lower()
+    if (api_microversion_header_name not in response_header or
+        api_microversion != response_header[api_microversion_header_name]):
+        msg = ("Microversion header '%s' with value '%s' does not match in "
+               "response - %s. " % (api_microversion_header_name,
+                                    api_microversion,
+                                    response_header))
+        raise exceptions.InvalidHTTPResponseHeader(msg)
diff --git a/tempest/scenario/manager.py b/tempest/scenario/manager.py
index f4e2185..6776220 100644
--- a/tempest/scenario/manager.py
+++ b/tempest/scenario/manager.py
@@ -1115,12 +1115,6 @@
 
         return rules
 
-    def _ssh_to_server(self, server, private_key):
-        ssh_login = CONF.validation.image_ssh_user
-        return self.get_remote_client(server,
-                                      username=ssh_login,
-                                      private_key=private_key)
-
     def _get_router(self, client=None, tenant_id=None):
         """Retrieve a router for the given tenant id.
 
diff --git a/tempest/scenario/test_aggregates_basic_ops.py b/tempest/scenario/test_aggregates_basic_ops.py
index 97a755d..cace90b 100644
--- a/tempest/scenario/test_aggregates_basic_ops.py
+++ b/tempest/scenario/test_aggregates_basic_ops.py
@@ -43,16 +43,14 @@
     def _create_aggregate(self, **kwargs):
         aggregate = (self.aggregates_client.create_aggregate(**kwargs)
                      ['aggregate'])
-        self.addCleanup(self._delete_aggregate, aggregate)
+        self.addCleanup(self.aggregates_client.delete_aggregate,
+                        aggregate['id'])
         aggregate_name = kwargs['name']
         availability_zone = kwargs['availability_zone']
         self.assertEqual(aggregate['name'], aggregate_name)
         self.assertEqual(aggregate['availability_zone'], availability_zone)
         return aggregate
 
-    def _delete_aggregate(self, aggregate):
-        self.aggregates_client.delete_aggregate(aggregate['id'])
-
     def _get_host_name(self):
         hosts = self.hosts_client.list_hosts()['hosts']
         self.assertTrue(len(hosts) >= 1)
diff --git a/tempest/scenario/test_minimum_basic.py b/tempest/scenario/test_minimum_basic.py
index d9c6924..f7c7434 100644
--- a/tempest/scenario/test_minimum_basic.py
+++ b/tempest/scenario/test_minimum_basic.py
@@ -62,12 +62,6 @@
             server, custom_matchers.MatchesDictExceptForKeys(
                 got_server, excluded_keys=excluded_keys))
 
-    def cinder_create(self):
-        return self.create_volume()
-
-    def cinder_list(self):
-        return self.volumes_client.list_volumes()['volumes']
-
     def cinder_show(self, volume):
         got_volume = self.volumes_client.show_volume(volume['id'])['volume']
         self.assertEqual(volume, got_volume)
@@ -115,8 +109,8 @@
 
         self.nova_show(server)
 
-        volume = self.cinder_create()
-        volumes = self.cinder_list()
+        volume = self.create_volume()
+        volumes = self.volumes_client.list_volumes()['volumes']
         self.assertIn(volume['id'], [x['id'] for x in volumes])
 
         self.cinder_show(volume)
diff --git a/tempest/scenario/test_network_basic_ops.py b/tempest/scenario/test_network_basic_ops.py
index 349ef11..79a5099 100644
--- a/tempest/scenario/test_network_basic_ops.py
+++ b/tempest/scenario/test_network_basic_ops.py
@@ -240,8 +240,8 @@
         old_floating_ip, server = self.floating_ip_tuple
         ip_address = old_floating_ip.floating_ip_address
         private_key = self._get_server_key(server)
-        ssh_client = self.get_remote_client(ip_address,
-                                            private_key=private_key)
+        ssh_client = self.get_remote_client(
+            ip_address, private_key=private_key)
         old_nic_list = self._get_server_nics(ssh_client)
         # get a port from a list of one item
         port_list = self._list_ports(device_id=server['id'])
@@ -336,7 +336,8 @@
                                    should_connect=True):
         ip_address = floating_ip.floating_ip_address
         private_key = self._get_server_key(self.floating_ip_tuple.server)
-        ssh_source = self._ssh_to_server(ip_address, private_key)
+        ssh_source = self.get_remote_client(
+            ip_address, private_key=private_key)
 
         for remote_ip in address_list:
             if should_connect:
@@ -553,7 +554,8 @@
         floating_ip, server = self.floating_ip_tuple
         ip_address = floating_ip.floating_ip_address
         private_key = self._get_server_key(server)
-        ssh_client = self._ssh_to_server(ip_address, private_key)
+        ssh_client = self.get_remote_client(
+            ip_address, private_key=private_key)
 
         dns_servers = [initial_dns_server]
         servers = ssh_client.get_dns_servers()
diff --git a/tempest/scenario/test_security_groups_basic_ops.py b/tempest/scenario/test_security_groups_basic_ops.py
index 1bf4089..18bd764 100644
--- a/tempest/scenario/test_security_groups_basic_ops.py
+++ b/tempest/scenario/test_security_groups_basic_ops.py
@@ -321,8 +321,8 @@
         access_point_ssh = \
             self.floating_ips[tenant.access_point['id']].floating_ip_address
         private_key = tenant.keypair['private_key']
-        access_point_ssh = self._ssh_to_server(access_point_ssh,
-                                               private_key=private_key)
+        access_point_ssh = self.get_remote_client(
+            access_point_ssh, private_key=private_key)
         return access_point_ssh
 
     def _check_connectivity(self, access_point, ip, should_succeed=True):
diff --git a/tempest/scenario/test_server_basic_ops.py b/tempest/scenario/test_server_basic_ops.py
index 239e120..6c24d04 100644
--- a/tempest/scenario/test_server_basic_ops.py
+++ b/tempest/scenario/test_server_basic_ops.py
@@ -69,10 +69,7 @@
                       image=self.image_ref, flavor=self.flavor_ref,
                       ssh=self.run_ssh, ssh_user=self.ssh_user))
 
-    def add_keypair(self):
-        self.keypair = self.create_keypair()
-
-    def verify_ssh(self):
+    def verify_ssh(self, keypair):
         if self.run_ssh:
             # Obtain a floating IP
             self.fip = self.create_floating_ip(self.instance)['ip']
@@ -80,7 +77,7 @@
             self.ssh_client = self.get_remote_client(
                 server_or_ip=self.fip,
                 username=self.image_utils.ssh_user(self.image_ref),
-                private_key=self.keypair['private_key'])
+                private_key=keypair['private_key'])
 
     def verify_metadata(self):
         if self.run_ssh and CONF.compute_feature_enabled.metadata_service:
@@ -123,19 +120,19 @@
     @test.attr(type='smoke')
     @test.services('compute', 'network')
     def test_server_basicops(self):
-        self.add_keypair()
+        keypair = self.create_keypair()
         self.security_group = self._create_security_group()
         security_groups = [{'name': self.security_group['name']}]
         self.md = {'meta1': 'data1', 'meta2': 'data2', 'metaN': 'dataN'}
         self.instance = self.create_server(
             image_id=self.image_ref,
             flavor=self.flavor_ref,
-            key_name=self.keypair['name'],
+            key_name=keypair['name'],
             security_groups=security_groups,
             config_drive=CONF.compute_feature_enabled.config_drive,
             metadata=self.md,
             wait_until='ACTIVE')
-        self.verify_ssh()
+        self.verify_ssh(keypair)
         self.verify_metadata()
         self.verify_metadata_on_config_drive()
         self.servers_client.delete_server(self.instance['id'])
diff --git a/tempest/scenario/test_stamp_pattern.py b/tempest/scenario/test_stamp_pattern.py
index 8183ce3..f88fb14 100644
--- a/tempest/scenario/test_stamp_pattern.py
+++ b/tempest/scenario/test_stamp_pattern.py
@@ -60,10 +60,6 @@
         if not CONF.volume_feature_enabled.snapshot:
             raise cls.skipException("Cinder volume snapshots are disabled")
 
-    def _wait_for_volume_snapshot_status(self, volume_snapshot, status):
-        self.snapshots_client.wait_for_snapshot_status(volume_snapshot['id'],
-                                                       status)
-
     def _create_volume_snapshot(self, volume):
         snapshot_name = data_utils.rand_name('scenario-snapshot')
         snapshot = self.snapshots_client.create_snapshot(
@@ -78,29 +74,12 @@
             except lib_exc.NotFound:
                 pass
         self.addCleanup(cleaner)
-        self._wait_for_volume_status(volume, 'available')
+        self.volumes_client.wait_for_volume_status(volume['id'], 'available')
         self.snapshots_client.wait_for_snapshot_status(snapshot['id'],
                                                        'available')
         self.assertEqual(snapshot_name, snapshot['display_name'])
         return snapshot
 
-    def _wait_for_volume_status(self, volume, status):
-        self.volumes_client.wait_for_volume_status(volume['id'], status)
-
-    def _create_volume(self, snapshot_id=None):
-        return self.create_volume(snapshot_id=snapshot_id)
-
-    def _attach_volume(self, server, volume):
-        attached_volume = self.servers_client.attach_volume(
-            server['id'], volumeId=volume['id'], device='/dev/%s'
-            % CONF.compute.volume_device_name)['volumeAttachment']
-        self.assertEqual(volume['id'], attached_volume['id'])
-        self._wait_for_volume_status(attached_volume, 'in-use')
-
-    def _detach_volume(self, server, volume):
-        self.servers_client.detach_volume(server['id'], volume['id'])
-        self._wait_for_volume_status(volume, 'available')
-
     def _wait_for_volume_available_on_the_system(self, server_or_ip,
                                                  private_key):
         ssh = self.get_remote_client(server_or_ip, private_key=private_key)
@@ -126,7 +105,7 @@
         security_group = self._create_security_group()
 
         # boot an instance and create a timestamp file in it
-        volume = self._create_volume()
+        volume = self.create_volume()
         server = self.create_server(
             image_id=CONF.compute.image_ref,
             key_name=keypair['name'],
@@ -136,13 +115,13 @@
         # create and add floating IP to server1
         ip_for_server = self.get_server_or_ip(server)
 
-        self._attach_volume(server, volume)
+        self.nova_volume_attach(server, volume)
         self._wait_for_volume_available_on_the_system(ip_for_server,
                                                       keypair['private_key'])
         timestamp = self.create_timestamp(ip_for_server,
                                           CONF.compute.volume_device_name,
                                           private_key=keypair['private_key'])
-        self._detach_volume(server, volume)
+        self.nova_volume_detach(server, volume)
 
         # snapshot the volume
         volume_snapshot = self._create_volume_snapshot(volume)
@@ -151,7 +130,7 @@
         snapshot_image = self.create_server_snapshot(server=server)
 
         # create second volume from the snapshot(volume2)
-        volume_from_snapshot = self._create_volume(
+        volume_from_snapshot = self.create_volume(
             snapshot_id=volume_snapshot['id'])
 
         # boot second instance from the snapshot(instance2)
@@ -164,7 +143,7 @@
         ip_for_snapshot = self.get_server_or_ip(server_from_snapshot)
 
         # attach volume2 to instance2
-        self._attach_volume(server_from_snapshot, volume_from_snapshot)
+        self.nova_volume_attach(server_from_snapshot, volume_from_snapshot)
         self._wait_for_volume_available_on_the_system(ip_for_snapshot,
                                                       keypair['private_key'])
 
diff --git a/tempest/services/base_microversion_client.py b/tempest/services/base_microversion_client.py
new file mode 100644
index 0000000..4c750f5
--- /dev/null
+++ b/tempest/services/base_microversion_client.py
@@ -0,0 +1,54 @@
+# Copyright 2016 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 tempest_lib.common import rest_client
+
+
+class BaseMicroversionClient(rest_client.RestClient):
+    """Base class to support microversion in service clients
+
+    This class is used to support microversion in service clients.
+    This provides feature to make API request with microversion.
+    Service clients derived from this class will be able to send API
+    request to server with or without microversion.
+    If api_microversion is not set on service client then API request will be
+    normal request without microversion.
+
+    """
+    def __init__(self, auth_provider, service, region,
+                 api_microversion_header_name, **kwargs):
+        """Base Microversion Client __init__
+
+        :param auth_provider: an auth provider object used to wrap requests in
+                              auth
+        :param str service: The service name to use for the catalog lookup
+        :param str region: The region to use for the catalog lookup
+        :param str api_microversion_header_name: The microversion header name
+                                                 to use for sending API
+                                                 request with microversion
+        :param kwargs: kwargs required by rest_client.RestClient
+        """
+        super(BaseMicroversionClient, self).__init__(
+            auth_provider, service, region, **kwargs)
+        self.api_microversion_header_name = api_microversion_header_name
+        self.api_microversion = None
+
+    def get_headers(self):
+        headers = super(BaseMicroversionClient, self).get_headers()
+        if self.api_microversion:
+            headers[self.api_microversion_header_name] = self.api_microversion
+        return headers
+
+    def set_api_microversion(self, microversion):
+        self.api_microversion = microversion
diff --git a/tempest/services/compute/json/base.py b/tempest/services/compute/json/base_compute_client.py
similarity index 69%
rename from tempest/services/compute/json/base.py
rename to tempest/services/compute/json/base_compute_client.py
index 40d3056..5349af6 100644
--- a/tempest/services/compute/json/base.py
+++ b/tempest/services/compute/json/base_compute_client.py
@@ -12,23 +12,31 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from tempest_lib.common import rest_client
-
 from tempest.common import api_version_request
+from tempest.common import api_version_utils
 from tempest import exceptions
+from tempest.services import base_microversion_client
 
 
-class BaseComputeClient(rest_client.RestClient):
-    api_microversion = None
+class BaseComputeClient(base_microversion_client.BaseMicroversionClient):
 
-    def get_headers(self):
-        headers = super(BaseComputeClient, self).get_headers()
-        if self.api_microversion:
-            headers['X-OpenStack-Nova-API-Version'] = self.api_microversion
-        return headers
+    def __init__(self, auth_provider, service, region,
+                 api_microversion_header_name='X-OpenStack-Nova-API-Version',
+                 **kwargs):
+        super(BaseComputeClient, self).__init__(
+            auth_provider, service, region,
+            api_microversion_header_name, **kwargs)
 
-    def set_api_microversion(self, microversion):
-        self.api_microversion = microversion
+    def request(self, method, url, extra_headers=False, headers=None,
+                body=None):
+        resp, resp_body = super(BaseComputeClient, self).request(
+            method, url, extra_headers, headers, body)
+        if self.api_microversion and self.api_microversion != 'latest':
+            api_version_utils.assert_version_header_matches_request(
+                self.api_microversion_header_name,
+                self.api_microversion,
+                resp)
+        return resp, resp_body
 
     def get_schema(self, schema_versions_info):
         """Get JSON schema
diff --git a/tempest/services/compute/json/keypairs_client.py b/tempest/services/compute/json/keypairs_client.py
index e956100..ec9b1e0 100644
--- a/tempest/services/compute/json/keypairs_client.py
+++ b/tempest/services/compute/json/keypairs_client.py
@@ -18,10 +18,10 @@
 from tempest.api_schema.response.compute.v2_1 import keypairs as schemav21
 from tempest.api_schema.response.compute.v2_2 import keypairs as schemav22
 from tempest.common import service_client
-from tempest.services.compute.json import base
+from tempest.services.compute.json import base_compute_client
 
 
-class KeyPairsClient(base.BaseComputeClient):
+class KeyPairsClient(base_compute_client.BaseComputeClient):
 
     schema_versions_info = [{'min': None, 'max': '2.1', 'schema': schemav21},
                             {'min': '2.2', 'max': None, 'schema': schemav22}]
diff --git a/tempest/tests/common/test_api_version_utils.py b/tempest/tests/common/test_api_version_utils.py
index 9f399a2..babf965 100644
--- a/tempest/tests/common/test_api_version_utils.py
+++ b/tempest/tests/common/test_api_version_utils.py
@@ -219,3 +219,31 @@
 
     def test_both_min_version_equal(self):
         self._test_request_version('2.3', '2.3', expected_version='2.3')
+
+
+class TestMicroversionHeaderMatches(base.TestCase):
+
+    def test_header_matches(self):
+        microversion_header_name = 'x-openstack-xyz-api-version'
+        request_microversion = '2.1'
+        test_respose = {microversion_header_name: request_microversion}
+        api_version_utils.assert_version_header_matches_request(
+            microversion_header_name, request_microversion, test_respose)
+
+    def test_header_does_not_match(self):
+        microversion_header_name = 'x-openstack-xyz-api-version'
+        request_microversion = '2.1'
+        test_respose = {microversion_header_name: '2.2'}
+        self.assertRaises(
+            exceptions.InvalidHTTPResponseHeader,
+            api_version_utils.assert_version_header_matches_request,
+            microversion_header_name, request_microversion, test_respose)
+
+    def test_header_not_present(self):
+        microversion_header_name = 'x-openstack-xyz-api-version'
+        request_microversion = '2.1'
+        test_respose = {}
+        self.assertRaises(
+            exceptions.InvalidHTTPResponseHeader,
+            api_version_utils.assert_version_header_matches_request,
+            microversion_header_name, request_microversion, test_respose)
diff --git a/tempest/tests/services/compute/test_base_compute_client.py b/tempest/tests/services/compute/test_base_compute_client.py
index 134fe39..7a55cdb 100644
--- a/tempest/tests/services/compute/test_base_compute_client.py
+++ b/tempest/tests/services/compute/test_base_compute_client.py
@@ -13,64 +13,48 @@
 #    under the License.
 
 import httplib2
-import mock
+from oslotest import mockpatch
 from tempest_lib.common import rest_client
 
 from tempest import exceptions
-from tempest.services.compute.json import base as base_compute_client
+from tempest.services.compute.json import base_compute_client
 from tempest.tests import fake_auth_provider
 from tempest.tests.services.compute import base
 
 
-class TestClientWithoutMicroversionHeader(base.BaseComputeServiceTest):
+class TestMicroversionHeaderCheck(base.BaseComputeServiceTest):
 
     def setUp(self):
-        super(TestClientWithoutMicroversionHeader, self).setUp()
+        super(TestMicroversionHeaderCheck, self).setUp()
         fake_auth = fake_auth_provider.FakeAuthProvider()
         self.client = base_compute_client.BaseComputeClient(
             fake_auth, 'compute', 'regionOne')
+        self.client.set_api_microversion('2.2')
 
-    def test_no_microverion_header(self):
-        header = self.client.get_headers()
-        self.assertNotIn('X-OpenStack-Nova-API-Version', header)
+    def _check_microverion_header_in_response(self, fake_response):
+        def request(*args, **kwargs):
+            return (httplib2.Response(fake_response), {})
 
-    def test_no_microverion_header_in_raw_request(self):
-        def raw_request(*args, **kwargs):
-            self.assertNotIn('X-OpenStack-Nova-API-Version', kwargs['headers'])
-            return (httplib2.Response({'status': 200}), {})
+        self.useFixture(mockpatch.PatchObject(
+            rest_client.RestClient,
+            'request',
+            side_effect=request))
 
-        with mock.patch.object(rest_client.RestClient,
-                               'raw_request') as mock_get:
-            mock_get.side_effect = raw_request
-            self.client.get('fake_url')
+    def test_correct_microverion_in_response(self):
+        fake_response = {self.client.api_microversion_header_name: '2.2'}
+        self._check_microverion_header_in_response(fake_response)
+        self.client.get('fake_url')
 
+    def test_incorrect_microverion_in_response(self):
+        fake_response = {self.client.api_microversion_header_name: '2.3'}
+        self._check_microverion_header_in_response(fake_response)
+        self.assertRaises(exceptions.InvalidHTTPResponseHeader,
+                          self.client.get, 'fake_url')
 
-class TestClientWithMicroversionHeader(base.BaseComputeServiceTest):
-
-    def setUp(self):
-        super(TestClientWithMicroversionHeader, self).setUp()
-        fake_auth = fake_auth_provider.FakeAuthProvider()
-        self.client = base_compute_client.BaseComputeClient(
-            fake_auth, 'compute', 'regionOne')
-        self.client.api_microversion = '2.2'
-
-    def test_microverion_header(self):
-        header = self.client.get_headers()
-        self.assertIn('X-OpenStack-Nova-API-Version', header)
-        self.assertEqual(self.client.api_microversion,
-                         header['X-OpenStack-Nova-API-Version'])
-
-    def test_microverion_header_in_raw_request(self):
-        def raw_request(*args, **kwargs):
-            self.assertIn('X-OpenStack-Nova-API-Version', kwargs['headers'])
-            self.assertEqual(self.client.api_microversion,
-                             kwargs['headers']['X-OpenStack-Nova-API-Version'])
-            return (httplib2.Response({'status': 200}), {})
-
-        with mock.patch.object(rest_client.RestClient,
-                               'raw_request') as mock_get:
-            mock_get.side_effect = raw_request
-            self.client.get('fake_url')
+    def test_no_microverion_header_in_response(self):
+        self._check_microverion_header_in_response({})
+        self.assertRaises(exceptions.InvalidHTTPResponseHeader,
+                          self.client.get, 'fake_url')
 
 
 class DummyServiceClient1(base_compute_client.BaseComputeClient):
diff --git a/tempest/tests/services/test_base_microversion_client.py b/tempest/tests/services/test_base_microversion_client.py
new file mode 100644
index 0000000..11b8170
--- /dev/null
+++ b/tempest/tests/services/test_base_microversion_client.py
@@ -0,0 +1,75 @@
+# Copyright 2016 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 httplib2
+import mock
+from tempest_lib.common import rest_client
+
+from tempest.services import base_microversion_client
+from tempest.tests import fake_auth_provider
+from tempest.tests.services.compute import base
+
+
+class TestClientWithoutMicroversionHeader(base.BaseComputeServiceTest):
+
+    def setUp(self):
+        super(TestClientWithoutMicroversionHeader, self).setUp()
+        fake_auth = fake_auth_provider.FakeAuthProvider()
+        self.client = base_microversion_client.BaseMicroversionClient(
+            fake_auth, 'compute', 'regionOne', 'X-OpenStack-Nova-API-Version')
+
+    def test_no_microverion_header(self):
+        header = self.client.get_headers()
+        self.assertNotIn(self.client.api_microversion_header_name, header)
+
+    def test_no_microverion_header_in_raw_request(self):
+        def raw_request(*args, **kwargs):
+            self.assertNotIn(self.client.api_microversion_header_name,
+                             kwargs['headers'])
+            return (httplib2.Response({'status': 200}), {})
+
+        with mock.patch.object(rest_client.RestClient,
+                               'raw_request') as mock_get:
+            mock_get.side_effect = raw_request
+            self.client.get('fake_url')
+
+
+class TestClientWithMicroversionHeader(base.BaseComputeServiceTest):
+
+    def setUp(self):
+        super(TestClientWithMicroversionHeader, self).setUp()
+        fake_auth = fake_auth_provider.FakeAuthProvider()
+        self.client = base_microversion_client.BaseMicroversionClient(
+            fake_auth, 'compute', 'regionOne', 'X-OpenStack-Nova-API-Version')
+        self.client.set_api_microversion('2.2')
+
+    def test_microverion_header(self):
+        header = self.client.get_headers()
+        self.assertIn(self.client.api_microversion_header_name, header)
+        self.assertEqual(self.client.api_microversion,
+                         header[self.client.api_microversion_header_name])
+
+    def test_microverion_header_in_raw_request(self):
+        def raw_request(*args, **kwargs):
+            self.assertIn(self.client.api_microversion_header_name,
+                          kwargs['headers'])
+            self.assertEqual(
+                self.client.api_microversion,
+                kwargs['headers'][self.client.api_microversion_header_name])
+            return (httplib2.Response({'status': 200}), {})
+
+        with mock.patch.object(rest_client.RestClient,
+                               'raw_request') as mock_get:
+            mock_get.side_effect = raw_request
+            self.client.get('fake_url')