diff --git a/manila_tempest_tests/config.py b/manila_tempest_tests/config.py
index fb85fe3..ad64b4b 100644
--- a/manila_tempest_tests/config.py
+++ b/manila_tempest_tests/config.py
@@ -36,7 +36,7 @@
                help="The minimum api microversion is configured to be the "
                     "value of the minimum microversion supported by Manila."),
     cfg.StrOpt("max_api_microversion",
-               default="2.9",
+               default="2.10",
                help="The maximum api microversion is configured to be the "
                     "value of the latest microversion supported by Manila."),
     cfg.StrOpt("region",
diff --git a/manila_tempest_tests/services/share/v2/json/shares_client.py b/manila_tempest_tests/services/share/v2/json/shares_client.py
index d017b91..57aec12 100644
--- a/manila_tempest_tests/services/share/v2/json/shares_client.py
+++ b/manila_tempest_tests/services/share/v2/json/shares_client.py
@@ -323,6 +323,30 @@
                            (instance_id, status, self.build_timeout))
                 raise exceptions.TimeoutException(message)
 
+    def wait_for_share_status(self, share_id, status, status_attr='status',
+                              version=LATEST_MICROVERSION):
+        """Waits for a share to reach a given status."""
+        body = self.get_share(share_id, version=version)
+        share_status = body[status_attr]
+        start = int(time.time())
+
+        while share_status != status:
+            time.sleep(self.build_interval)
+            body = self.get_share(share_id, version=version)
+            share_status = body[status_attr]
+            if share_status == status:
+                return
+            elif 'error' in share_status.lower():
+                raise share_exceptions.ShareBuildErrorException(
+                    share_id=share_id)
+
+            if int(time.time()) - start >= self.build_timeout:
+                message = ("Share's %(status_attr)s failed to transition to "
+                           "%(status)s within the required time %(seconds)s." %
+                           {"status_attr": status_attr, "status": status,
+                            "seconds": self.build_timeout})
+                raise exceptions.TimeoutException(message)
+
 ###############
 
     def extend_share(self, share_id, new_size, version=LATEST_MICROVERSION,
diff --git a/manila_tempest_tests/tests/api/admin/test_share_instances.py b/manila_tempest_tests/tests/api/admin/test_share_instances.py
index c5f96c8..248d145 100644
--- a/manila_tempest_tests/tests/api/admin/test_share_instances.py
+++ b/manila_tempest_tests/tests/api/admin/test_share_instances.py
@@ -64,6 +64,7 @@
         share_instances = self.shares_v2_client.get_instances_of_share(
             self.share['id'], version=version,
         )
+
         si = self.shares_v2_client.get_share_instance(
             share_instances[0]['id'], version=version)
 
@@ -73,6 +74,8 @@
         ]
         if utils.is_microversion_lt(version, '2.9'):
             expected_keys.extend(["export_location", "export_locations"])
+        if utils.is_microversion_ge(version, '2.10'):
+            expected_keys.append("access_rules_status")
         expected_keys = sorted(expected_keys)
         actual_keys = sorted(si.keys())
         self.assertEqual(expected_keys, actual_keys,
@@ -87,3 +90,7 @@
     @test.attr(type=["gate", ])
     def test_get_share_instance_v2_9(self):
         self._get_share_instance('2.9')
+
+    @test.attr(type=["gate", ])
+    def test_get_share_instance_v2_10(self):
+        self._get_share_instance('2.10')
diff --git a/manila_tempest_tests/tests/api/test_rules.py b/manila_tempest_tests/tests/api/test_rules.py
index 7c233ba..307a0cb 100644
--- a/manila_tempest_tests/tests/api/test_rules.py
+++ b/manila_tempest_tests/tests/api/test_rules.py
@@ -14,32 +14,53 @@
 #    under the License.
 
 import ddt
-from tempest import config  # noqa
-from tempest import test  # noqa
-from tempest_lib import exceptions as lib_exc  # noqa
-import testtools  # noqa
+from tempest import config
+from tempest import test
+from tempest_lib import exceptions as lib_exc
+import testtools
 
 from manila_tempest_tests.tests.api import base
+from manila_tempest_tests import utils
 
 CONF = config.CONF
+LATEST_MICROVERSION = CONF.share.max_api_microversion
 
 
-def _create_delete_ro_access_rule(self, client_name):
+def _create_delete_ro_access_rule(self, version):
     """Common test case for usage in test suites with different decorators.
 
     :param self: instance of test class
     """
-    rule = getattr(self, client_name).create_access_rule(
-        self.share["id"], self.access_type, self.access_to, 'ro')
+
+    if utils.is_microversion_eq(version, '1.0'):
+        rule = self.shares_client.create_access_rule(
+            self.share["id"], self.access_type, self.access_to, 'ro')
+    else:
+        rule = self.shares_v2_client.create_access_rule(
+            self.share["id"], self.access_type, self.access_to, 'ro',
+            version=version)
 
     self.assertEqual('ro', rule['access_level'])
     for key in ('deleted', 'deleted_at', 'instance_mappings'):
         self.assertNotIn(key, rule.keys())
-    getattr(self, client_name).wait_for_access_rule_status(
-        self.share["id"], rule["id"], "active")
-    getattr(self, client_name).delete_access_rule(self.share["id"], rule["id"])
-    getattr(self, client_name).wait_for_resource_deletion(
-        rule_id=rule["id"], share_id=self.share['id'])
+
+    if utils.is_microversion_le(version, '2.9'):
+        self.shares_client.wait_for_access_rule_status(
+            self.share["id"], rule["id"], "active")
+    else:
+        self.shares_v2_client.wait_for_share_status(
+            self.share["id"], "active", status_attr='access_rules_status',
+            version=version)
+
+    if utils.is_microversion_eq(version, '1.0'):
+        self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+        self.shares_client.wait_for_resource_deletion(
+            rule_id=rule["id"], share_id=self.share['id'])
+    else:
+        self.shares_v2_client.delete_access_rule(
+            self.share["id"], rule["id"], version=version)
+        self.shares_v2_client.wait_for_resource_deletion(
+            rule_id=rule["id"], share_id=self.share['id'], version=version)
 
 
 @ddt.ddt
@@ -58,56 +79,94 @@
         cls.access_to = "2.2.2.2"
 
     @test.attr(type=["gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_access_rules_with_one_ip(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_access_rules_with_one_ip(self, version):
 
         # test data
         access_to = "1.1.1.1"
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], self.access_type, access_to)
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], self.access_type, access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], self.access_type, access_to,
+                version=version)
 
         self.assertEqual('rw', rule['access_level'])
         for key in ('deleted', 'deleted_at', 'instance_mappings'):
             self.assertNotIn(key, rule.keys())
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
 
         # delete rule and wait for deletion
-        getattr(self, client_name).delete_access_rule(self.share["id"],
-                                                      rule["id"])
-        getattr(self, client_name).wait_for_resource_deletion(
-            rule_id=rule["id"], share_id=self.share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'])
+        else:
+            self.shares_v2_client.delete_access_rule(
+                self.share["id"], rule["id"], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'], version=version)
 
     @test.attr(type=["gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_access_rule_with_cidr(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_access_rule_with_cidr(self, version):
 
         # test data
         access_to = "1.2.3.4/32"
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], self.access_type, access_to)
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], self.access_type, access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], self.access_type, access_to,
+                version=version)
 
         for key in ('deleted', 'deleted_at', 'instance_mappings'):
             self.assertNotIn(key, rule.keys())
         self.assertEqual('rw', rule['access_level'])
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
 
         # delete rule and wait for deletion
-        getattr(self, client_name).delete_access_rule(self.share["id"],
-                                                      rule["id"])
-        getattr(self, client_name).wait_for_resource_deletion(
-            rule_id=rule["id"], share_id=self.share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'])
+        else:
+            self.shares_v2_client.delete_access_rule(
+                self.share["id"], rule["id"], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'], version=version)
 
     @test.attr(type=["gate", ])
     @testtools.skipIf(
         "nfs" not in CONF.share.enable_ro_access_level_for_protocols,
         "RO access rule tests are disabled for NFS protocol.")
-    @ddt.data('shares_client', 'shares_v2_client')
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
     def test_create_delete_ro_access_rule(self, client_name):
         _create_delete_ro_access_rule(self, client_name)
 
@@ -120,9 +179,9 @@
     @testtools.skipIf(
         "cifs" not in CONF.share.enable_ro_access_level_for_protocols,
         "RO access rule tests are disabled for CIFS protocol.")
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_ro_access_rule(self, client_name):
-        _create_delete_ro_access_rule(self, client_name)
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_ro_access_rule(self, version):
+        _create_delete_ro_access_rule(self, version)
 
 
 @ddt.ddt
@@ -142,32 +201,51 @@
         cls.access_to = CONF.share.username_for_user_rules
 
     @test.attr(type=["gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_user_rule(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_user_rule(self, version):
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], self.access_type, self.access_to)
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], self.access_type, self.access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], self.access_type, self.access_to,
+                version=version)
 
         self.assertEqual('rw', rule['access_level'])
         for key in ('deleted', 'deleted_at', 'instance_mappings'):
             self.assertNotIn(key, rule.keys())
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
 
         # delete rule and wait for deletion
-        getattr(self, client_name).delete_access_rule(self.share["id"],
-                                                      rule["id"])
-        getattr(self, client_name).wait_for_resource_deletion(
-            rule_id=rule["id"], share_id=self.share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'])
+        else:
+            self.shares_v2_client.delete_access_rule(
+                self.share["id"], rule["id"], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'], version=version)
 
     @test.attr(type=["gate", ])
     @testtools.skipIf(
         "nfs" not in CONF.share.enable_ro_access_level_for_protocols,
         "RO access rule tests are disabled for NFS protocol.")
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_ro_access_rule(self, client_name):
-        _create_delete_ro_access_rule(self, client_name)
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_ro_access_rule(self, version):
+        _create_delete_ro_access_rule(self, version)
 
 
 @ddt.ddt
@@ -178,9 +256,9 @@
     @testtools.skipIf(
         "cifs" not in CONF.share.enable_ro_access_level_for_protocols,
         "RO access rule tests are disabled for CIFS protocol.")
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_ro_access_rule(self, client_name):
-        _create_delete_ro_access_rule(self, client_name)
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_ro_access_rule(self, version):
+        _create_delete_ro_access_rule(self, version)
 
 
 @ddt.ddt
@@ -202,41 +280,82 @@
         cls.access_to = "client1.com"
 
     @test.attr(type=["gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_cert_rule(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_cert_rule(self, version):
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], self.access_type, self.access_to)
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], self.access_type, self.access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], self.access_type, self.access_to,
+                version=version)
 
         self.assertEqual('rw', rule['access_level'])
         for key in ('deleted', 'deleted_at', 'instance_mappings'):
             self.assertNotIn(key, rule.keys())
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
 
-        # delete rule and wait for deletion
-        getattr(self, client_name).delete_access_rule(self.share["id"],
-                                                      rule["id"])
-        getattr(self, client_name).wait_for_resource_deletion(
-            rule_id=rule["id"], share_id=self.share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
+
+        # delete rule
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'])
+        else:
+            self.shares_v2_client.delete_access_rule(
+                self.share["id"], rule["id"], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'], version=version)
 
     @test.attr(type=["gate", ])
     @testtools.skipIf(
         "glusterfs" not in CONF.share.enable_ro_access_level_for_protocols,
         "RO access rule tests are disabled for GLUSTERFS protocol.")
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_delete_cert_ro_access_rule(self, client_name):
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], 'cert', 'client2.com', 'ro')
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_delete_cert_ro_access_rule(self, version):
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], 'cert', 'client2.com', 'ro')
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], 'cert', 'client2.com', 'ro',
+                version=version)
 
         self.assertEqual('ro', rule['access_level'])
         for key in ('deleted', 'deleted_at', 'instance_mappings'):
             self.assertNotIn(key, rule.keys())
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
-        getattr(self, client_name).delete_access_rule(self.share["id"],
-                                                      rule["id"])
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'])
+        else:
+            self.shares_v2_client.delete_access_rule(
+                self.share["id"], rule["id"], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'], version=version)
 
 
 @ddt.ddt
@@ -269,27 +388,43 @@
         cls.share = cls.create_share()
 
     @test.attr(type=["gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_list_access_rules(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_list_access_rules(self, version):
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], self.access_type, self.access_to)
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], self.access_type, self.access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], self.access_type, self.access_to,
+                version=version)
 
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
 
         # list rules
-        rules = getattr(self, client_name).list_access_rules(self.share["id"])
+        if utils.is_microversion_eq(version, '1.0'):
+            rules = self.shares_client.list_access_rules(self.share["id"])
+        else:
+            rules = self.shares_v2_client.list_access_rules(self.share["id"],
+                                                            version=version)
 
         # verify keys
-        for key in ("state", "id", "access_type", "access_to", "access_level"):
+        for key in ("id", "access_type", "access_to", "access_level"):
             [self.assertIn(key, r.keys()) for r in rules]
         for key in ('deleted', 'deleted_at', 'instance_mappings'):
             [self.assertNotIn(key, r.keys()) for r in rules]
 
         # verify values
-        self.assertEqual("active", rules[0]["state"])
         self.assertEqual(self.access_type, rules[0]["access_type"])
         self.assertEqual(self.access_to, rules[0]["access_to"])
         self.assertEqual('rw', rules[0]["access_level"])
@@ -299,31 +434,58 @@
         msg = "expected id lists %s times in rule list" % (len(gen))
         self.assertEqual(len(gen), 1, msg)
 
-        getattr(self, client_name).delete_access_rule(
-            self.share['id'], rule['id'])
-
-        getattr(self, client_name).wait_for_resource_deletion(
-            rule_id=rule["id"], share_id=self.share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"], rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'])
+        else:
+            self.shares_v2_client.delete_access_rule(
+                self.share["id"], rule["id"], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share['id'], version=version)
 
     @test.attr(type=["gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_access_rules_deleted_if_share_deleted(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_access_rules_deleted_if_share_deleted(self, version):
 
         # create share
         share = self.create_share()
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            share["id"], self.access_type, self.access_to)
-        getattr(self, client_name).wait_for_access_rule_status(
-            share["id"], rule["id"], "active")
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                share["id"], self.access_type, self.access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                share["id"], self.access_type, self.access_to,
+                version=version)
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                share["id"], "active", status_attr='access_rules_status',
+                version=version)
 
         # delete share
-        getattr(self, client_name).delete_share(share['id'])
-        getattr(self, client_name).wait_for_resource_deletion(
-            share_id=share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_share(share['id'])
+            self.shares_client.wait_for_resource_deletion(share_id=share['id'])
+        else:
+            self.shares_v2_client.delete_share(share['id'], version=version)
+            self.shares_v2_client.wait_for_resource_deletion(
+                share_id=share['id'], version=version)
 
         # verify absence of rules for nonexistent share id
-        self.assertRaises(lib_exc.NotFound,
-                          getattr(self, client_name).list_access_rules,
-                          share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.assertRaises(lib_exc.NotFound,
+                              self.shares_client.list_access_rules,
+                              share['id'])
+        else:
+            self.assertRaises(lib_exc.NotFound,
+                              self.shares_v2_client.list_access_rules,
+                              share['id'], version)
diff --git a/manila_tempest_tests/tests/api/test_rules_negative.py b/manila_tempest_tests/tests/api/test_rules_negative.py
index 71b5244..47f5a52 100644
--- a/manila_tempest_tests/tests/api/test_rules_negative.py
+++ b/manila_tempest_tests/tests/api/test_rules_negative.py
@@ -14,14 +14,16 @@
 #    under the License.
 
 import ddt
-from tempest import config  # noqa
-from tempest import test  # noqa
-from tempest_lib import exceptions as lib_exc  # noqa
-import testtools  # noqa
+from tempest import config
+from tempest import test
+from tempest_lib import exceptions as lib_exc
+import testtools
 
 from manila_tempest_tests.tests.api import base
+from manila_tempest_tests import utils
 
 CONF = config.CONF
+LATEST_MICROVERSION = CONF.share.max_api_microversion
 
 
 @ddt.ddt
@@ -108,28 +110,53 @@
                           'su')
 
     @test.attr(type=["negative", "gate", ])
-    @ddt.data('shares_client', 'shares_v2_client')
-    def test_create_duplicate_of_ip_rule(self, client_name):
+    @ddt.data('1.0', '2.9', LATEST_MICROVERSION)
+    def test_create_duplicate_of_ip_rule(self, version):
         # test data
         access_type = "ip"
         access_to = "1.2.3.4"
 
         # create rule
-        rule = getattr(self, client_name).create_access_rule(
-            self.share["id"], access_type, access_to)
-        getattr(self, client_name).wait_for_access_rule_status(
-            self.share["id"], rule["id"], "active")
+        if utils.is_microversion_eq(version, '1.0'):
+            rule = self.shares_client.create_access_rule(
+                self.share["id"], access_type, access_to)
+        else:
+            rule = self.shares_v2_client.create_access_rule(
+                self.share["id"], access_type, access_to, version=version)
+
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        elif utils.is_microversion_eq(version, '2.9'):
+            self.shares_v2_client.wait_for_access_rule_status(
+                self.share["id"], rule["id"], "active")
+        else:
+            self.shares_v2_client.wait_for_share_status(
+                self.share["id"], "active", status_attr='access_rules_status',
+                version=version)
 
         # try create duplicate of rule
-        self.assertRaises(lib_exc.BadRequest,
-                          getattr(self, client_name).create_access_rule,
-                          self.share["id"], access_type, access_to)
+        if utils.is_microversion_eq(version, '1.0'):
+            self.assertRaises(lib_exc.BadRequest,
+                              self.shares_client.create_access_rule,
+                              self.share["id"], access_type, access_to)
+        else:
+            self.assertRaises(lib_exc.BadRequest,
+                              self.shares_v2_client.create_access_rule,
+                              self.share["id"], access_type, access_to,
+                              version=version)
 
         # delete rule and wait for deletion
-        getattr(self, client_name).delete_access_rule(self.share["id"],
-                                                      rule["id"])
-        getattr(self, client_name).wait_for_resource_deletion(
-            rule_id=rule["id"], share_id=self.share['id'])
+        if utils.is_microversion_eq(version, '1.0'):
+            self.shares_client.delete_access_rule(self.share["id"],
+                                                  rule["id"])
+            self.shares_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share["id"])
+        else:
+            self.shares_v2_client.delete_access_rule(self.share["id"],
+                                                     rule["id"])
+            self.shares_v2_client.wait_for_resource_deletion(
+                rule_id=rule["id"], share_id=self.share["id"], version=version)
 
 
 @ddt.ddt
diff --git a/manila_tempest_tests/tests/api/test_shares_actions.py b/manila_tempest_tests/tests/api/test_shares_actions.py
index f09cc6b..16fab6d 100644
--- a/manila_tempest_tests/tests/api/test_shares_actions.py
+++ b/manila_tempest_tests/tests/api/test_shares_actions.py
@@ -95,6 +95,8 @@
                                   "source_cgsnapshot_member_id"])
         if utils.is_microversion_ge(version, '2.5'):
             expected_keys.append("share_type_name")
+        if utils.is_microversion_ge(version, '2.10'):
+            expected_keys.append("access_rules_status")
         actual_keys = list(share.keys())
         [self.assertIn(key, actual_keys) for key in expected_keys]
 
@@ -137,6 +139,11 @@
         self._get_share('2.9')
 
     @test.attr(type=["gate", ])
+    @utils.skip_if_microversion_not_supported('2.10')
+    def test_get_share_with_access_rules_status(self):
+        self._get_share('2.10')
+
+    @test.attr(type=["gate", ])
     def test_list_shares(self):
 
         # list shares
@@ -174,6 +181,8 @@
                          "source_cgsnapshot_member_id"])
         if utils.is_microversion_ge(version, '2.6'):
             keys.append("share_type_name")
+        if utils.is_microversion_ge(version, '2.10'):
+            keys.append("access_rules_status")
 
         [self.assertIn(key, sh.keys()) for sh in shares for key in keys]
 
@@ -207,6 +216,11 @@
         self._list_shares_with_detail('2.9')
 
     @test.attr(type=["gate", ])
+    @utils.skip_if_microversion_not_supported('2.10')
+    def test_list_shares_with_detail_with_access_rules_status(self):
+        self._list_shares_with_detail('2.10')
+
+    @test.attr(type=["gate", ])
     def test_list_shares_with_detail_filter_by_metadata(self):
         filters = {'metadata': self.metadata}
 
diff --git a/manila_tempest_tests/tests/scenario/manager_share.py b/manila_tempest_tests/tests/scenario/manager_share.py
index 3a942e0..f5f0c1f 100644
--- a/manila_tempest_tests/tests/scenario/manager_share.py
+++ b/manila_tempest_tests/tests/scenario/manager_share.py
@@ -133,7 +133,12 @@
         """
         client = client or self.shares_client
         access = client.create_access_rule(share_id, access_type, access_to)
-        client.wait_for_access_rule_status(share_id, access['id'], "active")
+
+        # NOTE(u_glide): Ignore provided client, because we always need v2
+        # client to make this call
+        self.shares_v2_client.wait_for_share_status(
+            share_id, "active", status_attr='access_rules_status')
+
         if cleanup:
             self.addCleanup(client.delete_access_rule, share_id, access['id'])
         return access