diff --git a/designate_tempest_plugin/common/waiters.py b/designate_tempest_plugin/common/waiters.py
index a606fda..affe332 100644
--- a/designate_tempest_plugin/common/waiters.py
+++ b/designate_tempest_plugin/common/waiters.py
@@ -33,7 +33,7 @@
         time.sleep(client.build_interval)
 
         try:
-            _, zone = client.show_zone(zone_id)
+            zone = client.show_zone(zone_id)[1]
         except lib_exc.NotFound:
             LOG.info('Zone %s is 404ing', zone_id)
             return
@@ -62,12 +62,12 @@
     """Waits for a zone to reach given status."""
     LOG.info('Waiting for zone %s to reach %s', zone_id, status)
 
-    _, zone = client.show_zone(zone_id, headers=headers)
+    zone = client.show_zone(zone_id, headers=headers)[1]
     start = int(time.time())
 
     while zone['status'] != status:
         time.sleep(client.build_interval)
-        _, zone = client.show_zone(zone_id, headers=headers)
+        zone = client.show_zone(zone_id, headers=headers)[1]
         status_curr = zone['status']
         if status_curr == status:
             LOG.info('Zone %s reached %s', zone_id, status)
@@ -98,12 +98,12 @@
     """Waits for an imported zone to reach the given status."""
     LOG.info('Waiting for zone import %s to reach %s', zone_import_id, status)
 
-    _, zone_import = client.show_zone_import(zone_import_id)
+    zone_import = client.show_zone_import(zone_import_id)[1]
     start = int(time.time())
 
     while zone_import['status'] != status:
         time.sleep(client.build_interval)
-        _, zone_import = client.show_zone_import(zone_import_id)
+        zone_import = client.show_zone_import(zone_import_id)[1]
         status_curr = zone_import['status']
         if status_curr == status:
             LOG.info('Zone import %s reached %s', zone_import_id, status)
@@ -131,16 +131,17 @@
             raise lib_exc.TimeoutException(message)
 
 
-def wait_for_zone_export_status(client, zone_export_id, status):
+def wait_for_zone_export_status(client, zone_export_id, status, headers=None):
     """Waits for an exported zone to reach the given status."""
     LOG.info('Waiting for zone export %s to reach %s', zone_export_id, status)
 
-    _, zone_export = client.show_zone_export(zone_export_id)
+    zone_export = client.show_zone_export(zone_export_id, headers=headers)[1]
     start = int(time.time())
 
     while zone_export['status'] != status:
         time.sleep(client.build_interval)
-        _, zone_export = client.show_zone_export(zone_export_id)
+        zone_export = client.show_zone_export(
+            zone_export_id, headers=headers)[1]
         status_curr = zone_export['status']
         if status_curr == status:
             LOG.info('Zone export %s reached %s', zone_export_id, status)
@@ -168,17 +169,20 @@
             raise lib_exc.TimeoutException(message)
 
 
-def wait_for_recordset_status(client, zone_id, recordset_id, status):
+def wait_for_recordset_status(
+        client, zone_id, recordset_id, status, headers=None):
     """Waits for a recordset to reach the given status."""
     LOG.info('Waiting for recordset %s to reach %s',
              recordset_id, status)
 
-    _, recordset = client.show_recordset(zone_id, recordset_id)
+    recordset = client.show_recordset(
+        zone_id, recordset_id, headers=headers)[1]
     start = int(time.time())
 
     while recordset['status'] != status:
         time.sleep(client.build_interval)
-        _, recordset = client.show_recordset(zone_id, recordset_id)
+        recordset = client.show_recordset(
+            zone_id, recordset_id, headers=headers)[1]
         status_curr = recordset['status']
         if status_curr == status:
             LOG.info('Recordset %s reached %s', recordset_id, status)
diff --git a/designate_tempest_plugin/config.py b/designate_tempest_plugin/config.py
index c244b12..f4ca708 100644
--- a/designate_tempest_plugin/config.py
+++ b/designate_tempest_plugin/config.py
@@ -41,7 +41,7 @@
                default=360,
                help="Timeout in seconds to wait for an resource to build."),
     cfg.IntOpt('min_ttl',
-               default=1,
+               default=0,
                help="The minimum value to respect when generating ttls"),
     cfg.ListOpt('nameservers',
                 default=[],
diff --git a/designate_tempest_plugin/data_utils.py b/designate_tempest_plugin/data_utils.py
index 61c6da0..d148685 100644
--- a/designate_tempest_plugin/data_utils.py
+++ b/designate_tempest_plugin/data_utils.py
@@ -58,7 +58,7 @@
     return 'example@%s' % domain.rstrip('.')
 
 
-def rand_ttl(start=1, end=86400):
+def rand_ttl(start=0, end=86400):
     """Generate a random TTL value
     :return: a random ttl e.g. 165
     :rtype: string
@@ -125,7 +125,7 @@
 
 
 def rand_recordset_data(record_type, zone_name, name=None, records=None,
-                        ttl=None):
+                        ttl=None, number_of_records=None):
     """Generate random recordset data, with optional overrides
     :return: A RecordsetModel
     """
@@ -133,6 +133,8 @@
         name = rand_zone_name(prefix=record_type, suffix='.' + zone_name)
     if records is None:
         records = [rand_ip()]
+    if number_of_records:
+        records = [rand_ip() for r in range(number_of_records)]
     if ttl is None:
         ttl = rand_ttl()
     return {
diff --git a/designate_tempest_plugin/services/dns/v2/json/recordset_client.py b/designate_tempest_plugin/services/dns/v2/json/recordset_client.py
index d07ca18..4440705 100644
--- a/designate_tempest_plugin/services/dns/v2/json/recordset_client.py
+++ b/designate_tempest_plugin/services/dns/v2/json/recordset_client.py
@@ -35,27 +35,24 @@
 
     @base.handle_errors
     def create_recordset(self, zone_uuid, recordset_data,
-                         params=None, wait_until=False):
+                         params=None, wait_until=False, headers=None):
         """Create a recordset for the specified zone.
-
         :param zone_uuid: Unique identifier of the zone in UUID format..
         :param recordset_data: A dictionary that represents the recordset
                                data.
         :param params: A Python dict that represents the query paramaters to
                        include in the request URI.
+        :param headers (dict): The headers to use for the request.
         :return: A tuple with the server response and the created zone.
         """
         resp, body = self._create_request(
             "/zones/{0}/recordsets".format(zone_uuid), params=params,
-            data=recordset_data)
-
+            data=recordset_data, headers=headers)
         # Create Recordset should Return a HTTP 202
         self.expected_success(202, resp.status)
-
         if wait_until:
             waiters.wait_for_recordset_status(
-                self, zone_uuid, body['id'], wait_until)
-
+                self, zone_uuid, body['id'], wait_until, headers=headers)
         return resp, body
 
     @base.handle_errors
diff --git a/designate_tempest_plugin/services/dns/v2/json/zone_exports_client.py b/designate_tempest_plugin/services/dns/v2/json/zone_exports_client.py
index 1f469ec..5089d36 100644
--- a/designate_tempest_plugin/services/dns/v2/json/zone_exports_client.py
+++ b/designate_tempest_plugin/services/dns/v2/json/zone_exports_client.py
@@ -19,7 +19,8 @@
 class ZoneExportsClient(base.DnsClientV2Base):
 
     @base.handle_errors
-    def create_zone_export(self, uuid, params=None, wait_until=False):
+    def create_zone_export(self, uuid, params=None,
+                           wait_until=False, headers=None):
         """Create a zone export.
 
         :param uuid: Unique identifier of the zone in UUID format.
@@ -27,18 +28,20 @@
                        include in the request URI.
         :param wait_until: Block until the exported zone reaches the
                            desired status
+        :param headers (dict): The headers to use for the request.
         :return: Serialized imported zone as a dictionary.
         """
 
         export_uri = 'zones/{0}/tasks/export'.format(uuid)
         resp, body = self._create_request(
-            export_uri, params=params)
+            export_uri, params=params, headers=headers)
 
         # Create Zone Export should Return a HTTP 202
         self.expected_success(202, resp.status)
 
         if wait_until:
-            waiters.wait_for_zone_export_status(self, body['id'], wait_until)
+            waiters.wait_for_zone_export_status(
+                self, body['id'], wait_until, headers=headers)
 
         return resp, body
 
diff --git a/designate_tempest_plugin/services/dns/v2/json/zone_imports_client.py b/designate_tempest_plugin/services/dns/v2/json/zone_imports_client.py
index 4fbba2a..236e737 100644
--- a/designate_tempest_plugin/services/dns/v2/json/zone_imports_client.py
+++ b/designate_tempest_plugin/services/dns/v2/json/zone_imports_client.py
@@ -21,15 +21,16 @@
 
     @base.handle_errors
     def create_zone_import(self, zonefile_data=None,
-                           params=None, wait_until=None):
+                           wait_until=None, headers=None):
         """Create a zone import.
         :param zonefile_data: A tuple that represents zone data.
-        :param params: A Python dict that represents the query paramaters to
-                       include in the request URI.
+        :param wait_until: If not None, a waiter for appropriate status
+                will be activated.
+        :param headers (dict): The headers to use for the request.
         :return: Serialized imported zone as a dictionary.
         """
-
-        headers = {'Content-Type': 'text/dns'}
+        if not headers:
+            headers = {'Content-Type': 'text/dns'}
         zone_data = zonefile_data or dns_data_utils.rand_zonefile_data()
         resp, body = self._create_request(
             'zones/tasks/imports', zone_data, headers=headers)
diff --git a/designate_tempest_plugin/tests/api/v2/test_blacklists.py b/designate_tempest_plugin/tests/api/v2/test_blacklists.py
index cd859af..ecb5ce5 100644
--- a/designate_tempest_plugin/tests/api/v2/test_blacklists.py
+++ b/designate_tempest_plugin/tests/api/v2/test_blacklists.py
@@ -66,7 +66,6 @@
                                         expected_allowed, False)
 
     @decorators.idempotent_id('ea608152-da3c-11eb-b8b8-74e5f9e2a801')
-    @decorators.skip_because(bug="1934252")
     def test_create_blacklist_invalid_pattern(self):
         patterns = ['', '#(*&^%$%$#@$', 'a' * 1000]
         for pattern in patterns:
diff --git a/designate_tempest_plugin/tests/api/v2/test_zones.py b/designate_tempest_plugin/tests/api/v2/test_zones.py
index 3555c51..3ab2601 100644
--- a/designate_tempest_plugin/tests/api/v2/test_zones.py
+++ b/designate_tempest_plugin/tests/api/v2/test_zones.py
@@ -182,18 +182,6 @@
             'ZonesClient', 'show_zone', expected_allowed, False, zone['id'],
             headers={'x-auth-sudo-project-id': self.client.project_id})
 
-    @decorators.idempotent_id('49268b24-92de-11eb-9d02-74e5f9e2a801')
-    def test_show_not_existing_zone(self):
-        LOG.info('Fetch non existing zone')
-        self.assertRaises(lib_exc.NotFound,
-            lambda: self.client.show_zone(uuid.uuid1()))
-
-    @decorators.idempotent_id('736e3b50-92e0-11eb-9d02-74e5f9e2a801')
-    def test_use_invalid_id_to_show_zone(self):
-        LOG.info('Fetch the zone using invalid zone ID')
-        with self.assertRaisesDns(lib_exc.BadRequest, 'invalid_uuid', 400):
-            self.client.show_zone(uuid='zahlabut')
-
     @decorators.attr(type='smoke')
     @decorators.idempotent_id('a4791906-6cd6-4d27-9f15-32273db8bb3d')
     def test_delete_zone(self):
@@ -231,12 +219,6 @@
         self.assertEqual(const.DELETE, body['action'])
         self.assertEqual(const.PENDING, body['status'])
 
-    @decorators.idempotent_id('79921370-92e1-11eb-9d02-74e5f9e2a801')
-    def test_delete_non_existing_zone(self):
-        LOG.info('Delete non existing zone')
-        self.assertRaises(lib_exc.NotFound,
-            lambda: self.client.delete_zone(uuid.uuid1()))
-
     @decorators.idempotent_id('5bfa3cfe-5bc8-443b-bf48-cfba44cbb247')
     def test_list_zones(self):
         LOG.info('Create a zone')
@@ -246,7 +228,7 @@
         self.addCleanup(self.wait_zone_delete, self.client, zone['id'])
 
         LOG.info('List zones')
-        _, body = self.client.list_zones()
+        body = self.client.list_zones()[1]
 
         # TODO(kiall): We really want to assert that out newly created zone is
         #              present in the response.
@@ -374,20 +356,6 @@
             "Failed, expect the Serial to not change "
             "when the Description is updated")
 
-    @decorators.idempotent_id('e391e30a-92e0-11eb-9d02-74e5f9e2a801')
-    def test_update_non_existing_zone(self):
-        LOG.info('Update non existing zone')
-        self.assertRaises(lib_exc.NotFound,
-            lambda: self.client.update_zone(
-                uuid.uuid1(), description=data_utils.rand_name()))
-
-    @decorators.idempotent_id('925192f2-0ed8-4591-8fe7-a9fa028f90a0')
-    def test_list_zones_dot_json_fails(self):
-        uri = self.client.get_uri('zones.json')
-
-        self.assertRaises(lib_exc.NotFound,
-            lambda: self.client.get(uri))
-
     @decorators.idempotent_id('d4ce813e-64a5-11eb-9f43-74e5f9e2a801')
     def test_get_primary_zone_nameservers(self):
         # Create a zone and get the associated "pool_id"
@@ -439,6 +407,25 @@
             False, zone['id'],
             headers={'x-auth-sudo-project-id': self.client.project_id})
 
+    @decorators.idempotent_id('9970b632-f2db-11ec-a757-201e8823901f')
+    def test_create_zone_ttl_zero(self):
+        LOG.info('Create a PRIMARY zone')
+        zone_name = dns_data_utils.rand_zone_name(
+            name="test_create_zone_ttl_zero", suffix=self.tld_name)
+        zone = self.client.create_zone(name=zone_name, ttl=0)[1]
+        self.addCleanup(self.wait_zone_delete, self.client, zone['id'])
+
+        LOG.info('Ensure we respond with CREATE+PENDING')
+        self.assertEqual(const.CREATE, zone['action'])
+        self.assertEqual(const.PENDING, zone['status'])
+
+        LOG.info('Fetch the zone, ensure TTL is Zero')
+        body = self.client.show_zone(zone['id'])[1]
+        self.assertEqual(
+            0, body['ttl'],
+            "Failed, actual Zone's TTL:{} "
+            "is not Zero".format(body['ttl']))
+
 
 class ZonesAdminTest(BaseZonesTest):
     credentials = ["primary", "admin", "system_admin", "alt"]
@@ -657,3 +644,35 @@
             lib_exc.BadRequest, 'invalid_object', 400,
             self.client.create_zone,
             description=dns_data_utils.rand_zone_name() * 10000)
+
+    @decorators.idempotent_id('49268b24-92de-11eb-9d02-74e5f9e2a801')
+    def test_show_not_existing_zone(self):
+        LOG.info('Fetch non existing zone')
+        self.assertRaises(lib_exc.NotFound,
+            lambda: self.client.show_zone(uuid.uuid1()))
+
+    @decorators.idempotent_id('736e3b50-92e0-11eb-9d02-74e5f9e2a801')
+    def test_use_invalid_id_to_show_zone(self):
+        LOG.info('Fetch the zone using invalid zone ID')
+        with self.assertRaisesDns(lib_exc.BadRequest, 'invalid_uuid', 400):
+            self.client.show_zone(uuid='zahlabut')
+
+    @decorators.idempotent_id('79921370-92e1-11eb-9d02-74e5f9e2a801')
+    def test_delete_non_existing_zone(self):
+        LOG.info('Delete non existing zone')
+        self.assertRaises(lib_exc.NotFound,
+            lambda: self.client.delete_zone(uuid.uuid1()))
+
+    @decorators.idempotent_id('e391e30a-92e0-11eb-9d02-74e5f9e2a801')
+    def test_update_non_existing_zone(self):
+        LOG.info('Update non existing zone')
+        self.assertRaises(lib_exc.NotFound,
+            lambda: self.client.update_zone(
+                uuid.uuid1(), description=data_utils.rand_name()))
+
+    @decorators.idempotent_id('925192f2-0ed8-4591-8fe7-a9fa028f90a0')
+    def test_list_zones_dot_json_fails(self):
+        uri = self.client.get_uri('zones.json')
+
+        self.assertRaises(lib_exc.NotFound,
+            lambda: self.client.get(uri))
diff --git a/designate_tempest_plugin/tests/api/v2/test_zones_imports.py b/designate_tempest_plugin/tests/api/v2/test_zones_imports.py
index 34f2538..8e03845 100644
--- a/designate_tempest_plugin/tests/api/v2/test_zones_imports.py
+++ b/designate_tempest_plugin/tests/api/v2/test_zones_imports.py
@@ -373,3 +373,83 @@
         self.check_list_IDs_RBAC_enforcement(
             'ZoneImportsClient', 'list_zone_imports', expected_allowed,
             [zone_import['id']], headers=self.all_projects_header)
+
+
+class ZonesImportTestNegative(BaseZonesImportTest):
+    credentials = ["primary", "admin", "system_admin"]
+
+    @classmethod
+    def setup_credentials(cls):
+        # Do not create network resources for these test.
+        cls.set_network_resources()
+        super(ZonesImportTestNegative, cls).setup_credentials()
+
+    @classmethod
+    def setup_clients(cls):
+        super(ZonesImportTestNegative, cls).setup_clients()
+        cls.zone_client = cls.os_primary.dns_v2.ZonesClient()
+        cls.client = cls.os_primary.dns_v2.ZoneImportsClient()
+
+    def _clean_up_resources(self, zone_import_id):
+        zone_import = self.client.show_zone_import(zone_import_id)[1]
+        if zone_import['zone_id']:  # A zone was actually created.
+            waiters.wait_for_zone_import_status(
+                self.client, zone_import_id, const.COMPLETE)
+            self.client.delete_zone_import(zone_import['id'])
+            self.wait_zone_delete(self.zone_client, zone_import['zone_id'])
+        else:  # Import has failed and zone wasn't created.
+            self.client.delete_zone_import(zone_import['id'])
+
+    @decorators.idempotent_id('31eaf25a-9532-11eb-a55d-74e5f9e2a801')
+    def test_create_zone_import_invalid_ttl(self):
+        LOG.info('Try to create a zone import using invalid TTL value')
+        zone_name = dns_data_utils.rand_zone_name(
+            name="create_zone_import_invalid_ttl", suffix=self.tld_name)
+        zone_data = dns_data_utils.rand_zonefile_data(name=zone_name,
+                                                      ttl='zahlabut')
+        zone_import = self.client.create_zone_import(
+            zonefile_data=zone_data, wait_until=const.ERROR)[1]
+        self.addCleanup(self._clean_up_resources, zone_import['id'])
+
+    @decorators.idempotent_id('31eaf25a-9532-11eb-a55d-74e5f9e2a801')
+    def test_create_zone_import_invalid_name(self):
+        LOG.info('Try to create a zone import using invalid name')
+        zone_import = self.client.create_zone_import(
+            zonefile_data=dns_data_utils.rand_zonefile_data(
+                name='@@@'), wait_until=const.ERROR)[1]
+        self.addCleanup(self._clean_up_resources, zone_import['id'])
+
+    @decorators.idempotent_id('8fd744d2-9dff-11ec-9fb6-201e8823901f')
+    def test_create_zone_import_invalid_file_data(self):
+        LOG.info('Try to create a zone import using random generated'
+                 ' import file data')
+        zone_file_data = dns_data_utils.rand_string(size=100)
+        zone_import = self.client.create_zone_import(zone_file_data)[1]
+        self.addCleanup(self.client.delete_zone_import, zone_import['id'])
+        waiters.wait_for_zone_import_status(
+            self.client, zone_import['id'], const.ERROR)
+
+    @decorators.idempotent_id('4fb9494e-9e23-11ec-8378-201e8823901f')
+    def test_zone_cannot_be_update_by_import(self):
+        LOG.info('Create a Zone named: "...zone_to_update..."')
+        zone_name = dns_data_utils.rand_zone_name(
+            name='zone_to_update', suffix=self.tld_name)
+        zone = self.zone_client.create_zone(
+            name=zone_name, wait_until=const.ACTIVE)[1]
+        self.addCleanup(self.wait_zone_delete, self.zone_client, zone['id'])
+        LOG.info('Use zone import to update an existing zone, expected: zone'
+                 ' import gets into the ERROR status ')
+        zone_import_data = dns_data_utils.rand_zonefile_data(name=zone_name)
+        zone_import = self.client.create_zone_import(zone_import_data)[1]
+        waiters.wait_for_zone_import_status(
+            self.client, zone_import['id'], const.ERROR)
+        self.addCleanup(self._clean_up_resources, zone_import['id'])
+
+    @decorators.idempotent_id('5fa8016e-6ed1-11ec-9bd7-201e8823901f')
+    def test_create_zone_import_invalid_content_type(self):
+        LOG.info('Try to create a zone import using: "Content-Type:Zahlabut"'
+                 ' HTTP header in POST request')
+        with self.assertRaisesDns(
+                lib_exc.InvalidContentType, 'unsupported_content_type', 415):
+            self.client.create_zone_import(
+                headers={'Content-Type': 'Zahlabut'})
diff --git a/designate_tempest_plugin/tests/scenario/v2/test_quotas.py b/designate_tempest_plugin/tests/scenario/v2/test_quotas.py
index c5725ed..17fd16f 100644
--- a/designate_tempest_plugin/tests/scenario/v2/test_quotas.py
+++ b/designate_tempest_plugin/tests/scenario/v2/test_quotas.py
@@ -11,13 +11,16 @@
 # 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 random
 from oslo_log import log as logging
 from tempest import config
 from tempest.lib import decorators
+from tempest.lib import exceptions as lib_exc
 
 from designate_tempest_plugin.tests import base
 from designate_tempest_plugin import data_utils as dns_data_utils
+from designate_tempest_plugin.common import constants as const
+
 
 LOG = logging.getLogger(__name__)
 
@@ -28,6 +31,7 @@
 class QuotasV2Test(base.BaseDnsV2Test):
 
     credentials = ['primary', 'admin', 'system_admin', 'alt']
+    test_quota_limit = 3
 
     @classmethod
     def setup_credentials(cls):
@@ -55,7 +59,9 @@
             cls.admin_tld_client = cls.os_admin.dns_v2.TldClient()
         cls.quotas_client = cls.os_primary.dns_v2.QuotasClient()
         cls.alt_client = cls.os_alt.dns_v2.QuotasClient()
+        cls.zone_client = cls.os_primary.dns_v2.ZonesClient()
         cls.alt_zone_client = cls.os_alt.dns_v2.ZonesClient()
+        cls.recordset_client = cls.os_primary.dns_v2.RecordsetClient()
 
     @classmethod
     def resource_setup(cls):
@@ -71,40 +77,203 @@
         cls.admin_tld_client.delete_tld(cls.class_tld[1]['id'])
         super(QuotasV2Test, cls).resource_cleanup()
 
-    @decorators.idempotent_id('6987953a-dccf-11eb-903e-74e5f9e2a801')
-    def test_alt_reaches_zones_quota(self):
-
-        alt_project_id = self.alt_client.project_id
-        http_header = {'x-auth-sudo-project-id': alt_project_id}
-        limit_zones_quota = 3
-
-        LOG.info('As Admin user set Zones quota for Alt user '
-                 'to:{} '.format(limit_zones_quota))
-        quotas = dns_data_utils.rand_quotas()
-        quotas['zones'] = limit_zones_quota
+    def _set_quota_for_project(self, project_id, quotas):
+        http_header = {'x-auth-sudo-project-id': project_id}
         self.admin_client.set_quotas(
-            project_id=alt_project_id, quotas=quotas, headers=http_header)
+            project_id=project_id, quotas=quotas, headers=http_header)
         self.addCleanup(
-            self.admin_client.delete_quotas, project_id=alt_project_id)
+            self.admin_client.delete_quotas,
+            project_id=project_id, headers=http_header)
 
-        LOG.info('As Alt user try to create zones, up untill'
-                 ' "zones" quota (status code 413) is reached')
+    def _reach_quota_limit(
+            self, limit_threshold, quota_type, zone=None):
         attempt_number = 0
-        while attempt_number <= limit_zones_quota + 1:
-            attempt_number += 1
-            LOG.info('Attempt No:{} '.format(attempt_number))
+        not_raised_msg = "Failed, expected '413 over_quota' response of " \
+                         "type:{} wasn't received.".format(quota_type)
+        while attempt_number <= limit_threshold + 1:
             try:
-                zone_name = dns_data_utils.rand_zone_name(
-                    name="alt_reaches_zones_quota", suffix=self.tld_name)
-                zone = self.alt_zone_client.create_zone(name=zone_name)[1]
-                self.addCleanup(
-                    self.wait_zone_delete, self.alt_zone_client, zone['id'])
-            except Exception as err:
-                raised_error = str(err).replace(' ', '')
-                if not "'code':413" and "'type':'over_quota'" in raised_error \
-                        and attempt_number == limit_zones_quota + 1:
-                    raise (
-                        "Failed, expected status code 413 (type:over_quota) "
-                        "was not raised or maybe it has been raised mistakenly"
-                        "(bug) before the quota was actually reached."
-                        " Test failed with: {} ".format(err))
+                attempt_number += 1
+                LOG.info('Attempt No:{} '.format(attempt_number))
+                if quota_type == 'zones_quota':
+                    zone_name = dns_data_utils.rand_zone_name(
+                        name="_reach_quota_limit", suffix=self.tld_name)
+                    zone = self.zone_client.create_zone(
+                        name=zone_name,
+                        description='Test zone for:{}'.format(quota_type))[1]
+                    self.addCleanup(
+                        self.wait_zone_delete,
+                        self.zone_client, zone['id'])
+                else:
+                    if quota_type == 'zone_recordsets':
+                        max_number_of_records = 10
+                        prj_quota = self.admin_client.show_quotas(
+                            project_id=self.zone_client.project_id,
+                            headers=self.all_projects_header)[1][
+                            'zone_records']
+                        if max_number_of_records > prj_quota:
+                            max_number_of_records = prj_quota
+                        recordset_data = dns_data_utils.rand_recordset_data(
+                            record_type='A', zone_name=zone['name'],
+                            number_of_records=random.randint(
+                                1, max_number_of_records))
+                    else:
+                        recordset_data = dns_data_utils.rand_recordset_data(
+                            record_type='A', zone_name=zone['name'])
+                    recordset = self.recordset_client.create_recordset(
+                        zone['id'], recordset_data=recordset_data,
+                        wait_until=const.ACTIVE)[1]
+                    self.addCleanup(
+                        self.wait_recordset_delete,
+                        self.recordset_client,
+                        zone['id'], recordset['id'])
+                self.assertLess(
+                    attempt_number, limit_threshold + 1, not_raised_msg)
+            except Exception as e:
+                raised_err = str(e).replace(' ', '')
+                if not_raised_msg in str(e):
+                    raise AssertionError(not_raised_msg)
+                elif "'code':413" in raised_err and \
+                        "'type':'over_quota'" in raised_err:
+                    LOG.info("OK, type':'over_quota' was raised")
+                    break
+                else:
+                    raise
+
+    @decorators.attr(type='slow')
+    @decorators.idempotent_id('41d9cf2c-866a-11ec-8ccb-201e8823901f')
+    @decorators.skip_because(bug="1960495")
+    def test_api_export_size_quota(self):
+        LOG.info('Admin sets "api_export_size:{}" quota for Primary'
+                 ' user'.format(self.test_quota_limit))
+        quotas = dns_data_utils.rand_quotas()
+        quotas['api_export_size'] = self.test_quota_limit
+        self._set_quota_for_project(
+            self.zone_client.project_id, quotas)
+        LOG.info('Create a Zone, wait until ACTIVE and add:{}'
+                 ' Recordsets'.format(self.test_quota_limit + 1))
+        zone = self.zone_client.create_zone(
+            description='Zone for test_api_export_size_quota',
+            wait_until=const.ACTIVE)[1]
+        self.addCleanup(
+            self.wait_zone_delete,
+            self.zone_client, zone['id'])
+        for i in range(self.test_quota_limit + 1):
+            recordset_data = dns_data_utils.rand_recordset_data(
+                record_type='A', zone_name=zone['name'])
+            LOG.info('Try to create a recordset No:{}'.format(i))
+            recordset = self.recordset_client.create_recordset(
+                zone['id'], recordset_data=recordset_data,
+                wait_until=const.ACTIVE)[1]
+            self.addCleanup(
+                self.wait_recordset_delete,
+                self.recordset_client,
+                zone['id'], recordset['id'])
+        LOG.info(
+            'Ensure that the Number of Recordsets is bigger than configured'
+            ' api_export_size:{}'.format(self.test_quota_limit))
+        number_of_recordsets = len(self.recordset_client.list_recordset(
+            zone['id'])[1]['recordsets'])
+        self.assertGreater(
+            number_of_recordsets, self.test_quota_limit,
+            'Failed, the number of recordsets within a Zone is not enough to'
+            ' trigger "413 over quota" on Zone Export')
+        LOG.info('Try to export Zone. Expected:"413 over_quota"')
+        with self.assertRaisesDns(
+                lib_exc.OverLimit, 'over_quota', 413):
+            self.export_zone_client.create_zone_export(zone['id'])
+
+    @decorators.attr(type='slow')
+    @decorators.idempotent_id('2513cb6e-85ec-11ec-bf7f-201e8823901f')
+    def test_recordset_records_quota(self):
+        LOG.info('Admin sets "recordset_records:{}" quota for Primary'
+                 ' user'.format(self.test_quota_limit))
+        quotas = dns_data_utils.rand_quotas()
+        quotas['recordset_records'] = self.test_quota_limit
+        self._set_quota_for_project(
+            self.zone_client.project_id, quotas)
+        LOG.info('Create a Zone and wait until ACTIVE')
+        zone_name = dns_data_utils.rand_zone_name(
+            name="test_recordset_records_quota", suffix=self.tld_name)
+        zone = self.zone_client.create_zone(
+            name=zone_name,
+            description='Zone for test_recordset_records_quota',
+            wait_until=const.ACTIVE)[1]
+        self.addCleanup(
+            self.wait_zone_delete,
+            self.zone_client, zone['id'])
+        LOG.info(
+            'Create recordset data with:{} records and try to create'
+            ' a recordset. Expected:"413 over_quota"'.format(
+                self.test_quota_limit + 1))
+        recordset_data = dns_data_utils.rand_recordset_data(
+            record_type='A', zone_name=zone['name'],
+            number_of_records=self.test_quota_limit + 1)
+        LOG.info('Try to create a recordset. Expected:"413 over_quota"')
+        with self.assertRaisesDns(
+                lib_exc.OverLimit, 'over_quota', 413):
+            self.recordset_client.create_recordset(
+                zone['id'], recordset_data=recordset_data)
+
+    @decorators.attr(type='slow')
+    @decorators.idempotent_id('893dc648-868d-11ec-8ccb-201e8823901f')
+    def test_zone_records_quota(self):
+        LOG.info('Create a Zone and wait until ACTIVE')
+        zone_name = dns_data_utils.rand_zone_name(
+            name="test_zone_records_quota", suffix=self.tld_name)
+        zone = self.zone_client.create_zone(
+            name=zone_name,
+            description='Zone for test_zone_records_quota',
+            wait_until=const.ACTIVE)[1]
+        self.addCleanup(
+            self.wait_zone_delete,
+            self.zone_client, zone['id'])
+        LOG.info('Admin sets "zone_records:{}" quota for Primary '
+                 'user'.format(self.test_quota_limit))
+        quotas = dns_data_utils.rand_quotas()
+        quotas['zone_records'] = self.test_quota_limit
+        self._set_quota_for_project(
+            self.zone_client.project_id, quotas)
+        LOG.info(
+            'Try to add:{} recordsets (with a single record) to the Zone in'
+            ' loop. Expected:"413 over_quota"'.format(
+                self.test_quota_limit + 1))
+        self._reach_quota_limit(
+            self.test_quota_limit + 1, 'zone_records', zone)
+
+    @decorators.attr(type='slow')
+    @decorators.idempotent_id('f567bdda-86b3-11ec-8ccb-201e8823901f')
+    def test_zone_recordsets_quota(self):
+        LOG.info('Create a Zone and wait until ACTIVE')
+        zone_name = dns_data_utils.rand_zone_name(
+            name="test_zone_recordsets_quota", suffix=self.tld_name)
+        zone = self.zone_client.create_zone(
+            name=zone_name,
+            description='Zone for test_zone_recordsets_quota',
+            wait_until=const.ACTIVE)[1]
+        self.addCleanup(
+            self.wait_zone_delete,
+            self.zone_client, zone['id'])
+        LOG.info('Admin sets "zone_recordsets:{}" quota for Primary '
+                 'user'.format(self.test_quota_limit))
+        quotas = dns_data_utils.rand_quotas()
+        quotas['zone_recordsets'] = self.test_quota_limit
+        self._set_quota_for_project(
+            self.zone_client.project_id, quotas)
+        LOG.info(
+            'Try to add:{} recordsets (with a random number of records) to a'
+            ' Zone in loop. Expected:"413 over_quota"'.format(
+                self.test_quota_limit + 1))
+        self._reach_quota_limit(
+            self.test_quota_limit + 1,
+            'zone_recordsets', zone)
+
+    @decorators.attr(type='slow')
+    @decorators.idempotent_id('6987953a-dccf-11eb-903e-74e5f9e2a801')
+    def test_zones_quota(self):
+        LOG.info('Admin sets "zones" quota for Primary user')
+        quotas = dns_data_utils.rand_quotas()
+        quotas['zones'] = self.test_quota_limit
+        self._set_quota_for_project(
+            self.zone_client.project_id, quotas)
+        LOG.info('Try to create Zones. Expected:"413 over_quota"')
+        self._reach_quota_limit(self.test_quota_limit, 'zones_quota')
diff --git a/designate_tempest_plugin/tests/scenario/v2/test_zones.py b/designate_tempest_plugin/tests/scenario/v2/test_zones.py
index 2c89c20..74f9563 100644
--- a/designate_tempest_plugin/tests/scenario/v2/test_zones.py
+++ b/designate_tempest_plugin/tests/scenario/v2/test_zones.py
@@ -11,6 +11,10 @@
 # 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 time
+import math
+
 from oslo_log import log as logging
 from tempest import config
 from tempest.lib import decorators
@@ -21,6 +25,10 @@
 from designate_tempest_plugin.tests import base
 from designate_tempest_plugin.common import constants as const
 from designate_tempest_plugin.common import waiters
+from designate_tempest_plugin.services.dns.query.query_client \
+    import SingleQueryClient
+
+CONF = config.CONF
 
 CONF = config.CONF
 LOG = logging.getLogger(__name__)
@@ -34,14 +42,16 @@
         super(ZonesTest, cls).setup_clients()
         if CONF.enforce_scope.designate:
             cls.admin_tld_client = cls.os_system_admin.dns_v2.TldClient()
+            cls.rec_client = cls.os_system_admin.dns_v2.RecordsetClient()
         else:
             cls.admin_tld_client = cls.os_admin.dns_v2.TldClient()
+            cls.rec_client = cls.os_admin.dns_v2.RecordsetClient()
         cls.client = cls.os_primary.dns_v2.ZonesClient()
+        cls.primary_client = cls.os_primary.dns_v2.BlacklistsClient()
 
     @classmethod
     def resource_setup(cls):
         super(ZonesTest, cls).resource_setup()
-
         # Make sure we have an allowed TLD available
         tld_name = dns_data_utils.rand_zone_name(name="ZonesTest")
         cls.tld_name = f".{tld_name}"
@@ -183,3 +193,66 @@
         waiters.wait_for_zone_404(self.client, zone['id'])
         waiters.wait_for_query(self.query_client, zone['name'], const.SOA,
                                found=False)
+
+    @decorators.attr(type='slow')
+    @decorators.idempotent_id('ff9b9fc4-85b4-11ec-bcf5-201e8823901f')
+    @testtools.skipUnless(
+        config.CONF.dns.nameservers,
+        "Config option dns.nameservers is missing or empty")
+    def test_notify_msg_sent_to_nameservers(self):
+
+        # Test will only run when the SOA record Refresh is close to one hour,
+        # otherwise skipped.
+        # This implies that the only reason "A" record was propagated is as a
+        # result of successfully sent NOTIFY message.
+
+        LOG.info('Create a zone, wait until ACTIVE and get the Serial'
+                 ' and SOA Refresh values')
+        zone_name = dns_data_utils.rand_zone_name(
+            name="test_notify_msg_sent_to_nameservers", suffix=self.tld_name)
+        zone = self.client.create_zone(name=zone_name, wait_until='ACTIVE')[1]
+
+        org_serial = zone['serial']
+        self.addCleanup(self.wait_zone_delete, self.client, zone['id'])
+        try:
+            soa = [
+                rec['records'] for rec in self.rec_client.list_recordset(
+                    zone['id'], headers=self.all_projects_header)[1][
+                    'recordsets'] if rec['type'] == 'SOA'][0]
+            refresh = int(soa[0].split(' ')[3])
+            if math.isclose(3600, refresh, rel_tol=0.1) is False:
+                raise self.skipException(
+                    'Test is skipped, actual SOA REFRESH is:{} unlike test'
+                    ' prerequisites that requires a value close to 3600'
+                    ' (one hour)'.format(refresh))
+        except Exception as e:
+            raise self.skipException(
+                'Test is skipped, something went wrong on getting SOA REFRESH'
+                ' value, the error was:{}'.format(e))
+
+        LOG.info("Update Zone's TTL, wait until ACTIVE and"
+                 " ensure Zone's Serial has changed")
+        updated_zone = self.client.update_zone(
+            zone['id'], ttl=dns_data_utils.rand_ttl(), wait_until='ACTIVE')[1]
+        new_serial = updated_zone['serial']
+        self.assertNotEqual(
+            new_serial, org_serial,
+            "Failed, expected behaviour is that the Designate DNS changes the"
+            " Serial after updating Zone's TTL value")
+        waiters.wait_for_query(self.query_client, zone['name'], "SOA")
+
+        LOG.info('Per Nameserver "dig" for a SOA record until either:'
+                 ' updated Serial is detected or build timeout has reached')
+        for ns in config.CONF.dns.nameservers:
+            start = time.time()
+            while True:
+                ns_obj = SingleQueryClient(ns, config.CONF.dns.query_timeout)
+                ns_soa_record = ns_obj.query(zone['name'], rdatatype='SOA')
+                if str(new_serial) in str(ns_soa_record):
+                    return
+                if time.time() - start >= config.CONF.dns.build_timeout:
+                    raise lib_exc.TimeoutException(
+                        'Failed, expected Serial:{} for a Zone was not'
+                        ' detected on Nameserver:{} within a timeout of:{}'
+                        ' seconds.'.format(
+                            new_serial, ns, config.CONF.dns.build_timeout))
diff --git a/designate_tempest_plugin/tests/scenario/v2/test_zones_import.py b/designate_tempest_plugin/tests/scenario/v2/test_zones_import.py
index 29db239..7286f23 100644
--- a/designate_tempest_plugin/tests/scenario/v2/test_zones_import.py
+++ b/designate_tempest_plugin/tests/scenario/v2/test_zones_import.py
@@ -14,6 +14,7 @@
 from oslo_log import log as logging
 from tempest.lib import decorators
 
+from designate_tempest_plugin.common import constants as const
 from designate_tempest_plugin.common import waiters
 from designate_tempest_plugin import data_utils as dns_data_utils
 from designate_tempest_plugin.tests.api.v2.test_zones_imports import \
@@ -41,29 +42,26 @@
         zonefile = dns_data_utils.rand_zonefile_data(name=zone_name)
 
         LOG.info('Import zone %r', zone_name)
-        _, zone_import = self.client.create_zone_import(zonefile)
+        zone_import = self.client.create_zone_import(
+            zonefile, wait_until=const.COMPLETE)[1]
         self.addCleanup(self.client.delete_zone_import, zone_import['id'])
 
-        LOG.info('Wait for the zone import to COMPLETE')
-        waiters.wait_for_zone_import_status(self.client, zone_import['id'],
-                                            "COMPLETE")
-
         LOG.info('Check the zone import looks good')
-        _, zone_import = self.client.show_zone_import(zone_import['id'])
+        zone_import = self.client.show_zone_import(zone_import['id'])[1]
         self.addCleanup(self.wait_zone_delete,
                         self.zones_client,
                         zone_import['zone_id'])
 
-        self.assertEqual('COMPLETE', zone_import['status'])
+        self.assertEqual(const.COMPLETE, zone_import['status'])
         self.assertIsNotNone(zone_import['zone_id'])
         self.assertIsNotNone(zone_import['links'].get('zone'))
 
         LOG.info('Wait for the imported zone to go to ACTIVE')
-        waiters.wait_for_zone_status(self.zones_client, zone_import['zone_id'],
-                                     "ACTIVE")
+        waiters.wait_for_zone_status(
+            self.zones_client, zone_import['zone_id'], const.ACTIVE)
 
         LOG.info('Check the imported zone looks good')
-        _, zone = self.zones_client.show_zone(zone_import['zone_id'])
-        self.assertEqual('NONE', zone['action'])
-        self.assertEqual('ACTIVE', zone['status'])
+        zone = self.zones_client.show_zone(zone_import['zone_id'])[1]
+        self.assertEqual(const.NONE, zone['action'])
+        self.assertEqual(const.ACTIVE, zone['status'])
         self.assertEqual(zone_name, zone['name'])