diff --git a/octavia_tempest_plugin/tests/api/v2/test_listener.py b/octavia_tempest_plugin/tests/api/v2/test_listener.py
index 46735a5..249c1ff 100644
--- a/octavia_tempest_plugin/tests/api/v2/test_listener.py
+++ b/octavia_tempest_plugin/tests/api/v2/test_listener.py
@@ -245,14 +245,26 @@
     def test_http_listener_create(self):
         self._test_listener_create(const.HTTP, 8000)
 
+    @decorators.idempotent_id('4aaf06a4-a9e0-440d-9ff8-d4be13ddea96')
+    def test_http_listener_create_no_allowed_cidrs(self):
+        self._test_listener_create(const.HTTP, 8100, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('2cc89237-fc6b-434d-b38e-b3309823e71f')
     def test_https_listener_create(self):
         self._test_listener_create(const.HTTPS, 8001)
 
+    @decorators.idempotent_id('6085be5d-c49c-4275-87a9-2e256dc2ac9b')
+    def test_https_listener_create_no_allowed_cidrs(self):
+        self._test_listener_create(const.HTTPS, 8101, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('45580065-5653-436b-aaff-dc465fa0a542')
     def test_tcp_listener_create(self):
         self._test_listener_create(const.TCP, 8002)
 
+    @decorators.idempotent_id('f20ab493-d92f-4c86-a053-0d788efaec11')
+    def test_tcp_listener_create_no_allowed_cidrs(self):
+        self._test_listener_create(const.TCP, 8102, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('1a6ba0d0-f309-4088-a686-dda0e9ab7e43')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
@@ -264,6 +276,18 @@
                                      'on Octavia API version 2.25 or newer.')
         self._test_listener_create(const.PROMETHEUS, 8090)
 
+    @decorators.idempotent_id('bfa264ec-c7dc-487a-9437-cb19d7aec7a3')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
+        'PROMETHEUS listener tests are disabled in the tempest configuration.')
+    def test_prometheus_listener_create_no_allowed_cidrs(self):
+        if not self.mem_listener_client.is_version_supported(
+                self.api_version, '2.25'):
+            raise self.skipException('PROMETHEUS listeners are only available '
+                                     'on Octavia API version 2.25 or newer.')
+        self._test_listener_create(const.PROMETHEUS, 8190,
+                                   use_allowed_cidrs=False)
+
     @decorators.idempotent_id('df9861c5-4a2a-4122-8d8f-5556156e343e')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
@@ -276,15 +300,37 @@
                 ' require the either the barbican service,or running in noop.')
         self._test_listener_create(const.TERMINATED_HTTPS, 8095)
 
+    @decorators.idempotent_id('3f91e0f6-e223-48ad-8c6a-b5a608cc8bb3')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
+        '[loadbalancer-feature-enabled] "terminated_tls_enabled" is '
+        'False in the tempest configuration. TLS tests will be skipped.')
+    def test_terminated_https_listener_create_no_allowed_cidrs(self):
+        if not self.should_apply_terminated_https():
+            raise self.skipException(
+                f'Listener API tests with {const.TERMINATED_HTTPS} protocol'
+                ' require the either the barbican service,or running in noop.')
+        self._test_listener_create(const.TERMINATED_HTTPS, 8195,
+                                   use_allowed_cidrs=False)
+
     @decorators.idempotent_id('7b53f336-47bc-45ae-bbd7-4342ef0673fc')
     def test_udp_listener_create(self):
         self._test_listener_create(const.UDP, 8003)
 
+    @decorators.idempotent_id('214a837a-7173-46d9-a83b-a6e80f9295da')
+    def test_udp_listener_create_no_allowed_cidrs(self):
+        self._test_listener_create(const.UDP, 8103, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('d6d36c32-27ff-4977-9d21-fd71a14e3b20')
     def test_sctp_listener_create(self):
         self._test_listener_create(const.SCTP, 8004)
 
-    def _test_listener_create(self, protocol, protocol_port):
+    @decorators.idempotent_id('bc38ac9b-7241-4047-b5aa-815f11359cf2')
+    def test_sctp_listener_create_no_allowed_cidrs(self):
+        self._test_listener_create(const.SCTP, 8104, use_allowed_cidrs=False)
+
+    def _test_listener_create(self, protocol, protocol_port,
+                              use_allowed_cidrs=True):
         """Tests listener create and basic show APIs.
 
         * Tests that users without the loadbalancer member role cannot
@@ -345,7 +391,7 @@
             })
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             # Test that CIDR IP version matches VIP IP version
             bad_cidrs = ['192.0.1.0/24', '2001:db8:a0b:12f0::/64']
             listener_kwargs.update({const.ALLOWED_CIDRS: bad_cidrs})
@@ -448,7 +494,7 @@
                                   listener[const.TAGS])
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             self.assertEqual(self.allowed_cidrs, listener[const.ALLOWED_CIDRS])
 
     @decorators.idempotent_id('cceac303-4db5-4d5a-9f6e-ff33780a5f29')
@@ -679,10 +725,18 @@
     def test_http_listener_list(self):
         self._test_listener_list(const.HTTP, 8020)
 
+    @decorators.idempotent_id('3a753098-2b7c-43f9-b3f2-2be5576ec594')
+    def test_http_listener_list_no_allowed_cidrs(self):
+        self._test_listener_list(const.HTTP, 8120, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('61b7c643-f5fa-4471-8f9e-2e0ccdaf5ac7')
     def test_https_listener_list(self):
         self._test_listener_list(const.HTTPS, 8030)
 
+    @decorators.idempotent_id('e6c05d39-b76a-4245-83c2-0fc889e1e955')
+    def test_https_listener_list_no_allowed_cidrs(self):
+        self._test_listener_list(const.HTTPS, 8130, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('5473e071-8277-4ac5-9277-01ecaf46e274')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
@@ -694,18 +748,42 @@
                                      'on Octavia API version 2.25 or newer.')
         self._test_listener_list(const.PROMETHEUS, 8091)
 
+    @decorators.idempotent_id('71dd1ab0-b203-468e-9333-690847b848ee')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
+        'PROMETHEUS listener tests are disabled in the tempest configuration.')
+    def test_prometheus_listener_list_no_allowed_cidrs(self):
+        if not self.mem_listener_client.is_version_supported(
+                self.api_version, '2.25'):
+            raise self.skipException('PROMETHEUS listeners are only available '
+                                     'on Octavia API version 2.25 or newer.')
+        self._test_listener_list(const.PROMETHEUS, 8191,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('1cd476e2-7788-415e-bcaf-c377acfc9794')
     def test_tcp_listener_list(self):
         self._test_listener_list(const.TCP, 8030)
 
+    @decorators.idempotent_id('bdfe190e-6cee-46ae-a7cf-4acf617339df')
+    def test_tcp_listener_list_no_allowed_cidrs(self):
+        self._test_listener_list(const.TCP, 8130, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('c08fb77e-b317-4d6f-b430-91f5b27ebac6')
     def test_udp_listener_list(self):
         self._test_listener_list(const.UDP, 8040)
 
+    @decorators.idempotent_id('d2fbaf87-8441-4d66-a1c7-f9e2b246a419')
+    def test_udp_listener_list_no_allowed_cidrs(self):
+        self._test_listener_list(const.UDP, 8140, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('0abc3998-aacd-4edd-88f5-c5c35557646f')
     def test_sctp_listener_list(self):
         self._test_listener_list(const.SCTP, 8041)
 
+    @decorators.idempotent_id('b8a52d1a-97c9-4356-abe6-2ac9e90eed0c')
+    def test_sctp_listener_list_no_allowed_cidrs(self):
+        self._test_listener_list(const.SCTP, 8141, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('aed69f58-fe69-401d-bf07-37b0d6d8437f')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
@@ -718,7 +796,21 @@
                 ' require the either the barbican service,or running in noop.')
         self._test_listener_list(const.TERMINATED_HTTPS, 8042)
 
-    def _test_listener_list(self, protocol, protocol_port_base):
+    @decorators.idempotent_id('0f0b5021-245e-42bd-84d5-c089c2028cf5')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
+        '[loadbalancer-feature-enabled] "terminated_tls_enabled" is '
+        'False in the tempest configuration. TLS tests will be skipped.')
+    def test_terminated_https_listener_list_no_allowed_cidrs(self):
+        if not self.should_apply_terminated_https():
+            raise self.skipException(
+                f'Listener API tests with {const.TERMINATED_HTTPS} protocol'
+                ' require the either the barbican service,or running in noop.')
+        self._test_listener_list(const.TERMINATED_HTTPS, 8142,
+                                 use_allowed_cidrs=False)
+
+    def _test_listener_list(self, protocol, protocol_port_base,
+                            use_allowed_cidrs=True):
         """Tests listener list API and field filtering.
 
         * Create a clean loadbalancer.
@@ -1010,7 +1102,7 @@
             show_listener_response_fields.append('timeout_member_data')
             show_listener_response_fields.append('timeout_tcp_inspect')
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             show_listener_response_fields.append('allowed_cidrs')
         if self.mem_listener_client.is_version_supported(
                 self.api_version, '2.27'):
@@ -1098,10 +1190,18 @@
     def test_http_listener_show(self):
         self._test_listener_show(const.HTTP, 8050)
 
+    @decorators.idempotent_id('f852a76d-f41c-48e4-9c73-6f99d49af581')
+    def test_http_listener_show_no_allowed_cidrs(self):
+        self._test_listener_show(const.HTTP, 8150, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('aa838646-435f-4a20-8442-519a7a138e7e')
     def test_https_listener_show(self):
         self._test_listener_show(const.HTTPS, 8051)
 
+    @decorators.idempotent_id('00ff83ca-e286-4080-b9ec-850979e676bb')
+    def test_https_listener_show_no_allowed_cidrs(self):
+        self._test_listener_show(const.HTTPS, 8151, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('b851b754-4333-4115-9063-a9fce44c2e46')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
@@ -1113,18 +1213,42 @@
                                      'on Octavia API version 2.25 or newer.')
         self._test_listener_show(const.PROMETHEUS, 8092)
 
+    @decorators.idempotent_id('6fd0c3ae-d091-4c45-aa72-447581ec7939')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
+        'PROMETHEUS listener tests are disabled in the tempest configuration.')
+    def test_prometheus_listener_show_no_allowed_cidrs(self):
+        if not self.mem_listener_client.is_version_supported(
+                self.api_version, '2.25'):
+            raise self.skipException('PROMETHEUS listeners are only available '
+                                     'on Octavia API version 2.25 or newer.')
+        self._test_listener_show(const.PROMETHEUS, 8192,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('1fcbbee2-b697-4890-b6bf-d308ac1c94cd')
     def test_tcp_listener_show(self):
         self._test_listener_show(const.TCP, 8052)
 
+    @decorators.idempotent_id('916d36b8-9211-4a4f-aa84-3ed38477afd3')
+    def test_tcp_listener_show_no_allowed_cidrs(self):
+        self._test_listener_show(const.TCP, 8152, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('1dea3a6b-c95b-4e91-b591-1aa9cbcd0d1d')
     def test_udp_listener_show(self):
         self._test_listener_show(const.UDP, 8053)
 
+    @decorators.idempotent_id('38201807-28d0-4e29-9796-58db3280484f')
+    def test_udp_listener_show_no_allowed_cidrs(self):
+        self._test_listener_show(const.UDP, 8153, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('10992529-1d0a-47a3-855c-3dbcd868db4e')
     def test_sctp_listener_show(self):
         self._test_listener_show(const.SCTP, 8054)
 
+    @decorators.idempotent_id('6755f564-c8b1-40a1-8514-4893feb6e54d')
+    def test_sctp_listener_show_no_allowed_cidrs(self):
+        self._test_listener_show(const.SCTP, 8154, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('2c2e7146-0efc-44b6-8401-f1c69c2422fe')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
@@ -1137,7 +1261,21 @@
                 ' require the either the barbican service,or running in noop.')
         self._test_listener_show(const.TERMINATED_HTTPS, 8055)
 
-    def _test_listener_show(self, protocol, protocol_port):
+    @decorators.idempotent_id('9d7bd568-cc8b-49fe-bfed-f612944bd489')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
+        '[loadbalancer-feature-enabled] "terminated_tls_enabled" is '
+        'False in the tempest configuration. TLS tests will be skipped.')
+    def test_terminated_https_listener_show_no_allowed_cidrs(self):
+        if not self.should_apply_terminated_https():
+            raise self.skipException(
+                f'Listener API tests with {const.TERMINATED_HTTPS} protocol'
+                ' require the either the barbican service,or running in noop.')
+        self._test_listener_show(const.TERMINATED_HTTPS, 8155,
+                                 use_allowed_cidrs=False)
+
+    def _test_listener_show(self, protocol, protocol_port,
+                            use_allowed_cidrs=True):
         """Tests listener show API.
 
         * Create a fully populated listener.
@@ -1199,7 +1337,7 @@
             })
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             listener_kwargs.update({const.ALLOWED_CIDRS: self.allowed_cidrs})
 
         listener = self.mem_listener_client.create_listener(**listener_kwargs)
@@ -1274,7 +1412,7 @@
             self.assertEqual(const.ONLINE, listener[const.OPERATING_STATUS])
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             self.assertEqual(self.allowed_cidrs, listener[const.ALLOWED_CIDRS])
 
         if hsts_supported:
@@ -1299,10 +1437,18 @@
     def test_http_listener_update(self):
         self._test_listener_update(const.HTTP, 8060)
 
+    @decorators.idempotent_id('8ee610b6-af92-4a59-8332-370b4d529250')
+    def test_http_listener_update_no_allowed_cidrs(self):
+        self._test_listener_update(const.HTTP, 8160, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('9679b061-2b2c-469f-abd9-26ed140ef001')
     def test_https_listener_update(self):
         self._test_listener_update(const.HTTPS, 8061)
 
+    @decorators.idempotent_id('cae9f1e2-c395-427a-a150-26ef864d6e83')
+    def test_https_listener_update_no_allowed_cidrs(self):
+        self._test_listener_update(const.HTTPS, 8161, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('cbba6bf8-9184-4da5-95e9-5efe1f89ddf0')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
@@ -1314,18 +1460,42 @@
                                      'on Octavia API version 2.25 or newer.')
         self._test_listener_update(const.PROMETHEUS, 8093)
 
+    @decorators.idempotent_id('cbc8ffa9-750f-4050-938a-555594f76916')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.prometheus_listener_enabled,
+        'PROMETHEUS listener tests are disabled in the tempest configuration.')
+    def test_prometheus_listener_update_no_allowed_cidrs(self):
+        if not self.mem_listener_client.is_version_supported(
+                self.api_version, '2.25'):
+            raise self.skipException('PROMETHEUS listeners are only available '
+                                     'on Octavia API version 2.25 or newer.')
+        self._test_listener_update(const.PROMETHEUS, 8193,
+                                   use_allowed_cidrs=False)
+
     @decorators.idempotent_id('8d933121-db03-4ccc-8b77-4e879064a9ba')
     def test_tcp_listener_update(self):
         self._test_listener_update(const.TCP, 8062)
 
+    @decorators.idempotent_id('64b20147-59f0-4ce5-9390-d03767ae12c4')
+    def test_tcp_listener_update_no_allowed_cidrs(self):
+        self._test_listener_update(const.TCP, 8162, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('fd02dbfd-39ce-41c2-b181-54fc7ad91707')
     def test_udp_listener_update(self):
         self._test_listener_update(const.UDP, 8063)
 
+    @decorators.idempotent_id('1cf09eeb-c983-4dd6-b5d3-d36fb61830b2')
+    def test_udp_listener_update_no_allowed_cidrs(self):
+        self._test_listener_update(const.UDP, 8163, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('c590b485-4e08-4e49-b384-2282b3f6f1b9')
     def test_sctp_listener_update(self):
         self._test_listener_update(const.SCTP, 8064)
 
+    @decorators.idempotent_id('818d840a-c1e9-426b-92b9-c5131df2ba4f')
+    def test_sctp_listener_update_no_allowed_cidrs(self):
+        self._test_listener_update(const.SCTP, 8164, use_allowed_cidrs=False)
+
     @decorators.idempotent_id('2ae08e10-fbf8-46d8-a073-15f90454d718')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
@@ -1338,7 +1508,21 @@
                 ' require the either the barbican service,or running in noop.')
         self._test_listener_update(const.TERMINATED_HTTPS, 8065)
 
-    def _test_listener_update(self, protocol, protocol_port):
+    @decorators.idempotent_id('32e88736-6ba1-4d14-83ef-ebdb3e3950e4')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
+        '[loadbalancer-feature-enabled] "terminated_tls_enabled" is '
+        'False in the tempest configuration. TLS tests will be skipped.')
+    def test_terminated_https_listener_update_no_allowed_cidrs(self):
+        if not self.should_apply_terminated_https():
+            raise self.skipException(
+                f'Listener API tests with {const.TERMINATED_HTTPS} protocol'
+                ' require the either the barbican service,or running in noop.')
+        self._test_listener_update(const.TERMINATED_HTTPS, 8165,
+                                   use_allowed_cidrs=False)
+
+    def _test_listener_update(self, protocol, protocol_port,
+                              use_allowed_cidrs=True):
         """Tests listener update and show APIs.
 
         * Create a fully populated listener.
@@ -1398,7 +1582,7 @@
             })
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             listener_kwargs.update({const.ALLOWED_CIDRS: self.allowed_cidrs})
 
         listener = self.mem_listener_client.create_listener(**listener_kwargs)
@@ -1459,7 +1643,7 @@
                                   listener[const.TAGS])
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             self.assertEqual(self.allowed_cidrs, listener[const.ALLOWED_CIDRS])
 
         # Test that a user without the loadbalancer role cannot
@@ -1514,7 +1698,7 @@
             })
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             # Test that CIDR IP version matches VIP IP version
             bad_cidrs = ['192.0.2.0/24', '2001:db8::/6']
             listener_update_kwargs.update({const.ALLOWED_CIDRS: bad_cidrs})
@@ -1592,7 +1776,7 @@
                                   listener[const.TAGS])
 
         if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+                self.api_version, '2.12') and use_allowed_cidrs:
             expected_cidrs = ['192.0.2.0/24']
             if CONF.load_balancer.test_with_ipv6:
                 expected_cidrs = ['2001:db8::/64']
@@ -1716,22 +1900,47 @@
     def test_http_listener_show_stats(self):
         self._test_listener_show_stats(const.HTTP, 8080)
 
+    @decorators.idempotent_id('2a97a5f3-f05c-447c-80a7-326efcf31ab2')
+    def test_http_listener_show_stats_no_allowed_cidrs(self):
+        self._test_listener_show_stats(const.HTTP, 8180,
+                                       use_allowed_cidrs=False)
+
     @decorators.idempotent_id('f8a43c27-f0a0-496d-a287-1958f337ac04')
     def test_https_listener_show_stats(self):
         self._test_listener_show_stats(const.HTTPS, 8081)
 
+    @decorators.idempotent_id('9766962d-6819-4cb7-944a-899fef3fa241')
+    def test_https_listener_show_stats_no_allowed_cidrs(self):
+        self._test_listener_show_stats(const.HTTPS, 8181,
+                                       use_allowed_cidrs=False)
+
     @decorators.idempotent_id('8a999856-f448-498c-b891-21af449b5208')
     def test_tcp_listener_show_stats(self):
         self._test_listener_show_stats(const.TCP, 8082)
 
+    @decorators.idempotent_id('6afaea72-f4ed-4f15-a1c3-57ed16f12068')
+    def test_tcp_listener_show_stats_no_allowed_cidrs(self):
+        self._test_listener_show_stats(const.TCP, 8182,
+                                       use_allowed_cidrs=False)
+
     @decorators.idempotent_id('a4c1f199-923b-41e4-a134-c91e590e20c4')
     def test_udp_listener_show_stats(self):
         self._test_listener_show_stats(const.UDP, 8083)
 
+    @decorators.idempotent_id('45a120c4-9bd1-4032-ae5e-9b6458598b3d')
+    def test_udp_listener_show_stats_no_allowed_cidrs(self):
+        self._test_listener_show_stats(const.UDP, 8183,
+                                       use_allowed_cidrs=False)
+
     @decorators.idempotent_id('7f6d3906-529c-4b99-8376-b836059df220')
     def test_sctp_listener_show_stats(self):
         self._test_listener_show_stats(const.SCTP, 8084)
 
+    @decorators.idempotent_id('460f2308-9411-4ab2-9b9e-23fe87c9dec3')
+    def test_sctp_listener_show_stats_no_allowed_cidrs(self):
+        self._test_listener_show_stats(const.SCTP, 8184,
+                                       use_allowed_cidrs=False)
+
     @decorators.idempotent_id('c39c996f-9633-4d81-a5f1-e94643f0c650')
     @testtools.skipUnless(
         CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
@@ -1744,7 +1953,21 @@
                 ' require the either the barbican service,or running in noop.')
         self._test_listener_show_stats(const.TERMINATED_HTTPS, 8085)
 
-    def _test_listener_show_stats(self, protocol, protocol_port):
+    @decorators.idempotent_id('a402f84c-a29e-4e24-8ef6-f7eb8b0ffc46')
+    @testtools.skipUnless(
+        CONF.loadbalancer_feature_enabled.terminated_tls_enabled,
+        '[loadbalancer-feature-enabled] "terminated_tls_enabled" is '
+        'False in the tempest configuration. TLS tests will be skipped.')
+    def test_terminated_https_listener_show_stats_no_allowed_cidrs(self):
+        if not self.should_apply_terminated_https():
+            raise self.skipException(
+                f'Listener API tests with {const.TERMINATED_HTTPS} protocol'
+                ' require the either the barbican service,or running in noop.')
+        self._test_listener_show_stats(const.TERMINATED_HTTPS, 8085,
+                                       use_allowed_cidrs=False)
+
+    def _test_listener_show_stats(self, protocol, protocol_port,
+                                  use_allowed_cidrs=True):
         """Tests listener show statistics API.
 
         * Create a listener.
@@ -1776,6 +1999,10 @@
                                            self.SNI2_secret_ref],
             })
 
+        if self.mem_listener_client.is_version_supported(
+                self.api_version, '2.12') and use_allowed_cidrs:
+            listener_kwargs.update({const.ALLOWED_CIDRS: self.allowed_cidrs})
+
         listener = self.mem_listener_client.create_listener(**listener_kwargs)
         self.addCleanup(
             self.mem_listener_client.cleanup_listener,
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_listener.py b/octavia_tempest_plugin/tests/scenario/v2/test_listener.py
index be997aa..74514f2 100644
--- a/octavia_tempest_plugin/tests/scenario/v2/test_listener.py
+++ b/octavia_tempest_plugin/tests/scenario/v2/test_listener.py
@@ -118,54 +118,117 @@
                                           const.LB_ALGORITHM_LEAST_CONNECTIONS)
         self._test_listener_CRUD(const.HTTP, pool1, pool2)
 
+    @decorators.idempotent_id('d6d729ba-b03f-496c-8e0f-53704cd4994d')
+    def test_http_least_connections_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.HTTP,
+                                          const.LB_ALGORITHM_LEAST_CONNECTIONS)
+        self._test_listener_CRUD(const.HTTP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('0681b2ac-8301-4e6c-bf29-b35244864af3')
     def test_tcp_least_connections_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.TCP,
                                           const.LB_ALGORITHM_LEAST_CONNECTIONS)
         self._test_listener_CRUD(const.TCP, pool1, pool2)
 
+    @decorators.idempotent_id('10c5ecc8-533d-403c-9eb1-e3ca83586781')
+    def test_tcp_least_connections_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.TCP,
+                                          const.LB_ALGORITHM_LEAST_CONNECTIONS)
+        self._test_listener_CRUD(const.TCP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('27a2ba7d-6147-46e4-886a-47c1ba63bf89')
     def test_udp_least_connections_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.UDP,
                                           const.LB_ALGORITHM_LEAST_CONNECTIONS)
         self._test_listener_CRUD(const.UDP, pool1, pool2)
 
+    @decorators.idempotent_id('76776488-b38d-418e-9804-e0be4a443b51')
+    def test_udp_least_connections_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.UDP,
+                                          const.LB_ALGORITHM_LEAST_CONNECTIONS)
+        self._test_listener_CRUD(const.UDP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('4a874014-b7d1-49a4-ac9a-2400b3434700')
     def test_http_round_robin_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.HTTP,
                                           const.LB_ALGORITHM_ROUND_ROBIN)
         self._test_listener_CRUD(const.HTTP, pool1, pool2)
 
+    @decorators.idempotent_id('a2d8e2ca-5104-41b0-b011-819782e01054')
+    def test_http_round_robin_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.HTTP,
+                                          const.LB_ALGORITHM_ROUND_ROBIN)
+        self._test_listener_CRUD(const.HTTP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('2b888812-d916-44f0-b620-8d83dbb45975')
     def test_tcp_round_robin_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.TCP,
                                           const.LB_ALGORITHM_ROUND_ROBIN)
         self._test_listener_CRUD(const.TCP, pool1, pool2)
 
+    @decorators.idempotent_id('1b2bfce6-29f9-4af6-87f2-329654c03c3d')
+    def test_tcp_round_robin_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.TCP,
+                                          const.LB_ALGORITHM_ROUND_ROBIN)
+        self._test_listener_CRUD(const.TCP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('dd913f74-c6a6-4998-9bed-095babb9cb47')
     def test_udp_round_robin_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.UDP,
                                           const.LB_ALGORITHM_ROUND_ROBIN)
         self._test_listener_CRUD(const.UDP, pool1, pool2)
 
+    @decorators.idempotent_id('4a938409-eb79-4a9b-b003-44115153163d')
+    def test_udp_round_robin_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.UDP,
+                                          const.LB_ALGORITHM_ROUND_ROBIN)
+        self._test_listener_CRUD(const.UDP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('b2ae8604-7a4f-477c-9658-fac27734671a')
     def test_http_source_ip_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.HTTP,
                                           const.LB_ALGORITHM_SOURCE_IP)
         self._test_listener_CRUD(const.HTTP, pool1, pool2)
 
+    @decorators.idempotent_id('baa747b1-0b3c-4f56-a1d1-b5550ec69c6e')
+    def test_http_source_ip_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.HTTP,
+                                          const.LB_ALGORITHM_SOURCE_IP)
+        self._test_listener_CRUD(const.HTTP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('0ad3fdee-e8c2-4c44-9690-b8a838fbc7a5')
     def test_tcp_source_ip_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.TCP,
                                           const.LB_ALGORITHM_SOURCE_IP)
         self._test_listener_CRUD(const.TCP, pool1, pool2)
 
+    @decorators.idempotent_id('3778e729-8c5b-4634-876a-8bacba0976c2')
+    def test_tcp_source_ip_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.TCP,
+                                          const.LB_ALGORITHM_SOURCE_IP)
+        self._test_listener_CRUD(const.TCP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('7830aba8-12ca-40d9-9d9b-a63f7a43b287')
     def test_udp_source_ip_listener_CRUD(self):
         pool1, pool2 = self._create_pools(const.UDP,
                                           const.LB_ALGORITHM_SOURCE_IP)
         self._test_listener_CRUD(const.UDP, pool1, pool2)
 
+    @decorators.idempotent_id('8d98b27b-f775-4f1b-8b74-88ec2e60e39f')
+    def test_udp_source_ip_listener_CRUD_no_allowed_cidrs(self):
+        pool1, pool2 = self._create_pools(const.UDP,
+                                          const.LB_ALGORITHM_SOURCE_IP)
+        self._test_listener_CRUD(const.UDP, pool1, pool2,
+                                 use_allowed_cidrs=False)
+
     @decorators.idempotent_id('807a421e-5e99-4556-b0eb-512d39b25eac')
     def test_http_source_ip_port_listener_CRUD(self):
         try:
@@ -180,6 +243,21 @@
                 message = e.resp_body.get('faultstring', message)
             raise testtools.TestCase.skipException(message)
 
+    @decorators.idempotent_id('1d522a51-4fa0-4b8e-9f72-292e0f145bf1')
+    def test_http_source_ip_port_listener_CRUD_no_allowed_cidrs(self):
+        try:
+            pool1, pool2 = self._create_pools(
+                const.HTTP, const.LB_ALGORITHM_SOURCE_IP_PORT)
+            self._test_listener_CRUD(const.HTTP, pool1, pool2,
+                                     use_allowed_cidrs=False)
+        except exceptions.NotImplemented as e:
+            message = ("The configured provider driver '{driver}' "
+                       "does not support a feature required for this "
+                       "test.".format(driver=CONF.load_balancer.provider))
+            if hasattr(e, 'resp_body'):
+                message = e.resp_body.get('faultstring', message)
+            raise testtools.TestCase.skipException(message)
+
     @decorators.idempotent_id('6211f8ad-622d-404d-b199-8c2eb55ab340')
     def test_tcp_source_ip_port_listener_CRUD(self):
         try:
@@ -194,6 +272,21 @@
                 message = e.resp_body.get('faultstring', message)
             raise testtools.TestCase.skipException(message)
 
+    @decorators.idempotent_id('a66d32f9-2186-437e-a145-139f5a1b0786')
+    def test_tcp_source_ip_port_listener_CRUD_no_allowed_cidrs(self):
+        try:
+            pool1, pool2 = self._create_pools(
+                const.TCP, const.LB_ALGORITHM_SOURCE_IP_PORT)
+            self._test_listener_CRUD(const.TCP, pool1, pool2,
+                                     use_allowed_cidrs=False)
+        except exceptions.NotImplemented as e:
+            message = ("The configured provider driver '{driver}' "
+                       "does not support a feature required for this "
+                       "test.".format(driver=CONF.load_balancer.provider))
+            if hasattr(e, 'resp_body'):
+                message = e.resp_body.get('faultstring', message)
+            raise testtools.TestCase.skipException(message)
+
     @decorators.idempotent_id('3f9a2de9-5012-437d-a907-a25e1f68ccfb')
     def test_udp_source_ip_port_listener_CRUD(self):
         try:
@@ -208,7 +301,23 @@
                 message = e.resp_body.get('faultstring', message)
             raise testtools.TestCase.skipException(message)
 
-    def _test_listener_CRUD(self, protocol, pool1_id, pool2_id):
+    @decorators.idempotent_id('dff6d829-9122-47cb-9ce5-f2def7fcf902')
+    def test_udp_source_ip_port_listener_CRUD_no_allowed_cidrs(self):
+        try:
+            pool1, pool2 = self._create_pools(
+                const.UDP, const.LB_ALGORITHM_SOURCE_IP_PORT)
+            self._test_listener_CRUD(const.UDP, pool1, pool2,
+                                     use_allowed_cidrs=False)
+        except exceptions.NotImplemented as e:
+            message = ("The configured provider driver '{driver}' "
+                       "does not support a feature required for this "
+                       "test.".format(driver=CONF.load_balancer.provider))
+            if hasattr(e, 'resp_body'):
+                message = e.resp_body.get('faultstring', message)
+            raise testtools.TestCase.skipException(message)
+
+    def _test_listener_CRUD(self, protocol, pool1_id, pool2_id,
+                            use_allowed_cidrs=True):
         """Tests listener create, read, update, delete
 
         * Create a fully populated listener.
@@ -249,8 +358,9 @@
                 const.TIMEOUT_MEMBER_DATA: 1000,
                 const.TIMEOUT_TCP_INSPECT: 50,
             })
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+        if (use_allowed_cidrs and
+                self.mem_listener_client.is_version_supported(
+                    self.api_version, '2.12')):
             listener_kwargs.update({const.ALLOWED_CIDRS: self.allowed_cidrs})
 
         listener = self.mem_listener_client.create_listener(**listener_kwargs)
@@ -295,8 +405,9 @@
             self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_CONNECT])
             self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_DATA])
             self.assertEqual(50, listener[const.TIMEOUT_TCP_INSPECT])
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+        if (use_allowed_cidrs and
+                self.mem_listener_client.is_version_supported(
+                    self.api_version, '2.12')):
             self.assertEqual(self.allowed_cidrs, listener[const.ALLOWED_CIDRS])
 
         # Listener update
@@ -328,9 +439,9 @@
                 const.TIMEOUT_MEMBER_DATA: 2000,
                 const.TIMEOUT_TCP_INSPECT: 100,
             })
-
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+        if (use_allowed_cidrs and
+                self.mem_listener_client.is_version_supported(
+                    self.api_version, '2.12')):
             new_cidrs = ['192.0.2.0/24']
             if CONF.load_balancer.test_with_ipv6:
                 new_cidrs = ['2001:db8::/64']
@@ -382,8 +493,9 @@
             self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_CONNECT])
             self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_DATA])
             self.assertEqual(100, listener[const.TIMEOUT_TCP_INSPECT])
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.12'):
+        if (use_allowed_cidrs and
+                self.mem_listener_client.is_version_supported(
+                    self.api_version, '2.12')):
             expected_cidrs = ['192.0.2.0/24']
             if CONF.load_balancer.test_with_ipv6:
                 expected_cidrs = ['2001:db8::/64']