diff --git a/octavia_tempest_plugin/tests/api/v2/test_healthmonitor.py b/octavia_tempest_plugin/tests/api/v2/test_healthmonitor.py
deleted file mode 100644
index 4887995..0000000
--- a/octavia_tempest_plugin/tests/api/v2/test_healthmonitor.py
+++ /dev/null
@@ -1,803 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-from uuid import UUID
-
-from dateutil import parser
-from oslo_log import log as logging
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-LOG = logging.getLogger(__name__)
-
-
-class HealthMonitorAPITest(test_base.LoadBalancerBaseTest):
-    """Test the healthmonitor object API."""
-
-    @classmethod
-    def skip_checks(cls):
-        super(HealthMonitorAPITest, cls).skip_checks()
-        if not CONF.loadbalancer_feature_enabled.health_monitor_enabled:
-            cls.skip('Health Monitors not supported')
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(HealthMonitorAPITest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_hm")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-    @decorators.idempotent_id('30288670-5772-40c2-92e6-6d4a6d62d029')
-    def test_healthmonitor_create(self):
-        """Tests healthmonitor create and basic show APIs.
-
-        * Create a clean pool to use for the healthmonitor.
-        * Tests that users without the loadbalancer member role cannot
-          create healthmonitors.
-        * Create a fully populated healthmonitor.
-        * Show healthmonitor details.
-        * Validate the show reflects the requested values.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1_hm-create")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        hm_name = data_utils.rand_name("lb_member_hm1-create")
-        hm_kwargs = {
-            const.POOL_ID: pool[const.ID],
-            const.NAME: hm_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-            const.MAX_RETRIES_DOWN: 5,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/',
-            const.EXPECTED_CODES: '200-204',
-            const.ADMIN_STATE_UP: True,
-        }
-
-        # Test that a user without the loadbalancer role cannot
-        # create a healthmonitor
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.healthmonitor_client.create_healthmonitor,
-                **hm_kwargs)
-
-        hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        parser.parse(hm[const.CREATED_AT])
-        parser.parse(hm[const.UPDATED_AT])
-        UUID(hm[const.ID])
-
-        # Healthmonitors are always ONLINE
-        self.assertEqual(const.ONLINE, hm[const.OPERATING_STATUS])
-
-        equal_items = [const.NAME, const.TYPE, const.DELAY, const.TIMEOUT,
-                       const.MAX_RETRIES, const.MAX_RETRIES_DOWN,
-                       const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES,
-                       const.ADMIN_STATE_UP]
-
-        for item in equal_items:
-            self.assertEqual(hm_kwargs[item], hm[item])
-
-    # Helper functions for test healthmonitor list
-    def _filter_hms_by_pool_id(self, hms, pool_ids):
-        return [hm for hm in hms
-                if hm[const.POOLS][0][const.ID] in pool_ids]
-
-    def _filter_hms_by_index(self, hms, indexes):
-        return [hm for i, hm in enumerate(hms) if i not in indexes]
-
-    @decorators.idempotent_id('c9a9f20c-3680-4ae8-b657-33c687258fea')
-    def test_healthmonitor_list(self):
-        """Tests healthmonitor list API and field filtering.
-
-        * Create three clean pools to use for the healthmonitors.
-        * Create three healthmonitors.
-        * Validates that other accounts cannot list the healthmonitors.
-        * List the healthmonitors using the default sort order.
-        * List the healthmonitors using descending sort order.
-        * List the healthmonitors using ascending sort order.
-        * List the healthmonitors returning one field at a time.
-        * List the healthmonitors returning two fields.
-        * List the healthmonitors filtering to one of the three.
-        * List the healthmonitors filtered, one field, and sorted.
-        """
-        # Get a list of pre-existing HMs to filter from test data
-        pretest_hms = self.mem_healthmonitor_client.list_healthmonitors()
-        # Store their IDs for easy access
-        pretest_hm_ids = [hm['id'] for hm in pretest_hms]
-
-        pool1_name = data_utils.rand_name("lb_member_pool1_hm-list")
-        pool1_kwargs = {
-            const.NAME: pool1_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool1 = self.mem_pool_client.create_pool(**pool1_kwargs)
-        pool1_id = pool1[const.ID]
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool1_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool2_name = data_utils.rand_name("lb_member_pool2_hm-list")
-        pool2_kwargs = {
-            const.NAME: pool2_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool2 = self.mem_pool_client.create_pool(**pool2_kwargs)
-        pool2_id = pool2[const.ID]
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool2_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool3_name = data_utils.rand_name("lb_member_pool3_hm-list")
-        pool3_kwargs = {
-            const.NAME: pool3_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool3 = self.mem_pool_client.create_pool(**pool3_kwargs)
-        pool3_id = pool3[const.ID]
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool3_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        hm1_name = data_utils.rand_name("lb_member_hm2-list")
-        hm1_kwargs = {
-            const.POOL_ID: pool1_id,
-            const.NAME: hm1_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-            const.MAX_RETRIES_DOWN: 5,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/B',
-            const.EXPECTED_CODES: '200-204',
-            const.ADMIN_STATE_UP: True,
-        }
-        hm1 = self.mem_healthmonitor_client.create_healthmonitor(
-            **hm1_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm1[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        hm1 = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor, hm1[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        hm2_name = data_utils.rand_name("lb_member_hm1-list")
-        hm2_kwargs = {
-            const.POOL_ID: pool2_id,
-            const.NAME: hm2_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-            const.MAX_RETRIES_DOWN: 5,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/A',
-            const.EXPECTED_CODES: '200-204',
-            const.ADMIN_STATE_UP: True,
-        }
-        hm2 = self.mem_healthmonitor_client.create_healthmonitor(
-            **hm2_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm2[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        hm2 = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor, hm2[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        hm3_name = data_utils.rand_name("lb_member_hm3-list")
-        hm3_kwargs = {
-            const.POOL_ID: pool3_id,
-            const.NAME: hm3_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-            const.MAX_RETRIES_DOWN: 5,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/C',
-            const.EXPECTED_CODES: '200-204',
-            const.ADMIN_STATE_UP: False,
-        }
-        hm3 = self.mem_healthmonitor_client.create_healthmonitor(
-            **hm3_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm3[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        hm3 = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor, hm3[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        # Test that a different user cannot list healthmonitors
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.healthmonitor_client
-            primary = member2_client.list_healthmonitors(
-                query_params='pool_id={pool_id}'.format(pool_id=pool1_id))
-            self.assertEqual(0, len(primary))
-
-        # Test that users without the lb member role cannot list healthmonitors
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.healthmonitor_client.list_healthmonitors)
-
-        # Check the default sort order, created_at
-        hms = self.mem_healthmonitor_client.list_healthmonitors()
-        hms = self._filter_hms_by_pool_id(hms, (pool1_id, pool2_id, pool3_id))
-        self.assertEqual(hm1[const.URL_PATH],
-                         hms[0][const.URL_PATH])
-        self.assertEqual(hm2[const.URL_PATH],
-                         hms[1][const.URL_PATH])
-        self.assertEqual(hm3[const.URL_PATH],
-                         hms[2][const.URL_PATH])
-
-        # Test sort descending by description
-        hms = self.mem_healthmonitor_client.list_healthmonitors(
-            query_params='{sort}={url_path}:{desc}'
-                         .format(sort=const.SORT,
-                                 url_path=const.URL_PATH, desc=const.DESC))
-        hms = self._filter_hms_by_pool_id(hms, (pool1_id, pool2_id, pool3_id))
-        self.assertEqual(hm1[const.URL_PATH],
-                         hms[1][const.URL_PATH])
-        self.assertEqual(hm2[const.URL_PATH],
-                         hms[2][const.URL_PATH])
-        self.assertEqual(hm3[const.URL_PATH],
-                         hms[0][const.URL_PATH])
-
-        # Test sort ascending by description
-        hms = self.mem_healthmonitor_client.list_healthmonitors(
-            query_params='{sort}={url_path}:{asc}'
-                         .format(sort=const.SORT,
-                                 url_path=const.URL_PATH, asc=const.ASC))
-        hms = self._filter_hms_by_pool_id(hms, (pool1_id, pool2_id, pool3_id))
-        self.assertEqual(hm1[const.URL_PATH],
-                         hms[1][const.URL_PATH])
-        self.assertEqual(hm2[const.URL_PATH],
-                         hms[0][const.URL_PATH])
-        self.assertEqual(hm3[const.URL_PATH],
-                         hms[2][const.URL_PATH])
-
-        # Determine indexes of pretest HMs in default sort
-        pretest_hm_indexes = []
-        hms = self.mem_healthmonitor_client.list_healthmonitors()
-        for i, hm in enumerate(hms):
-            if hm['id'] in pretest_hm_ids:
-                pretest_hm_indexes.append(i)
-
-        # Test fields
-        for field in const.SHOW_HEALTHMONITOR_RESPONSE_FIELDS:
-            hms = self.mem_healthmonitor_client.list_healthmonitors(
-                query_params='{fields}={field}'
-                             .format(fields=const.FIELDS, field=field))
-            hms = self._filter_hms_by_index(hms, pretest_hm_indexes)
-            self.assertEqual(1, len(hms[0]))
-            self.assertEqual(hm1[field], hms[0][field])
-            self.assertEqual(hm2[field], hms[1][field])
-            self.assertEqual(hm3[field], hms[2][field])
-
-        # Test multiple fields at the same time
-        hms = self.mem_healthmonitor_client.list_healthmonitors(
-            query_params='{fields}={admin}&'
-                         '{fields}={created}&'
-                         '{fields}={pools}'.format(
-                             fields=const.FIELDS,
-                             admin=const.ADMIN_STATE_UP,
-                             created=const.CREATED_AT,
-                             pools=const.POOLS))
-        hms = self._filter_hms_by_pool_id(hms, (pool1_id, pool2_id, pool3_id))
-        self.assertEqual(3, len(hms[0]))
-        self.assertTrue(hms[0][const.ADMIN_STATE_UP])
-        parser.parse(hms[0][const.CREATED_AT])
-        self.assertTrue(hms[1][const.ADMIN_STATE_UP])
-        parser.parse(hms[1][const.CREATED_AT])
-        self.assertFalse(hms[2][const.ADMIN_STATE_UP])
-        parser.parse(hms[2][const.CREATED_AT])
-
-        # Test filtering
-        hms = self.mem_healthmonitor_client.list_healthmonitors(
-            query_params='{name}={hm_name}'.format(
-                name=const.NAME,
-                hm_name=hm2[const.NAME]))
-        self.assertEqual(1, len(hms))
-        self.assertEqual(hm2[const.NAME],
-                         hms[0][const.NAME])
-
-        # Test combined params
-        hms = self.mem_healthmonitor_client.list_healthmonitors(
-            query_params='{admin}={true}&'
-                         '{fields}={name}&{fields}={pools}&'
-                         '{sort}={name}:{desc}'.format(
-                             admin=const.ADMIN_STATE_UP,
-                             true=const.ADMIN_STATE_UP_TRUE,
-                             fields=const.FIELDS, name=const.NAME,
-                             pools=const.POOLS, sort=const.SORT,
-                             desc=const.DESC))
-        hms = self._filter_hms_by_pool_id(hms, (pool1_id, pool2_id, pool3_id))
-        # Should get two healthmonitors
-        self.assertEqual(2, len(hms))
-        # healthmonitors should have two fields
-        self.assertEqual(2, len(hms[0]))
-        # Should be in descending order
-        self.assertEqual(hm2[const.NAME],
-                         hms[1][const.NAME])
-        self.assertEqual(hm1[const.NAME],
-                         hms[0][const.NAME])
-
-    @decorators.idempotent_id('284e8d3b-7b2d-4697-9e41-580b3423c0b4')
-    def test_healthmonitor_show(self):
-        """Tests healthmonitor show API.
-
-        * Create a clean pool to use for the healthmonitor.
-        * Create a fully populated healthmonitor.
-        * Show healthmonitor details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the healthmonitor.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1_hm-show")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        hm_name = data_utils.rand_name("lb_member_hm1-show")
-        hm_kwargs = {
-            const.POOL_ID: pool[const.ID],
-            const.NAME: hm_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-            const.MAX_RETRIES_DOWN: 5,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/',
-            const.EXPECTED_CODES: '200-204',
-            const.ADMIN_STATE_UP: True,
-        }
-
-        hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        parser.parse(hm[const.CREATED_AT])
-        parser.parse(hm[const.UPDATED_AT])
-        UUID(hm[const.ID])
-
-        # Healthmonitors are always ONLINE
-        self.assertEqual(const.ONLINE, hm[const.OPERATING_STATUS])
-
-        equal_items = [const.NAME, const.TYPE, const.DELAY, const.TIMEOUT,
-                       const.MAX_RETRIES, const.MAX_RETRIES_DOWN,
-                       const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES,
-                       const.ADMIN_STATE_UP]
-
-        for item in equal_items:
-            self.assertEqual(hm_kwargs[item], hm[item])
-
-        # Test that a user with lb_admin role can see the healthmonitor
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            healthmonitor_client = self.os_roles_lb_admin.healthmonitor_client
-            hm_adm = healthmonitor_client.show_healthmonitor(hm[const.ID])
-            self.assertEqual(hm_name, hm_adm[const.NAME])
-
-        # Test that a user with cloud admin role can see the healthmonitor
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.healthmonitor_client.show_healthmonitor(
-                hm[const.ID])
-            self.assertEqual(hm_name, adm[const.NAME])
-
-        # Test that a different user, with loadbalancer member role, cannot
-        # see this healthmonitor
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.healthmonitor_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.show_healthmonitor,
-                              hm[const.ID])
-
-        # Test that a user, without the loadbalancer member role, cannot
-        # show healthmonitors
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.healthmonitor_client.show_healthmonitor,
-                hm[const.ID])
-
-    @decorators.idempotent_id('fa584b2c-f179-4c4e-ad2e-ff51fd1c5973')
-    def test_healthmonitor_update(self):
-        """Tests healthmonitor update and show APIs.
-
-        * Create a clean pool to use for the healthmonitor.
-        * Create a fully populated healthmonitor.
-        * Show healthmonitor details.
-        * Validate the show reflects the initial values.
-        * Validates that other accounts cannot update the healthmonitor.
-        * Update the healthmonitor details.
-        * Show healthmonitor details.
-        * Validate the show reflects the updated values.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1_hm-update")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        hm_name = data_utils.rand_name("lb_member_hm1-update")
-        hm_kwargs = {
-            const.POOL_ID: pool[const.ID],
-            const.NAME: hm_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-            const.MAX_RETRIES_DOWN: 5,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/',
-            const.EXPECTED_CODES: '200-204',
-            const.ADMIN_STATE_UP: False,
-        }
-
-        hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        parser.parse(hm[const.CREATED_AT])
-        parser.parse(hm[const.UPDATED_AT])
-        UUID(hm[const.ID])
-
-        # Healthmonitors are ONLINE if admin_state_up = True, else OFFLINE
-        if hm_kwargs[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, hm[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, hm[const.OPERATING_STATUS])
-
-        equal_items = [const.NAME, const.TYPE, const.DELAY, const.TIMEOUT,
-                       const.MAX_RETRIES, const.MAX_RETRIES_DOWN,
-                       const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES,
-                       const.ADMIN_STATE_UP]
-
-        for item in equal_items:
-            self.assertEqual(hm_kwargs[item], hm[item])
-
-        # Test that a user, without the loadbalancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.healthmonitor_client.update_healthmonitor,
-                hm[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        hm_check = self.mem_healthmonitor_client.show_healthmonitor(
-            hm[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         hm_check[const.PROVISIONING_STATUS])
-        self.assertFalse(hm_check[const.ADMIN_STATE_UP])
-
-        # Test that a user, without the loadbalancer member role, cannot
-        # update this healthmonitor
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.healthmonitor_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.update_healthmonitor,
-                              hm[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        hm_check = self.mem_healthmonitor_client.show_healthmonitor(
-            hm[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         hm_check[const.PROVISIONING_STATUS])
-        self.assertFalse(hm_check[const.ADMIN_STATE_UP])
-
-        new_name = data_utils.rand_name("lb_member_hm1-UPDATED")
-        hm_update_kwargs = {
-            const.NAME: new_name,
-            const.DELAY: hm_kwargs[const.DELAY] + 1,
-            const.TIMEOUT: hm_kwargs[const.TIMEOUT] + 1,
-            const.MAX_RETRIES: hm_kwargs[const.MAX_RETRIES] + 1,
-            const.MAX_RETRIES_DOWN: hm_kwargs[const.MAX_RETRIES_DOWN] + 1,
-            const.HTTP_METHOD: const.POST,
-            const.URL_PATH: '/test',
-            const.EXPECTED_CODES: '201,202',
-            const.ADMIN_STATE_UP: not hm_kwargs[const.ADMIN_STATE_UP],
-        }
-        hm = self.mem_healthmonitor_client.update_healthmonitor(
-            hm[const.ID], **hm_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Healthmonitors are ONLINE if admin_state_up = True, else OFFLINE
-        if hm_update_kwargs[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, hm[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, hm[const.OPERATING_STATUS])
-
-        # Test changed items
-        equal_items = [const.NAME, const.DELAY, const.TIMEOUT,
-                       const.MAX_RETRIES, const.MAX_RETRIES_DOWN,
-                       const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES,
-                       const.ADMIN_STATE_UP]
-
-        for item in equal_items:
-            self.assertEqual(hm_update_kwargs[item], hm[item])
-
-        # Test unchanged items
-        equal_items = [const.TYPE]
-        for item in equal_items:
-            self.assertEqual(hm_kwargs[item], hm[item])
-
-    @decorators.idempotent_id('a7bab4ac-340c-4776-ab9d-9fcb66869432')
-    def test_healthmonitor_delete(self):
-        """Tests healthmonitor create and delete APIs.
-
-        * Create a clean pool to use for the healthmonitor.
-        * Creates a healthmonitor.
-        * Validates that other accounts cannot delete the healthmonitor
-        * Deletes the healthmonitor.
-        * Validates the healthmonitor is in the DELETED state.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1_hm-delete")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        hm_name = data_utils.rand_name("lb_member_hm1-delete")
-        hm_kwargs = {
-            const.POOL_ID: pool[const.ID],
-            const.NAME: hm_name,
-            const.TYPE: const.HEALTH_MONITOR_TCP,
-            const.DELAY: 2,
-            const.TIMEOUT: 3,
-            const.MAX_RETRIES: 4,
-        }
-        hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test that a user without the loadbalancer role cannot
-        # delete this healthmonitor
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.healthmonitor_client.delete_healthmonitor,
-                hm[const.ID])
-
-        # Test that a different user, with the loadbalancer member role
-        # cannot delete this healthmonitor
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.healthmonitor_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.delete_healthmonitor,
-                              hm[const.ID])
-
-        self.mem_healthmonitor_client.delete_healthmonitor(hm[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/api/v2/test_l7policy.py b/octavia_tempest_plugin/tests/api/v2/test_l7policy.py
deleted file mode 100644
index 255bbde..0000000
--- a/octavia_tempest_plugin/tests/api/v2/test_l7policy.py
+++ /dev/null
@@ -1,796 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class L7PolicyAPITest(test_base.LoadBalancerBaseTest):
-    """Test the l7policy object API."""
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(L7PolicyAPITest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_l7policy")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_l7policy")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_l7policy")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('eba4ddc2-758b-4dd5-bd28-c1b41d6575ca')
-    def test_l7policy_create_redirect_pool(self):
-        self._test_l7policy_create(pool_id=self.pool_id)
-
-    @decorators.idempotent_id('2b529135-71bc-46f7-912f-74d238d67190')
-    def test_l7policy_create_redirect_url(self):
-        self._test_l7policy_create(url='http://localhost')
-
-    @decorators.idempotent_id('aa9b0d50-0d16-4365-85eb-846b17eb8398')
-    def test_l7policy_create_reject(self):
-        self._test_l7policy_create()
-
-    def _test_l7policy_create(self, url=None, pool_id=None):
-        """Tests l7policy create and basic show APIs.
-
-        * Tests that users without the loadbalancer member role cannot
-          create l7policies.
-        * Create a fully populated l7policy.
-        * Show l7policy details.
-        * Validate the show reflects the requested values.
-        """
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1-create")
-        l7policy_description = data_utils.arbitrary_string(size=255)
-        l7policy_kwargs = {
-            const.LISTENER_ID: self.listener_id,
-            const.NAME: l7policy_name,
-            const.DESCRIPTION: l7policy_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-        }
-        if url:
-            l7policy_kwargs[const.ACTION] = const.REDIRECT_TO_URL
-            l7policy_kwargs[const.REDIRECT_URL] = url
-        elif pool_id:
-            l7policy_kwargs[const.ACTION] = const.REDIRECT_TO_POOL
-            l7policy_kwargs[const.REDIRECT_POOL_ID] = pool_id
-        else:
-            l7policy_kwargs[const.ACTION] = const.REJECT
-
-        # Test that a user without the load balancer role cannot
-        # create a l7policy
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7policy_client.create_l7policy,
-                **l7policy_kwargs)
-
-        l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7policy = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy,
-            l7policy[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            l7policy = waiters.wait_for_status(
-                self.mem_l7policy_client.show_l7policy,
-                l7policy[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(l7policy_name, l7policy[const.NAME])
-        self.assertEqual(l7policy_description, l7policy[const.DESCRIPTION])
-        self.assertTrue(l7policy[const.ADMIN_STATE_UP])
-        parser.parse(l7policy[const.CREATED_AT])
-        parser.parse(l7policy[const.UPDATED_AT])
-        UUID(l7policy[const.ID])
-        # Operating status for a l7policy will be ONLINE if it is enabled:
-        if l7policy[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7policy[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7policy[const.OPERATING_STATUS])
-        self.assertEqual(self.listener_id, l7policy[const.LISTENER_ID])
-        self.assertEqual(1, l7policy[const.POSITION])
-        if url:
-            self.assertEqual(const.REDIRECT_TO_URL, l7policy[const.ACTION])
-            self.assertEqual(url, l7policy[const.REDIRECT_URL])
-            self.assertIsNone(l7policy.pop(const.REDIRECT_POOL_ID, None))
-        elif pool_id:
-            self.assertEqual(const.REDIRECT_TO_POOL, l7policy[const.ACTION])
-            self.assertEqual(pool_id, l7policy[const.REDIRECT_POOL_ID])
-            self.assertIsNone(l7policy.pop(const.REDIRECT_URL, None))
-        else:
-            self.assertEqual(const.REJECT, l7policy[const.ACTION])
-            self.assertIsNone(l7policy.pop(const.REDIRECT_URL, None))
-            self.assertIsNone(l7policy.pop(const.REDIRECT_POOL_ID, None))
-
-    @decorators.idempotent_id('42fa14ba-caf1-465e-ab36-27e7501f95ef')
-    def test_l7policy_list(self):
-        """Tests l7policy list API and field filtering.
-
-        * Create a clean listener.
-        * Create three l7policies.
-        * Validates that other accounts cannot list the l7policies.
-        * List the l7policies using the default sort order.
-        * List the l7policies using descending sort order.
-        * List the l7policies using ascending sort order.
-        * List the l7policies returning one field at a time.
-        * List the l7policies returning two fields.
-        * List the l7policies filtering to one of the three.
-        * List the l7policies filtered, one field, and sorted.
-        """
-        listener_name = data_utils.rand_name(
-            "lb_member_listener2_l7policy-list")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '81',
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        listener_id = listener[const.ID]
-        self.addCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        l7policy1_name = data_utils.rand_name("lb_member_l7policy2-list")
-        l7policy1_desc = 'B'
-        l7policy1_kwargs = {
-            const.LISTENER_ID: listener_id,
-            const.NAME: l7policy1_name,
-            const.DESCRIPTION: l7policy1_desc,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-            const.ACTION: const.REJECT
-        }
-        l7policy1 = self.mem_l7policy_client.create_l7policy(
-            **l7policy1_kwargs)
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy1[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        l7policy1 = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy, l7policy1[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        l7policy2_name = data_utils.rand_name("lb_member_l7policy1-list")
-        l7policy2_desc = 'A'
-        l7policy2_kwargs = {
-            const.LISTENER_ID: listener_id,
-            const.NAME: l7policy2_name,
-            const.DESCRIPTION: l7policy2_desc,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-            const.ACTION: const.REDIRECT_TO_POOL,
-            const.REDIRECT_POOL_ID: self.pool_id
-        }
-        l7policy2 = self.mem_l7policy_client.create_l7policy(
-            **l7policy2_kwargs)
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy2[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        l7policy2 = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy, l7policy2[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        l7policy3_name = data_utils.rand_name("lb_member_l7policy3-list")
-        l7policy3_desc = 'C'
-        l7_redirect_url = 'http://localhost'
-        l7policy3_kwargs = {
-            const.LISTENER_ID: listener_id,
-            const.NAME: l7policy3_name,
-            const.DESCRIPTION: l7policy3_desc,
-            const.ADMIN_STATE_UP: False,
-            const.POSITION: 1,
-            const.ACTION: const.REDIRECT_TO_URL,
-            const.REDIRECT_URL: l7_redirect_url
-        }
-        l7policy3 = self.mem_l7policy_client.create_l7policy(
-            **l7policy3_kwargs)
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy3[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        l7policy3 = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy, l7policy3[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        # Test that a different user cannot list l7policies
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7policy_client
-            primary = member2_client.list_l7policies(
-                query_params='listener_id={listener_id}'.format(
-                    listener_id=listener_id))
-            self.assertEqual(0, len(primary))
-
-        # Test that a user without the lb member role cannot list load
-        # balancers
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7policy_client.list_l7policies)
-
-        # Check the default sort order, created_at
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}'.format(
-                listener_id=listener_id))
-        self.assertEqual(l7policy1[const.DESCRIPTION],
-                         l7policies[0][const.DESCRIPTION])
-        self.assertEqual(l7policy2[const.DESCRIPTION],
-                         l7policies[1][const.DESCRIPTION])
-        self.assertEqual(l7policy3[const.DESCRIPTION],
-                         l7policies[2][const.DESCRIPTION])
-
-        # Test sort descending by description
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}&{sort}={descr}:{desc}'
-                         .format(listener_id=listener_id, sort=const.SORT,
-                                 descr=const.DESCRIPTION, desc=const.DESC))
-        self.assertEqual(l7policy1[const.DESCRIPTION],
-                         l7policies[1][const.DESCRIPTION])
-        self.assertEqual(l7policy2[const.DESCRIPTION],
-                         l7policies[2][const.DESCRIPTION])
-        self.assertEqual(l7policy3[const.DESCRIPTION],
-                         l7policies[0][const.DESCRIPTION])
-
-        # Test sort ascending by description
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}&{sort}={descr}:{asc}'
-                         .format(listener_id=listener_id, sort=const.SORT,
-                                 descr=const.DESCRIPTION, asc=const.ASC))
-        self.assertEqual(l7policy1[const.DESCRIPTION],
-                         l7policies[1][const.DESCRIPTION])
-        self.assertEqual(l7policy2[const.DESCRIPTION],
-                         l7policies[0][const.DESCRIPTION])
-        self.assertEqual(l7policy3[const.DESCRIPTION],
-                         l7policies[2][const.DESCRIPTION])
-
-        # Use this opportunity to verify the position insertion is working
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}&{sort}={position}:{asc}'
-                         .format(listener_id=listener_id, sort=const.SORT,
-                                 position=const.POSITION, asc=const.ASC))
-        self.assertEqual(1, l7policies[0][const.POSITION])
-        self.assertEqual(2, l7policies[1][const.POSITION])
-        self.assertEqual(3, l7policies[2][const.POSITION])
-        self.assertEqual(l7policy1[const.NAME],
-                         l7policies[2][const.NAME])
-        self.assertEqual(l7policy2[const.NAME],
-                         l7policies[1][const.NAME])
-        self.assertEqual(l7policy3[const.NAME],
-                         l7policies[0][const.NAME])
-
-        # Test fields
-        for field in const.SHOW_L7POLICY_RESPONSE_FIELDS:
-            # Test position / updated fields separately, because they're odd
-            if field not in (const.POSITION, const.UPDATED_AT):
-                l7policies = self.mem_l7policy_client.list_l7policies(
-                    query_params='listener_id={listener_id}&{fields}={field}'
-                                 .format(listener_id=listener_id,
-                                         fields=const.FIELDS, field=field))
-                self.assertEqual(1, len(l7policies[0]))
-                self.assertEqual(l7policy1[field], l7policies[0][field])
-                self.assertEqual(l7policy2[field], l7policies[1][field])
-                self.assertEqual(l7policy3[field], l7policies[2][field])
-            elif field == const.POSITION:
-                l7policies = self.mem_l7policy_client.list_l7policies(
-                    query_params='listener_id={listener_id}&{fields}={field}'
-                                 .format(listener_id=listener_id,
-                                         fields=const.FIELDS, field=field))
-                self.assertEqual(1, len(l7policies[0]))
-                # Positions won't match the request due to insertion reordering
-                self.assertEqual(3, l7policies[0][field])
-                self.assertEqual(2, l7policies[1][field])
-                self.assertEqual(1, l7policies[2][field])
-            elif field == const.UPDATED_AT:
-                l7policies = self.mem_l7policy_client.list_l7policies(
-                    query_params='listener_id={listener_id}&{fields}={field}'
-                                 .format(listener_id=listener_id,
-                                         fields=const.FIELDS, field=field))
-                # Just test that we get it -- the actual value is unpredictable
-                self.assertEqual(1, len(l7policies[0]))
-
-        # Test multiple fields at the same time
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}&{fields}={admin}&'
-                         '{fields}={created}'.format(
-                             listener_id=listener_id, fields=const.FIELDS,
-                             admin=const.ADMIN_STATE_UP,
-                             created=const.CREATED_AT))
-        self.assertEqual(2, len(l7policies[0]))
-        self.assertTrue(l7policies[0][const.ADMIN_STATE_UP])
-        parser.parse(l7policies[0][const.CREATED_AT])
-        self.assertTrue(l7policies[1][const.ADMIN_STATE_UP])
-        parser.parse(l7policies[1][const.CREATED_AT])
-        self.assertFalse(l7policies[2][const.ADMIN_STATE_UP])
-        parser.parse(l7policies[2][const.CREATED_AT])
-
-        # Test filtering
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}&'
-                         '{desc}={l7policy_desc}'.format(
-                             listener_id=listener_id, desc=const.DESCRIPTION,
-                             l7policy_desc=l7policy2[const.DESCRIPTION]))
-        self.assertEqual(1, len(l7policies))
-        self.assertEqual(l7policy2[const.DESCRIPTION],
-                         l7policies[0][const.DESCRIPTION])
-
-        # Test combined params
-        l7policies = self.mem_l7policy_client.list_l7policies(
-            query_params='listener_id={listener_id}&{admin}={true}&'
-                         '{fields}={descr}&{fields}={id}&'
-                         '{sort}={descr}:{desc}'.format(
-                             listener_id=listener_id,
-                             admin=const.ADMIN_STATE_UP,
-                             true=const.ADMIN_STATE_UP_TRUE,
-                             fields=const.FIELDS, descr=const.DESCRIPTION,
-                             id=const.ID, sort=const.SORT, desc=const.DESC))
-        # Should get two l7policies
-        self.assertEqual(2, len(l7policies))
-        # l7policies should have two fields
-        self.assertEqual(2, len(l7policies[0]))
-        # Should be in descending order
-        self.assertEqual(l7policy2[const.DESCRIPTION],
-                         l7policies[1][const.DESCRIPTION])
-        self.assertEqual(l7policy1[const.DESCRIPTION],
-                         l7policies[0][const.DESCRIPTION])
-
-    @decorators.idempotent_id('baaa8104-a037-4976-b908-82a0b3e08129')
-    def test_l7policy_show(self):
-        """Tests l7policy show API.
-
-        * Create a fully populated l7policy.
-        * Show l7policy details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the l7policy.
-        """
-        listener_name = data_utils.rand_name(
-            "lb_member_listener4_l7policy-show")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '81',
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        listener_id = listener[const.ID]
-        self.addCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1-show")
-        l7policy_description = data_utils.arbitrary_string(size=255)
-        l7policy_kwargs = {
-            const.LISTENER_ID: listener_id,
-            const.NAME: l7policy_name,
-            const.DESCRIPTION: l7policy_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-            const.ACTION: const.REJECT,
-        }
-
-        l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7policy = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy,
-            l7policy[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            l7policy = waiters.wait_for_status(
-                self.mem_l7policy_client.show_l7policy,
-                l7policy[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(l7policy_name, l7policy[const.NAME])
-        self.assertEqual(l7policy_description, l7policy[const.DESCRIPTION])
-        self.assertTrue(l7policy[const.ADMIN_STATE_UP])
-        parser.parse(l7policy[const.CREATED_AT])
-        parser.parse(l7policy[const.UPDATED_AT])
-        UUID(l7policy[const.ID])
-        # Operating status for a l7policy will be ONLINE if it is enabled:
-        if l7policy[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7policy[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7policy[const.OPERATING_STATUS])
-        self.assertEqual(listener_id, l7policy[const.LISTENER_ID])
-        self.assertEqual(1, l7policy[const.POSITION])
-        self.assertEqual(const.REJECT, l7policy[const.ACTION])
-        self.assertIsNone(l7policy.pop(const.REDIRECT_URL, None))
-        self.assertIsNone(l7policy.pop(const.REDIRECT_POOL_ID, None))
-
-        # Test that a user with lb_admin role can see the l7policy
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            l7policy_client = self.os_roles_lb_admin.l7policy_client
-            l7policy_adm = l7policy_client.show_l7policy(l7policy[const.ID])
-            self.assertEqual(l7policy_name, l7policy_adm[const.NAME])
-
-        # Test that a user with cloud admin role can see the l7policy
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.l7policy_client.show_l7policy(
-                l7policy[const.ID])
-            self.assertEqual(l7policy_name, adm[const.NAME])
-
-        # Test that a different user, with load balancer member role, cannot
-        # see this l7policy
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7policy_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.show_l7policy,
-                              l7policy[const.ID])
-
-        # Test that a user, without the load balancer member role, cannot
-        # show l7policies
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7policy_client.show_l7policy,
-                l7policy[const.ID])
-
-    @decorators.idempotent_id('08f73b22-550b-4e5a-b3d6-2ec03251ca13')
-    def test_l7policy_update(self):
-        """Tests l7policy update and show APIs.
-
-        * Create a clean listener.
-        * Create a fully populated l7policy.
-        * Show l7policy details.
-        * Validate the show reflects the initial values.
-        * Validates that other accounts cannot update the l7policy.
-        * Update the l7policy details.
-        * Show l7policy details.
-        * Validate the show reflects the updated values.
-        """
-        listener_name = data_utils.rand_name(
-            "lb_member_listener3_l7policy-update")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '81',
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        listener_id = listener[const.ID]
-        self.addCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1-update")
-        l7policy_description = data_utils.arbitrary_string(size=255)
-        l7_redirect_url = 'http://localhost'
-        l7policy_kwargs = {
-            const.LISTENER_ID: listener_id,
-            const.NAME: l7policy_name,
-            const.DESCRIPTION: l7policy_description,
-            const.ADMIN_STATE_UP: False,
-            const.POSITION: 1,
-            const.ACTION: const.REDIRECT_TO_URL,
-            const.REDIRECT_URL: l7_redirect_url,
-        }
-
-        l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7policy = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy,
-            l7policy[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(l7policy_name, l7policy[const.NAME])
-        self.assertEqual(l7policy_description, l7policy[const.DESCRIPTION])
-        self.assertFalse(l7policy[const.ADMIN_STATE_UP])
-        parser.parse(l7policy[const.CREATED_AT])
-        parser.parse(l7policy[const.UPDATED_AT])
-        UUID(l7policy[const.ID])
-        # Operating status for a l7policy will be ONLINE if it is enabled:
-        if l7policy[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7policy[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7policy[const.OPERATING_STATUS])
-        self.assertEqual(listener_id, l7policy[const.LISTENER_ID])
-        self.assertEqual(1, l7policy[const.POSITION])
-        self.assertEqual(const.REDIRECT_TO_URL, l7policy[const.ACTION])
-        self.assertEqual(l7_redirect_url, l7policy[const.REDIRECT_URL])
-        self.assertIsNone(l7policy.pop(const.REDIRECT_POOL_ID, None))
-
-        # Test that a user, without the load balancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7policy_client.update_l7policy,
-                l7policy[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        l7policy_check = self.mem_l7policy_client.show_l7policy(
-            l7policy[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         l7policy_check[const.PROVISIONING_STATUS])
-        self.assertFalse(l7policy_check[const.ADMIN_STATE_UP])
-
-        # Test that a user, without the load balancer member role, cannot
-        # update this l7policy
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7policy_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.update_l7policy,
-                              l7policy[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        l7policy_check = self.mem_l7policy_client.show_l7policy(
-            l7policy[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         l7policy_check[const.PROVISIONING_STATUS])
-        self.assertFalse(l7policy_check[const.ADMIN_STATE_UP])
-
-        new_name = data_utils.rand_name("lb_member_l7policy1-UPDATED")
-        new_description = data_utils.arbitrary_string(size=255,
-                                                      base_text='new')
-        l7policy_update_kwargs = {
-            const.NAME: new_name,
-            const.DESCRIPTION: new_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 2,
-            const.ACTION: const.REDIRECT_TO_POOL,
-            const.REDIRECT_POOL_ID: self.pool_id,
-        }
-        l7policy = self.mem_l7policy_client.update_l7policy(
-            l7policy[const.ID], **l7policy_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7policy = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy,
-            l7policy[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            l7policy = waiters.wait_for_status(
-                self.mem_l7policy_client.show_l7policy,
-                l7policy[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(new_name, l7policy[const.NAME])
-        self.assertEqual(new_description, l7policy[const.DESCRIPTION])
-        self.assertTrue(l7policy[const.ADMIN_STATE_UP])
-        parser.parse(l7policy[const.CREATED_AT])
-        parser.parse(l7policy[const.UPDATED_AT])
-        UUID(l7policy[const.ID])
-        # Operating status for a l7policy will be ONLINE if it is enabled:
-        if l7policy[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7policy[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7policy[const.OPERATING_STATUS])
-        self.assertEqual(listener_id, l7policy[const.LISTENER_ID])
-        self.assertEqual(1, l7policy[const.POSITION])
-        self.assertEqual(const.REDIRECT_TO_POOL, l7policy[const.ACTION])
-        self.assertEqual(self.pool_id, l7policy[const.REDIRECT_POOL_ID])
-        self.assertIsNone(l7policy.pop(const.REDIRECT_URL, None))
-
-    @decorators.idempotent_id('7925eb4b-94b6-4c28-98c2-fd0b4f0976cc')
-    def test_l7policy_delete(self):
-        """Tests l7policy create and delete APIs.
-
-        * Creates a l7policy.
-        * Validates that other accounts cannot delete the l7policy
-        * Deletes the l7policy.
-        * Validates the l7policy is in the DELETED state.
-        """
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1-delete")
-        l7policy_kwargs = {
-            const.LISTENER_ID: self.listener_id,
-            const.NAME: l7policy_name,
-            const.ACTION: const.REJECT,
-        }
-        l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test that a user without the load balancer role cannot
-        # delete this l7policy
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7policy_client.delete_l7policy,
-                l7policy[const.ID])
-
-        # Test that a different user, with the load balancer member role
-        # cannot delete this l7policy
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7policy_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.delete_l7policy,
-                              l7policy[const.ID])
-
-        self.mem_l7policy_client.delete_l7policy(l7policy[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_l7policy_client.show_l7policy, l7policy[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/api/v2/test_l7rule.py b/octavia_tempest_plugin/tests/api/v2/test_l7rule.py
deleted file mode 100644
index 395a3ad..0000000
--- a/octavia_tempest_plugin/tests/api/v2/test_l7rule.py
+++ /dev/null
@@ -1,682 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class L7RuleAPITest(test_base.LoadBalancerBaseTest):
-    """Test the l7rule object API."""
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(L7RuleAPITest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_l7rule")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_l7rule")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_l7rule")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LISTENER_ID: cls.listener_id,
-        }
-
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1_l7rule")
-        l7policy_kwargs = {
-            const.NAME: l7policy_name,
-            const.LISTENER_ID: cls.listener_id,
-            const.ACTION: const.REJECT,
-        }
-        l7policy = cls.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        cls.l7policy_id = l7policy[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_l7policy_client.cleanup_l7policy,
-            cls.l7policy_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    # Note: This test also covers basic l7rule show API
-    @decorators.idempotent_id('55ac1337-189d-40a6-b614-47d7a8e991f6')
-    def test_l7rule_create(self):
-        """Tests l7rule create and basic show APIs.
-
-        * Tests that users without the loadbalancer member role cannot
-          create l7rules.
-        * Create a fully populated l7rule.
-        * Show l7rule details.
-        * Validate the show reflects the requested values.
-        """
-        l7rule_kwargs = {
-            const.ADMIN_STATE_UP: True,
-            const.L7POLICY_ID: self.l7policy_id,
-            const.TYPE: const.HEADER,
-            const.VALUE: 'myvalue-create',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey-create',
-            const.INVERT: False,
-        }
-
-        # Test that a user without the load balancer role cannot
-        # create a l7rule
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7rule_client.create_l7rule,
-                **l7rule_kwargs)
-
-        l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule[const.ID], l7policy_id=self.l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7rule = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule,
-            l7rule[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=self.l7policy_id)
-        if not CONF.load_balancer.test_with_noop:
-            l7rule = waiters.wait_for_status(
-                self.mem_l7rule_client.show_l7rule,
-                l7rule[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout,
-                l7policy_id=self.l7policy_id)
-
-        parser.parse(l7rule[const.CREATED_AT])
-        parser.parse(l7rule[const.UPDATED_AT])
-        UUID(l7rule[const.ID])
-        # Operating status for a l7rule will be ONLINE if it is enabled:
-        if l7rule[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7rule[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7rule[const.OPERATING_STATUS])
-
-        equal_items = [const.ADMIN_STATE_UP, const.TYPE, const.VALUE,
-                       const.COMPARE_TYPE, const.KEY, const.INVERT]
-
-        for item in equal_items:
-            self.assertEqual(l7rule_kwargs[item], l7rule[item])
-
-    @decorators.idempotent_id('69095254-f106-4fb6-9f54-7a78cc14fb51')
-    def test_l7rule_list(self):
-        """Tests l7rule list API and field filtering.
-
-        * Create a clean l7policy.
-        * Create three l7rules.
-        * Validates that other accounts cannot list the l7rules.
-        * List the l7rules using the default sort order.
-        * List the l7rules using descending sort order.
-        * List the l7rules using ascending sort order.
-        * List the l7rules returning one field at a time.
-        * List the l7rules returning two fields.
-        * List the l7rules filtering to one of the three.
-        * List the l7rules filtered, one field, and sorted.
-        """
-        l7policy_name = data_utils.rand_name("lb_member_l7policy2_l7rule-list")
-        l7policy = self.mem_l7policy_client.create_l7policy(
-            name=l7policy_name, listener_id=self.listener_id,
-            action=const.REJECT)
-        l7policy_id = l7policy[const.ID]
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy, l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        l7rule1_kwargs = {
-            const.L7POLICY_ID: l7policy_id,
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.HEADER,
-            const.VALUE: '2',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey2-list',
-        }
-        l7rule1 = self.mem_l7rule_client.create_l7rule(
-            **l7rule1_kwargs)
-        self.addCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule1[const.ID], l7policy_id=l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        l7rule1 = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule, l7rule1[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=l7policy_id)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.check_interval,
-                                CONF.load_balancer.check_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        l7rule2_kwargs = {
-            const.L7POLICY_ID: l7policy_id,
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.HEADER,
-            const.VALUE: '1',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey1-list',
-        }
-        l7rule2 = self.mem_l7rule_client.create_l7rule(
-            **l7rule2_kwargs)
-        self.addCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule2[const.ID], l7policy_id=l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        l7rule2 = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule, l7rule2[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=l7policy_id)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.check_interval,
-                                CONF.load_balancer.check_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        l7rule3_kwargs = {
-            const.L7POLICY_ID: l7policy_id,
-            const.ADMIN_STATE_UP: False,
-            const.TYPE: const.HEADER,
-            const.VALUE: '3',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey3-list',
-        }
-        l7rule3 = self.mem_l7rule_client.create_l7rule(
-            **l7rule3_kwargs)
-        self.addCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule3[const.ID], l7policy_id=l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        l7rule3 = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule, l7rule3[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=l7policy_id)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.check_interval,
-                                CONF.load_balancer.check_timeout)
-
-        # Test that a different user cannot list l7rules
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7rule_client
-            self.assertRaises(
-                exceptions.Forbidden,
-                member2_client.list_l7rules,
-                l7policy_id)
-
-        # Test that a user without the lb l7rule role cannot list load
-        # balancers
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7rule_client.list_l7rules,
-                l7policy_id)
-
-        # Check the default sort order, created_at
-        l7rules = self.mem_l7rule_client.list_l7rules(l7policy_id)
-        self.assertEqual(l7rule1[const.VALUE],
-                         l7rules[0][const.VALUE])
-        self.assertEqual(l7rule2[const.VALUE],
-                         l7rules[1][const.VALUE])
-        self.assertEqual(l7rule3[const.VALUE],
-                         l7rules[2][const.VALUE])
-
-        # Test sort descending by `value`
-        l7rules = self.mem_l7rule_client.list_l7rules(
-            l7policy_id, query_params='{sort}={value}:{desc}'.format(
-                sort=const.SORT, value=const.VALUE, desc=const.DESC))
-        self.assertEqual(l7rule1[const.VALUE],
-                         l7rules[1][const.VALUE])
-        self.assertEqual(l7rule2[const.VALUE],
-                         l7rules[2][const.VALUE])
-        self.assertEqual(l7rule3[const.VALUE],
-                         l7rules[0][const.VALUE])
-
-        # Test sort ascending by `value`
-        l7rules = self.mem_l7rule_client.list_l7rules(
-            l7policy_id, query_params='{sort}={value}:{asc}'.format(
-                sort=const.SORT, value=const.VALUE, asc=const.ASC))
-        self.assertEqual(l7rule1[const.VALUE],
-                         l7rules[1][const.VALUE])
-        self.assertEqual(l7rule2[const.VALUE],
-                         l7rules[0][const.VALUE])
-        self.assertEqual(l7rule3[const.VALUE],
-                         l7rules[2][const.VALUE])
-
-        # Test fields
-        for field in const.SHOW_L7RULE_RESPONSE_FIELDS:
-            l7rules = self.mem_l7rule_client.list_l7rules(
-                l7policy_id, query_params='{fields}={field}'.format(
-                    fields=const.FIELDS, field=field))
-            self.assertEqual(1, len(l7rules[0]))
-            self.assertEqual(l7rule1[field], l7rules[0][field])
-            self.assertEqual(l7rule2[field], l7rules[1][field])
-            self.assertEqual(l7rule3[field], l7rules[2][field])
-
-        # Test multiple fields at the same time
-        l7rules = self.mem_l7rule_client.list_l7rules(
-            l7policy_id,
-            query_params='{fields}={admin}&{fields}={created}'.format(
-                fields=const.FIELDS, admin=const.ADMIN_STATE_UP,
-                created=const.CREATED_AT))
-        self.assertEqual(2, len(l7rules[0]))
-        self.assertTrue(l7rules[0][const.ADMIN_STATE_UP])
-        parser.parse(l7rules[0][const.CREATED_AT])
-        self.assertTrue(l7rules[1][const.ADMIN_STATE_UP])
-        parser.parse(l7rules[1][const.CREATED_AT])
-        self.assertFalse(l7rules[2][const.ADMIN_STATE_UP])
-        parser.parse(l7rules[2][const.CREATED_AT])
-
-        # Test filtering
-        l7rules = self.mem_l7rule_client.list_l7rules(
-            l7policy_id,
-            query_params='{value}={rule_value}'.format(
-                value=const.VALUE,
-                rule_value=l7rule2[const.VALUE]))
-        self.assertEqual(1, len(l7rules))
-        self.assertEqual(l7rule2[const.VALUE],
-                         l7rules[0][const.VALUE])
-
-        # Test combined params
-        l7rules = self.mem_l7rule_client.list_l7rules(
-            l7policy_id,
-            query_params='{admin}={true}&'
-                         '{fields}={value}&{fields}={id}&'
-                         '{sort}={value}:{desc}'.format(
-                             admin=const.ADMIN_STATE_UP,
-                             true=const.ADMIN_STATE_UP_TRUE,
-                             fields=const.FIELDS, value=const.VALUE,
-                             id=const.ID, sort=const.SORT, desc=const.DESC))
-        # Should get two l7rules
-        self.assertEqual(2, len(l7rules))
-        # l7rules should have two fields
-        self.assertEqual(2, len(l7rules[0]))
-        # Should be in descending order by `value`
-        self.assertEqual(l7rule2[const.VALUE],
-                         l7rules[1][const.VALUE])
-        self.assertEqual(l7rule1[const.VALUE],
-                         l7rules[0][const.VALUE])
-
-    @decorators.idempotent_id('b80b34c3-09fc-467b-8027-7350adb17070')
-    def test_l7rule_show(self):
-        """Tests l7rule show API.
-
-        * Create a fully populated l7rule.
-        * Show l7rule details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the l7rule.
-        """
-        l7rule_kwargs = {
-            const.ADMIN_STATE_UP: True,
-            const.L7POLICY_ID: self.l7policy_id,
-            const.TYPE: const.HEADER,
-            const.VALUE: 'myvalue-show',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey-show',
-            const.INVERT: False,
-        }
-
-        l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule[const.ID], l7policy_id=self.l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7rule = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule,
-            l7rule[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=self.l7policy_id)
-        if not CONF.load_balancer.test_with_noop:
-            l7rule = waiters.wait_for_status(
-                self.mem_l7rule_client.show_l7rule,
-                l7rule[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout,
-                l7policy_id=self.l7policy_id)
-
-        parser.parse(l7rule[const.CREATED_AT])
-        parser.parse(l7rule[const.UPDATED_AT])
-        UUID(l7rule[const.ID])
-        # Operating status for a l7rule will be ONLINE if it is enabled:
-        if l7rule[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7rule[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7rule[const.OPERATING_STATUS])
-
-        equal_items = [const.ADMIN_STATE_UP, const.TYPE, const.VALUE,
-                       const.COMPARE_TYPE, const.KEY, const.INVERT]
-
-        for item in equal_items:
-            self.assertEqual(l7rule_kwargs[item], l7rule[item])
-
-        # Test that a user with lb_admin role can see the l7rule
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            l7rule_client = self.os_roles_lb_admin.l7rule_client
-            l7rule_adm = l7rule_client.show_l7rule(
-                l7rule[const.ID], l7policy_id=self.l7policy_id)
-            self.assertEqual(l7rule_kwargs[const.KEY], l7rule_adm[const.KEY])
-
-        # Test that a user with cloud admin role can see the l7rule
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.l7rule_client.show_l7rule(
-                l7rule[const.ID], l7policy_id=self.l7policy_id)
-            self.assertEqual(l7rule_kwargs[const.KEY], adm[const.KEY])
-
-        # Test that a different user, with load balancer member role, cannot
-        # see this l7rule
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7rule_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.show_l7rule,
-                              l7rule[const.ID], l7policy_id=self.l7policy_id)
-
-        # Test that a user, without the load balancer member role, cannot
-        # show l7rules
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7rule_client.show_l7rule,
-                l7rule[const.ID], l7policy_id=self.l7policy_id)
-
-    @decorators.idempotent_id('f8cee23b-89b6-4f3a-a842-1463daf42cf7')
-    def test_l7rule_update(self):
-        """Tests l7rule show API and field filtering.
-
-        * Create a fully populated l7rule.
-        * Show l7rule details.
-        * Validate the show reflects the initial values.
-        * Validates that other accounts cannot update the l7rule.
-        * Update the l7rule details.
-        * Show l7rule details.
-        * Validate the show reflects the initial values.
-        """
-        l7rule_kwargs = {
-            const.ADMIN_STATE_UP: False,
-            const.L7POLICY_ID: self.l7policy_id,
-            const.TYPE: const.HEADER,
-            const.VALUE: 'myvalue-update',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey-update',
-            const.INVERT: False,
-        }
-
-        l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule[const.ID], l7policy_id=self.l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7rule = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule,
-            l7rule[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=self.l7policy_id)
-
-        parser.parse(l7rule[const.CREATED_AT])
-        parser.parse(l7rule[const.UPDATED_AT])
-        UUID(l7rule[const.ID])
-        # Operating status for a l7rule will be ONLINE if it is enabled:
-        if l7rule[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7rule[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7rule[const.OPERATING_STATUS])
-
-        equal_items = [const.ADMIN_STATE_UP, const.TYPE, const.VALUE,
-                       const.COMPARE_TYPE, const.KEY, const.INVERT]
-
-        for item in equal_items:
-            self.assertEqual(l7rule_kwargs[item], l7rule[item])
-
-        # Test that a user, without the load balancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7rule_client.update_l7rule,
-                l7rule[const.ID], l7policy_id=self.l7policy_id,
-                admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        l7rule_check = self.mem_l7rule_client.show_l7rule(
-            l7rule[const.ID], l7policy_id=self.l7policy_id)
-        self.assertEqual(const.ACTIVE, l7rule_check[const.PROVISIONING_STATUS])
-        self.assertEqual(False, l7rule_check[const.ADMIN_STATE_UP])
-
-        # Test that a user, without the load balancer member role, cannot
-        # update this l7rule
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7rule_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.update_l7rule,
-                              l7rule[const.ID], l7policy_id=self.l7policy_id,
-                              admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        l7rule_check = self.mem_l7rule_client.show_l7rule(
-            l7rule[const.ID], l7policy_id=self.l7policy_id)
-        self.assertEqual(const.ACTIVE, l7rule_check[const.PROVISIONING_STATUS])
-        self.assertEqual(False, l7rule_check[const.ADMIN_STATE_UP])
-
-        l7rule_update_kwargs = {
-            const.L7POLICY_ID: self.l7policy_id,
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.COOKIE,
-            const.VALUE: 'myvalue-UPDATED',
-            const.COMPARE_TYPE: const.CONTAINS,
-            const.KEY: 'mykey-UPDATED',
-            const.INVERT: True,
-        }
-        l7rule = self.mem_l7rule_client.update_l7rule(
-            l7rule[const.ID], **l7rule_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7rule = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule,
-            l7rule[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=self.l7policy_id)
-
-        # Operating status for a l7rule will be ONLINE if it is enabled:
-        if l7rule[const.ADMIN_STATE_UP]:
-            self.assertEqual(const.ONLINE, l7rule[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.OFFLINE, l7rule[const.OPERATING_STATUS])
-
-        # Test changed items (which is all of them, for l7rules)
-        equal_items = [const.ADMIN_STATE_UP, const.TYPE, const.VALUE,
-                       const.COMPARE_TYPE, const.KEY, const.INVERT]
-        for item in equal_items:
-            self.assertEqual(l7rule_update_kwargs[item], l7rule[item])
-
-    @decorators.idempotent_id('8e15d68d-70e7-4cf3-82bc-9604384654a0')
-    def test_l7rule_delete(self):
-        """Tests l7rule create and delete APIs.
-
-        * Creates a l7rule.
-        * Validates that other accounts cannot delete the l7rule
-        * Deletes the l7rule.
-        * Validates the l7rule is in the DELETED state.
-        """
-        l7rule_kwargs = {
-            const.L7POLICY_ID: self.l7policy_id,
-            const.TYPE: const.HEADER,
-            const.VALUE: 'myvalue-delete',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey-delete',
-        }
-        l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule[const.ID], l7policy_id=self.l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test that a user without the load balancer role cannot
-        # delete this l7rule
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.l7rule_client.delete_l7rule,
-                l7rule[const.ID], l7policy_id=self.l7policy_id)
-
-        # Test that a different user, with the load balancer member role
-        # cannot delete this l7rule
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.l7rule_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.delete_l7rule,
-                              l7rule[const.ID], l7policy_id=self.l7policy_id)
-
-        self.mem_l7rule_client.delete_l7rule(l7rule[const.ID],
-                                             l7policy_id=self.l7policy_id)
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_l7rule_client.show_l7rule, l7rule[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout,
-            l7policy_id=self.l7policy_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/api/v2/test_listener.py b/octavia_tempest_plugin/tests/api/v2/test_listener.py
deleted file mode 100644
index 38da0ae..0000000
--- a/octavia_tempest_plugin/tests/api/v2/test_listener.py
+++ /dev/null
@@ -1,766 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-from uuid import UUID
-
-from dateutil import parser
-from oslo_utils import strutils
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class ListenerAPITest(test_base.LoadBalancerBaseTest):
-    """Test the listener object API."""
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(ListenerAPITest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_listener")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-    @decorators.idempotent_id('88d0ec83-7b08-48d9-96e2-0df1d2f8cd98')
-    def test_listener_create(self):
-        """Tests listener create and basic show APIs.
-
-        * Tests that users without the loadbalancer member role cannot
-          create listeners.
-        * Create a fully populated listener.
-        * Show listener details.
-        * Validate the show reflects the requested values.
-        """
-        listener_name = data_utils.rand_name("lb_member_listener1-create")
-        listener_description = data_utils.arbitrary_string(size=255)
-
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.DESCRIPTION: listener_description,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 80,
-            const.LOADBALANCER_ID: self.lb_id,
-            const.CONNECTION_LIMIT: 200,
-            const.INSERT_HEADERS: {
-                const.X_FORWARDED_FOR: "true",
-                const.X_FORWARDED_PORT: "true"
-            },
-            # Don't test with a default pool -- we'll do that in the scenario,
-            # but this will allow us to test that the field isn't mandatory,
-            # as well as not conflate pool failures with listener test failures
-            # const.DEFAULT_POOL_ID: self.pool_id,
-
-            # TODO(rm_work): need to add TLS related stuff
-            # const.DEFAULT_TLS_CONTAINER_REF: '',
-            # const.SNI_CONTAINER_REFS: [],
-        }
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            listener_kwargs.update({
-                const.TIMEOUT_CLIENT_DATA: 1000,
-                const.TIMEOUT_MEMBER_CONNECT: 1000,
-                const.TIMEOUT_MEMBER_DATA: 1000,
-                const.TIMEOUT_TCP_INSPECT: 50,
-            })
-
-        # Test that a user without the load balancer role cannot
-        # create a listener
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.listener_client.create_listener,
-                **listener_kwargs)
-
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        listener = waiters.wait_for_status(
-            self.mem_listener_client.show_listener,
-            listener[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            listener = waiters.wait_for_status(
-                self.mem_listener_client.show_listener,
-                listener[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(listener_name, listener[const.NAME])
-        self.assertEqual(listener_description, listener[const.DESCRIPTION])
-        self.assertTrue(listener[const.ADMIN_STATE_UP])
-        parser.parse(listener[const.CREATED_AT])
-        parser.parse(listener[const.UPDATED_AT])
-        UUID(listener[const.ID])
-        # Operating status is a measured status, so no-op will not go online
-        if CONF.load_balancer.test_with_noop:
-            self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.ONLINE, listener[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, listener[const.PROTOCOL])
-        self.assertEqual(80, listener[const.PROTOCOL_PORT])
-        self.assertEqual(200, listener[const.CONNECTION_LIMIT])
-        insert_headers = listener[const.INSERT_HEADERS]
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR]))
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT]))
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            self.assertEqual(1000, listener[const.TIMEOUT_CLIENT_DATA])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_CONNECT])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_DATA])
-            self.assertEqual(50, listener[const.TIMEOUT_TCP_INSPECT])
-
-    @decorators.idempotent_id('78ba6eb0-178c-477e-9156-b6775ca7b271')
-    def test_listener_list(self):
-        """Tests listener list API and field filtering.
-
-        * Create a clean loadbalancer.
-        * Create three listeners.
-        * Validates that other accounts cannot list the listeners.
-        * List the listeners using the default sort order.
-        * List the listeners using descending sort order.
-        * List the listeners using ascending sort order.
-        * List the listeners returning one field at a time.
-        * List the listeners returning two fields.
-        * List the listeners filtering to one of the three.
-        * List the listeners filtered, one field, and sorted.
-        """
-        lb_name = data_utils.rand_name("lb_member_lb2_listener-list")
-        lb = self.mem_lb_client.create_loadbalancer(
-            name=lb_name,
-            vip_network_id=self.lb_member_vip_net[const.ID])
-        lb_id = lb[const.ID]
-        self.addCleanup(
-            self.mem_lb_client.cleanup_loadbalancer,
-            lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener1_name = data_utils.rand_name("lb_member_listener2-list")
-        listener1_desc = 'B'
-        listener1_kwargs = {
-            const.NAME: listener1_name,
-            const.DESCRIPTION: listener1_desc,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 80,
-            const.LOADBALANCER_ID: lb_id,
-        }
-        listener1 = self.mem_listener_client.create_listener(
-            **listener1_kwargs)
-        self.addCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener1[const.ID],
-            lb_client=self.mem_lb_client, lb_id=lb_id)
-        listener1 = waiters.wait_for_status(
-            self.mem_listener_client.show_listener, listener1[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        listener2_name = data_utils.rand_name("lb_member_listener1-list")
-        listener2_desc = 'A'
-        listener2_kwargs = {
-            const.NAME: listener2_name,
-            const.DESCRIPTION: listener2_desc,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 81,
-            const.LOADBALANCER_ID: lb_id,
-        }
-        listener2 = self.mem_listener_client.create_listener(
-            **listener2_kwargs)
-        self.addCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener2[const.ID],
-            lb_client=self.mem_lb_client, lb_id=lb_id)
-        listener2 = waiters.wait_for_status(
-            self.mem_listener_client.show_listener, listener2[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        listener3_name = data_utils.rand_name("lb_member_listener3-list")
-        listener3_desc = 'C'
-        listener3_kwargs = {
-            const.NAME: listener3_name,
-            const.DESCRIPTION: listener3_desc,
-            const.ADMIN_STATE_UP: False,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 82,
-            const.LOADBALANCER_ID: lb_id,
-        }
-        listener3 = self.mem_listener_client.create_listener(
-            **listener3_kwargs)
-        self.addCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener3[const.ID],
-            lb_client=self.mem_lb_client, lb_id=lb_id)
-        listener3 = waiters.wait_for_status(
-            self.mem_listener_client.show_listener, listener3[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        if not CONF.load_balancer.test_with_noop:
-            # Wait for the enabled listeners to come ONLINE
-            listener1 = waiters.wait_for_status(
-                self.mem_listener_client.show_listener, listener1[const.ID],
-                const.OPERATING_STATUS, const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-            listener2 = waiters.wait_for_status(
-                self.mem_listener_client.show_listener, listener2[const.ID],
-                const.OPERATING_STATUS, const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        # Test that a different user cannot list listeners
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.listener_client
-            primary = member2_client.list_listeners(
-                query_params='loadbalancer_id={lb_id}'.format(lb_id=lb_id))
-            self.assertEqual(0, len(primary))
-
-        # Test that a user without the lb member role cannot list load
-        # balancers
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.listener_client.list_listeners)
-
-        # Check the default sort order, created_at
-        listeners = self.mem_listener_client.list_listeners(
-            query_params='loadbalancer_id={lb_id}'.format(lb_id=lb_id))
-        self.assertEqual(listener1[const.DESCRIPTION],
-                         listeners[0][const.DESCRIPTION])
-        self.assertEqual(listener2[const.DESCRIPTION],
-                         listeners[1][const.DESCRIPTION])
-        self.assertEqual(listener3[const.DESCRIPTION],
-                         listeners[2][const.DESCRIPTION])
-
-        # Test sort descending by description
-        listeners = self.mem_listener_client.list_listeners(
-            query_params='loadbalancer_id={lb_id}&{sort}={descr}:{desc}'
-                         .format(lb_id=lb_id, sort=const.SORT,
-                                 descr=const.DESCRIPTION, desc=const.DESC))
-        self.assertEqual(listener1[const.DESCRIPTION],
-                         listeners[1][const.DESCRIPTION])
-        self.assertEqual(listener2[const.DESCRIPTION],
-                         listeners[2][const.DESCRIPTION])
-        self.assertEqual(listener3[const.DESCRIPTION],
-                         listeners[0][const.DESCRIPTION])
-
-        # Test sort ascending by description
-        listeners = self.mem_listener_client.list_listeners(
-            query_params='loadbalancer_id={lb_id}&{sort}={descr}:{asc}'
-                         .format(lb_id=lb_id, sort=const.SORT,
-                                 descr=const.DESCRIPTION, asc=const.ASC))
-        self.assertEqual(listener1[const.DESCRIPTION],
-                         listeners[1][const.DESCRIPTION])
-        self.assertEqual(listener2[const.DESCRIPTION],
-                         listeners[0][const.DESCRIPTION])
-        self.assertEqual(listener3[const.DESCRIPTION],
-                         listeners[2][const.DESCRIPTION])
-
-        # Test fields
-        show_listener_response_fields = const.SHOW_LISTENER_RESPONSE_FIELDS
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            show_listener_response_fields.append('timeout_client_data')
-            show_listener_response_fields.append('timeout_member_connect')
-            show_listener_response_fields.append('timeout_member_data')
-            show_listener_response_fields.append('timeout_tcp_inspect')
-        for field in show_listener_response_fields:
-            if field in (const.DEFAULT_POOL_ID, const.L7_POLICIES):
-                continue
-            listeners = self.mem_listener_client.list_listeners(
-                query_params='loadbalancer_id={lb_id}&{fields}={field}'
-                             .format(lb_id=lb_id,
-                                     fields=const.FIELDS, field=field))
-            self.assertEqual(1, len(listeners[0]))
-            self.assertEqual(listener1[field], listeners[0][field])
-            self.assertEqual(listener2[field], listeners[1][field])
-            self.assertEqual(listener3[field], listeners[2][field])
-
-        # Test multiple fields at the same time
-        listeners = self.mem_listener_client.list_listeners(
-            query_params='loadbalancer_id={lb_id}&{fields}={admin}&'
-                         '{fields}={created}'.format(
-                             lb_id=lb_id, fields=const.FIELDS,
-                             admin=const.ADMIN_STATE_UP,
-                             created=const.CREATED_AT))
-        self.assertEqual(2, len(listeners[0]))
-        self.assertTrue(listeners[0][const.ADMIN_STATE_UP])
-        parser.parse(listeners[0][const.CREATED_AT])
-        self.assertTrue(listeners[1][const.ADMIN_STATE_UP])
-        parser.parse(listeners[1][const.CREATED_AT])
-        self.assertFalse(listeners[2][const.ADMIN_STATE_UP])
-        parser.parse(listeners[2][const.CREATED_AT])
-
-        # Test filtering
-        listeners = self.mem_listener_client.list_listeners(
-            query_params='loadbalancer_id={lb_id}&{desc}={lb_desc}'.format(
-                lb_id=lb_id, desc=const.DESCRIPTION,
-                lb_desc=listener2[const.DESCRIPTION]))
-        self.assertEqual(1, len(listeners))
-        self.assertEqual(listener2[const.DESCRIPTION],
-                         listeners[0][const.DESCRIPTION])
-
-        # Test combined params
-        listeners = self.mem_listener_client.list_listeners(
-            query_params='loadbalancer_id={lb_id}&{admin}={true}&'
-                         '{fields}={descr}&{fields}={id}&'
-                         '{sort}={descr}:{desc}'.format(
-                             lb_id=lb_id, admin=const.ADMIN_STATE_UP,
-                             true=const.ADMIN_STATE_UP_TRUE,
-                             fields=const.FIELDS, descr=const.DESCRIPTION,
-                             id=const.ID, sort=const.SORT, desc=const.DESC))
-        # Should get two listeners
-        self.assertEqual(2, len(listeners))
-        # listeners should have two fields
-        self.assertEqual(2, len(listeners[0]))
-        # Should be in descending order
-        self.assertEqual(listener2[const.DESCRIPTION],
-                         listeners[1][const.DESCRIPTION])
-        self.assertEqual(listener1[const.DESCRIPTION],
-                         listeners[0][const.DESCRIPTION])
-
-    @decorators.idempotent_id('6e299eae-6907-4dfc-89c2-e57709d25d3d')
-    def test_listener_show(self):
-        """Tests listener show API.
-
-        * Create a fully populated listener.
-        * Show listener details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the listener.
-        """
-        listener_name = data_utils.rand_name("lb_member_listener1-show")
-        listener_description = data_utils.arbitrary_string(size=255)
-
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.DESCRIPTION: listener_description,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 81,
-            const.LOADBALANCER_ID: self.lb_id,
-            const.CONNECTION_LIMIT: 200,
-            const.INSERT_HEADERS: {
-                const.X_FORWARDED_FOR: "true",
-                const.X_FORWARDED_PORT: "true"
-            },
-            # TODO(rm_work): need to finish the rest of this stuff
-            # const.DEFAULT_POOL_ID: '',
-            # const.DEFAULT_TLS_CONTAINER_REF: '',
-            # const.SNI_CONTAINER_REFS: [],
-        }
-
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            listener_kwargs.update({
-                const.TIMEOUT_CLIENT_DATA: 1000,
-                const.TIMEOUT_MEMBER_CONNECT: 1000,
-                const.TIMEOUT_MEMBER_DATA: 1000,
-                const.TIMEOUT_TCP_INSPECT: 50,
-            })
-
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        listener = waiters.wait_for_status(
-            self.mem_listener_client.show_listener,
-            listener[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            listener = waiters.wait_for_status(
-                self.mem_listener_client.show_listener,
-                listener[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(listener_name, listener[const.NAME])
-        self.assertEqual(listener_description, listener[const.DESCRIPTION])
-        self.assertTrue(listener[const.ADMIN_STATE_UP])
-        parser.parse(listener[const.CREATED_AT])
-        parser.parse(listener[const.UPDATED_AT])
-        UUID(listener[const.ID])
-        # Operating status is a measured status, so no-op will not go online
-        if CONF.load_balancer.test_with_noop:
-            self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.ONLINE, listener[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, listener[const.PROTOCOL])
-        self.assertEqual(81, listener[const.PROTOCOL_PORT])
-        self.assertEqual(200, listener[const.CONNECTION_LIMIT])
-        insert_headers = listener[const.INSERT_HEADERS]
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR]))
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT]))
-
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            self.assertEqual(1000, listener[const.TIMEOUT_CLIENT_DATA])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_CONNECT])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_DATA])
-            self.assertEqual(50, listener[const.TIMEOUT_TCP_INSPECT])
-
-        # Test that a user with lb_admin role can see the listener
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            listener_client = self.os_roles_lb_admin.listener_client
-            listener_adm = listener_client.show_listener(listener[const.ID])
-            self.assertEqual(listener_name, listener_adm[const.NAME])
-
-        # Test that a user with cloud admin role can see the listener
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.listener_client.show_listener(
-                listener[const.ID])
-            self.assertEqual(listener_name, adm[const.NAME])
-
-        # Test that a different user, with load balancer member role, cannot
-        # see this listener
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.listener_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.show_listener,
-                              listener[const.ID])
-
-        # Test that a user, without the load balancer member role, cannot
-        # show listeners
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.listener_client.show_listener,
-                listener[const.ID])
-
-    @decorators.idempotent_id('aaae0298-5778-4c7e-a27a-01549a71b319')
-    def test_listener_update(self):
-        """Tests listener update and show APIs.
-
-        * Create a fully populated listener.
-        * Show listener details.
-        * Validate the show reflects the initial values.
-        * Validates that other accounts cannot update the listener.
-        * Update the listener details.
-        * Show listener details.
-        * Validate the show reflects the updated values.
-        """
-        listener_name = data_utils.rand_name("lb_member_listener1-update")
-        listener_description = data_utils.arbitrary_string(size=255)
-
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.DESCRIPTION: listener_description,
-            const.ADMIN_STATE_UP: False,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 82,
-            const.LOADBALANCER_ID: self.lb_id,
-            const.CONNECTION_LIMIT: 200,
-            const.INSERT_HEADERS: {
-                const.X_FORWARDED_FOR: "true",
-                const.X_FORWARDED_PORT: "true"
-            },
-            # TODO(rm_work): need to finish the rest of this stuff
-            # const.DEFAULT_POOL_ID: '',
-            # const.DEFAULT_TLS_CONTAINER_REF: '',
-            # const.SNI_CONTAINER_REFS: [],
-        }
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            listener_kwargs.update({
-                const.TIMEOUT_CLIENT_DATA: 1000,
-                const.TIMEOUT_MEMBER_CONNECT: 1000,
-                const.TIMEOUT_MEMBER_DATA: 1000,
-                const.TIMEOUT_TCP_INSPECT: 50,
-            })
-
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        listener = waiters.wait_for_status(
-            self.mem_listener_client.show_listener,
-            listener[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(listener_name, listener[const.NAME])
-        self.assertEqual(listener_description, listener[const.DESCRIPTION])
-        self.assertFalse(listener[const.ADMIN_STATE_UP])
-        parser.parse(listener[const.CREATED_AT])
-        parser.parse(listener[const.UPDATED_AT])
-        UUID(listener[const.ID])
-        # Operating status will be OFFLINE while admin_state_up = False
-        self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, listener[const.PROTOCOL])
-        self.assertEqual(82, listener[const.PROTOCOL_PORT])
-        self.assertEqual(200, listener[const.CONNECTION_LIMIT])
-        insert_headers = listener[const.INSERT_HEADERS]
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR]))
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT]))
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            self.assertEqual(1000, listener[const.TIMEOUT_CLIENT_DATA])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_CONNECT])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_DATA])
-            self.assertEqual(50, listener[const.TIMEOUT_TCP_INSPECT])
-
-        # Test that a user, without the load balancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.listener_client.update_listener,
-                listener[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        listener_check = self.mem_listener_client.show_listener(
-            listener[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         listener_check[const.PROVISIONING_STATUS])
-        self.assertFalse(listener_check[const.ADMIN_STATE_UP])
-
-        # Test that a user, without the load balancer member role, cannot
-        # update this listener
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.listener_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.update_listener,
-                              listener[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        listener_check = self.mem_listener_client.show_listener(
-            listener[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         listener_check[const.PROVISIONING_STATUS])
-        self.assertFalse(listener_check[const.ADMIN_STATE_UP])
-
-        new_name = data_utils.rand_name("lb_member_listener1-UPDATED")
-        new_description = data_utils.arbitrary_string(size=255,
-                                                      base_text='new')
-        listener_update_kwargs = {
-            const.NAME: new_name,
-            const.DESCRIPTION: new_description,
-            const.ADMIN_STATE_UP: True,
-            const.CONNECTION_LIMIT: 400,
-            const.INSERT_HEADERS: {
-                const.X_FORWARDED_FOR: "false",
-                const.X_FORWARDED_PORT: "false"
-            },
-            # TODO(rm_work): need to finish the rest of this stuff
-            # const.DEFAULT_POOL_ID: '',
-            # const.DEFAULT_TLS_CONTAINER_REF: '',
-            # const.SNI_CONTAINER_REFS: [],
-        }
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            listener_update_kwargs.update({
-                const.TIMEOUT_CLIENT_DATA: 2000,
-                const.TIMEOUT_MEMBER_CONNECT: 2000,
-                const.TIMEOUT_MEMBER_DATA: 2000,
-                const.TIMEOUT_TCP_INSPECT: 100,
-            })
-
-        listener = self.mem_listener_client.update_listener(
-            listener[const.ID], **listener_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        listener = waiters.wait_for_status(
-            self.mem_listener_client.show_listener,
-            listener[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            listener = waiters.wait_for_status(
-                self.mem_listener_client.show_listener,
-                listener[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(new_name, listener[const.NAME])
-        self.assertEqual(new_description, listener[const.DESCRIPTION])
-        self.assertTrue(listener[const.ADMIN_STATE_UP])
-        # Operating status is a measured status, so no-op will not go online
-        if CONF.load_balancer.test_with_noop:
-            self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.ONLINE, listener[const.OPERATING_STATUS])
-        self.assertEqual(400, listener[const.CONNECTION_LIMIT])
-        insert_headers = listener[const.INSERT_HEADERS]
-        self.assertFalse(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR]))
-        self.assertFalse(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT]))
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            self.assertEqual(2000, listener[const.TIMEOUT_CLIENT_DATA])
-            self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_CONNECT])
-            self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_DATA])
-            self.assertEqual(100, listener[const.TIMEOUT_TCP_INSPECT])
-
-    @decorators.idempotent_id('16f11c82-f069-4592-8954-81b35a98e3b7')
-    def test_listener_delete(self):
-        """Tests listener create and delete APIs.
-
-        * Creates a listener.
-        * Validates that other accounts cannot delete the listener
-        * Deletes the listener.
-        * Validates the listener is in the DELETED state.
-        """
-        listener_name = data_utils.rand_name("lb_member_listener1-delete")
-
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 83,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test that a user without the load balancer role cannot
-        # delete this listener
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.listener_client.delete_listener,
-                listener[const.ID])
-
-        # Test that a different user, with the load balancer member role
-        # cannot delete this listener
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.listener_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.delete_listener,
-                              listener[const.ID])
-
-        self.mem_listener_client.delete_listener(listener[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_listener_client.show_listener, listener[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/api/v2/test_load_balancer.py b/octavia_tempest_plugin/tests/api/v2/test_load_balancer.py
index 35f2dde..935f7a9 100644
--- a/octavia_tempest_plugin/tests/api/v2/test_load_balancer.py
+++ b/octavia_tempest_plugin/tests/api/v2/test_load_balancer.py
@@ -236,6 +236,7 @@
         return [lb for i, lb in enumerate(lbs) if i not in indexes]
 
     @decorators.idempotent_id('6546ef3c-c0e2-46af-b892-f795f4d01119')
+    @decorators.attr(type='smoke')
     def test_load_balancer_list(self):
         """Tests load balancer list API and field filtering.
 
diff --git a/octavia_tempest_plugin/tests/api/v2/test_member.py b/octavia_tempest_plugin/tests/api/v2/test_member.py
deleted file mode 100644
index 18073cc..0000000
--- a/octavia_tempest_plugin/tests/api/v2/test_member.py
+++ /dev/null
@@ -1,924 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import testtools
-import time
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class MemberAPITest(test_base.LoadBalancerBaseTest):
-    """Test the member object API."""
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(MemberAPITest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_member")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_member")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_member")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LISTENER_ID: cls.listener_id,
-        }
-
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    # Note: This test also covers basic member show API
-    @decorators.idempotent_id('0623aa1f-753d-44e7-afa1-017d274eace7')
-    def test_member_ipv4_create(self):
-        self._test_member_create(4)
-
-    # Note: This test also covers basic member show API
-    @decorators.idempotent_id('141944cc-5e2c-4e83-88f8-f61a6797c9b7')
-    @testtools.skipUnless(CONF.load_balancer.test_with_ipv6,
-                          'IPv6 testing is disabled')
-    def test_member_ipv6_create(self):
-        self._test_member_create(6)
-
-    def _test_member_create(self, ip_version):
-        """Tests member create and basic show APIs.
-
-        * Tests that users without the loadbalancer member role cannot
-          create members.
-        * Create a fully populated member.
-        * Show member details.
-        * Validate the show reflects the requested values.
-        """
-        if ip_version == 4:
-            member_address = '192.0.2.1'
-            member_monitor_address = '192.0.2.2'
-        else:
-            member_address = '2001:db8:0:0:0:0:0:1'
-            member_monitor_address = '2001:db8:0:0:0:0:0:2'
-
-        member_name = data_utils.rand_name("lb_member_member1-create")
-        member_kwargs = {
-            const.NAME: member_name,
-            const.ADMIN_STATE_UP: True,
-            const.POOL_ID: self.pool_id,
-            const.ADDRESS: member_address,
-            const.PROTOCOL_PORT: 80,
-            const.WEIGHT: 50,
-            const.MONITOR_ADDRESS: member_monitor_address,
-            const.MONITOR_PORT: 8080,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member_kwargs.update({
-                const.BACKUP: False,
-            })
-
-        if self.lb_member_vip_subnet:
-            member_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        # Test that a user without the load balancer role cannot
-        # create a member
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.member_client.create_member,
-                **member_kwargs)
-
-        member = self.mem_member_client.create_member(**member_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        parser.parse(member[const.CREATED_AT])
-        parser.parse(member[const.UPDATED_AT])
-        UUID(member[const.ID])
-        self.assertEqual(const.NO_MONITOR, member[const.OPERATING_STATUS])
-
-        equal_items = [const.NAME, const.ADMIN_STATE_UP, const.ADDRESS,
-                       const.PROTOCOL_PORT, const.WEIGHT,
-                       const.MONITOR_ADDRESS, const.MONITOR_PORT]
-
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            equal_items.append(const.BACKUP)
-
-        if const.SUBNET_ID in member_kwargs:
-            equal_items.append(const.SUBNET_ID)
-        else:
-            self.assertIsNone(member.get(const.SUBNET_ID))
-
-        for item in equal_items:
-            self.assertEqual(member_kwargs[item], member[item])
-
-    @decorators.idempotent_id('9ce7ad78-915b-42ce-b0d8-44d88a929f3d')
-    def test_member_list(self):
-        """Tests member list API and field filtering.
-
-        * Create a clean pool.
-        * Create three members.
-        * Validates that other accounts cannot list the members.
-        * List the members using the default sort order.
-        * List the members using descending sort order.
-        * List the members using ascending sort order.
-        * List the members returning one field at a time.
-        * List the members returning two fields.
-        * List the members filtering to one of the three.
-        * List the members filtered, one field, and sorted.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool2_member-list")
-        pool = self.mem_pool_client.create_pool(
-            name=pool_name, loadbalancer_id=self.lb_id,
-            protocol=const.HTTP, lb_algorithm=const.LB_ALGORITHM_ROUND_ROBIN)
-        pool_id = pool[const.ID]
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool, pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        member1_name = data_utils.rand_name("lb_member_member2-list")
-        member1_kwargs = {
-            const.POOL_ID: pool_id,
-            const.NAME: member1_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 101,
-        }
-        member1 = self.mem_member_client.create_member(
-            **member1_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member1[const.ID], pool_id=pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        member1 = waiters.wait_for_status(
-            self.mem_member_client.show_member, member1[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=pool_id)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.check_interval,
-                                CONF.load_balancer.check_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        member2_name = data_utils.rand_name("lb_member_member1-list")
-        member2_kwargs = {
-            const.POOL_ID: pool_id,
-            const.NAME: member2_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 100,
-        }
-        member2 = self.mem_member_client.create_member(
-            **member2_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member2[const.ID], pool_id=pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        member2 = waiters.wait_for_status(
-            self.mem_member_client.show_member, member2[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=pool_id)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.check_interval,
-                                CONF.load_balancer.check_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        member3_name = data_utils.rand_name("lb_member_member3-list")
-        member3_kwargs = {
-            const.POOL_ID: pool_id,
-            const.NAME: member3_name,
-            const.ADMIN_STATE_UP: False,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 102,
-        }
-        member3 = self.mem_member_client.create_member(
-            **member3_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member3[const.ID], pool_id=pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        member3 = waiters.wait_for_status(
-            self.mem_member_client.show_member, member3[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=pool_id)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.check_interval,
-                                CONF.load_balancer.check_timeout)
-
-        # Test that a different user cannot list members
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.member_client
-            self.assertRaises(
-                exceptions.Forbidden,
-                member2_client.list_members,
-                pool_id)
-
-        # Test that a user without the lb member role cannot list load
-        # balancers
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.member_client.list_members,
-                pool_id)
-
-        # Check the default sort order, created_at
-        members = self.mem_member_client.list_members(pool_id)
-        self.assertEqual(member1[const.PROTOCOL_PORT],
-                         members[0][const.PROTOCOL_PORT])
-        self.assertEqual(member2[const.PROTOCOL_PORT],
-                         members[1][const.PROTOCOL_PORT])
-        self.assertEqual(member3[const.PROTOCOL_PORT],
-                         members[2][const.PROTOCOL_PORT])
-
-        # Test sort descending by protocol_port
-        members = self.mem_member_client.list_members(
-            pool_id, query_params='{sort}={descr}:{desc}'.format(
-                sort=const.SORT, descr=const.PROTOCOL_PORT, desc=const.DESC))
-        self.assertEqual(member1[const.PROTOCOL_PORT],
-                         members[1][const.PROTOCOL_PORT])
-        self.assertEqual(member2[const.PROTOCOL_PORT],
-                         members[2][const.PROTOCOL_PORT])
-        self.assertEqual(member3[const.PROTOCOL_PORT],
-                         members[0][const.PROTOCOL_PORT])
-
-        # Test sort ascending by protocol_port
-        members = self.mem_member_client.list_members(
-            pool_id, query_params='{sort}={descr}:{asc}'.format(
-                sort=const.SORT, descr=const.PROTOCOL_PORT, asc=const.ASC))
-        self.assertEqual(member1[const.PROTOCOL_PORT],
-                         members[1][const.PROTOCOL_PORT])
-        self.assertEqual(member2[const.PROTOCOL_PORT],
-                         members[0][const.PROTOCOL_PORT])
-        self.assertEqual(member3[const.PROTOCOL_PORT],
-                         members[2][const.PROTOCOL_PORT])
-
-        # Test fields
-        show_member_response_fields = const.SHOW_MEMBER_RESPONSE_FIELDS
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            show_member_response_fields.append('backup')
-        for field in show_member_response_fields:
-            members = self.mem_member_client.list_members(
-                pool_id, query_params='{fields}={field}'.format(
-                    fields=const.FIELDS, field=field))
-            self.assertEqual(1, len(members[0]))
-            self.assertEqual(member1[field], members[0][field])
-            self.assertEqual(member2[field], members[1][field])
-            self.assertEqual(member3[field], members[2][field])
-
-        # Test multiple fields at the same time
-        members = self.mem_member_client.list_members(
-            pool_id,
-            query_params='{fields}={admin}&{fields}={created}'.format(
-                fields=const.FIELDS, admin=const.ADMIN_STATE_UP,
-                created=const.CREATED_AT))
-        self.assertEqual(2, len(members[0]))
-        self.assertTrue(members[0][const.ADMIN_STATE_UP])
-        parser.parse(members[0][const.CREATED_AT])
-        self.assertTrue(members[1][const.ADMIN_STATE_UP])
-        parser.parse(members[1][const.CREATED_AT])
-        self.assertFalse(members[2][const.ADMIN_STATE_UP])
-        parser.parse(members[2][const.CREATED_AT])
-
-        # Test filtering
-        members = self.mem_member_client.list_members(
-            pool_id,
-            query_params='{desc}={lb_desc}'.format(
-                desc=const.PROTOCOL_PORT,
-                lb_desc=member2[const.PROTOCOL_PORT]))
-        self.assertEqual(1, len(members))
-        self.assertEqual(member2[const.PROTOCOL_PORT],
-                         members[0][const.PROTOCOL_PORT])
-
-        # Test combined params
-        members = self.mem_member_client.list_members(
-            pool_id,
-            query_params='{admin}={true}&'
-                         '{fields}={descr}&{fields}={id}&'
-                         '{sort}={descr}:{desc}'.format(
-                             admin=const.ADMIN_STATE_UP,
-                             true=const.ADMIN_STATE_UP_TRUE,
-                             fields=const.FIELDS, descr=const.PROTOCOL_PORT,
-                             id=const.ID, sort=const.SORT, desc=const.DESC))
-        # Should get two members
-        self.assertEqual(2, len(members))
-        # members should have two fields
-        self.assertEqual(2, len(members[0]))
-        # Should be in descending order
-        self.assertEqual(member2[const.PROTOCOL_PORT],
-                         members[1][const.PROTOCOL_PORT])
-        self.assertEqual(member1[const.PROTOCOL_PORT],
-                         members[0][const.PROTOCOL_PORT])
-
-    @decorators.idempotent_id('7674ae04-7e92-44ef-9adf-40718d7ec705')
-    def test_member_show(self):
-        """Tests member show API.
-
-        * Create a fully populated member.
-        * Show member details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the member.
-        """
-        member_name = data_utils.rand_name("lb_member_member1-show")
-        member_kwargs = {
-            const.NAME: member_name,
-            const.ADMIN_STATE_UP: True,
-            const.POOL_ID: self.pool_id,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 81,
-            const.WEIGHT: 50,
-            const.MONITOR_ADDRESS: '192.0.2.2',
-            const.MONITOR_PORT: 8080,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member_kwargs.update({
-                const.BACKUP: False,
-            })
-        if self.lb_member_vip_subnet:
-            member_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        member = self.mem_member_client.create_member(**member_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        parser.parse(member[const.CREATED_AT])
-        parser.parse(member[const.UPDATED_AT])
-        UUID(member[const.ID])
-        self.assertEqual(const.NO_MONITOR, member[const.OPERATING_STATUS])
-
-        equal_items = [const.NAME, const.ADMIN_STATE_UP, const.ADDRESS,
-                       const.PROTOCOL_PORT, const.WEIGHT,
-                       const.MONITOR_ADDRESS, const.MONITOR_PORT]
-
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            equal_items.append(const.BACKUP)
-
-        if const.SUBNET_ID in member_kwargs:
-            equal_items.append(const.SUBNET_ID)
-        else:
-            self.assertIsNone(member.get(const.SUBNET_ID))
-
-        for item in equal_items:
-            self.assertEqual(member_kwargs[item], member[item])
-
-        # Test that a user with lb_admin role can see the member
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            member_client = self.os_roles_lb_admin.member_client
-            member_adm = member_client.show_member(
-                member[const.ID], pool_id=self.pool_id)
-            self.assertEqual(member_name, member_adm[const.NAME])
-
-        # Test that a user with cloud admin role can see the member
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.member_client.show_member(
-                member[const.ID], pool_id=self.pool_id)
-            self.assertEqual(member_name, adm[const.NAME])
-
-        # Test that a different user, with load balancer member role, cannot
-        # see this member
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.member_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.show_member,
-                              member[const.ID], pool_id=self.pool_id)
-
-        # Test that a user, without the load balancer member role, cannot
-        # show members
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.member_client.show_member,
-                member[const.ID], pool_id=self.pool_id)
-
-    @decorators.idempotent_id('c07572b8-e853-48f3-a8ea-37fc293a4724')
-    def test_member_update(self):
-        """Tests member show API and field filtering.
-
-        * Create a fully populated member.
-        * Show member details.
-        * Validate the show reflects the initial values.
-        * Validates that other accounts cannot update the member.
-        * Update the member details.
-        * Show member details.
-        * Validate the show reflects the initial values.
-        """
-        member_name = data_utils.rand_name("lb_member_member1-update")
-        member_kwargs = {
-            const.NAME: member_name,
-            const.ADMIN_STATE_UP: False,
-            const.POOL_ID: self.pool_id,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 82,
-            const.WEIGHT: 50,
-            const.MONITOR_ADDRESS: '192.0.2.2',
-            const.MONITOR_PORT: 8080,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member_kwargs.update({
-                const.BACKUP: False,
-            })
-
-        if self.lb_member_vip_subnet:
-            member_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        member = self.mem_member_client.create_member(**member_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        if not CONF.load_balancer.test_with_noop:
-            member = waiters.wait_for_status(
-                self.mem_member_client.show_member,
-                member[const.ID], const.OPERATING_STATUS,
-                const.OFFLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout,
-                pool_id=self.pool_id)
-
-        parser.parse(member[const.CREATED_AT])
-        parser.parse(member[const.UPDATED_AT])
-        UUID(member[const.ID])
-
-        equal_items = [const.NAME, const.ADMIN_STATE_UP, const.ADDRESS,
-                       const.PROTOCOL_PORT, const.WEIGHT,
-                       const.MONITOR_ADDRESS, const.MONITOR_PORT]
-
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            equal_items.append(const.BACKUP)
-
-        if const.SUBNET_ID in member_kwargs:
-            equal_items.append(const.SUBNET_ID)
-        else:
-            self.assertIsNone(member.get(const.SUBNET_ID))
-
-        for item in equal_items:
-            self.assertEqual(member_kwargs[item], member[item])
-
-        if CONF.load_balancer.test_with_noop:
-            # Operating status with noop will stay in NO_MONITOR
-            self.assertEqual(const.NO_MONITOR, member[const.OPERATING_STATUS])
-        else:
-            # Operating status will be OFFLINE while admin_state_up = False
-            self.assertEqual(const.OFFLINE, member[const.OPERATING_STATUS])
-
-        # Test that a user, without the load balancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.member_client.update_member,
-                member[const.ID], pool_id=self.pool_id, admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        member_check = self.mem_member_client.show_member(
-            member[const.ID], pool_id=self.pool_id)
-        self.assertEqual(const.ACTIVE,
-                         member_check[const.PROVISIONING_STATUS])
-        self.assertEqual(member_kwargs[const.ADMIN_STATE_UP],
-                         member_check[const.ADMIN_STATE_UP])
-
-        # Test that a user, without the load balancer member role, cannot
-        # update this member
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.member_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.update_member,
-                              member[const.ID], pool_id=self.pool_id,
-                              admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        member_check = self.mem_member_client.show_member(
-            member[const.ID], pool_id=self.pool_id)
-        self.assertEqual(const.ACTIVE,
-                         member_check[const.PROVISIONING_STATUS])
-        self.assertEqual(member_kwargs[const.ADMIN_STATE_UP],
-                         member_check[const.ADMIN_STATE_UP])
-
-        new_name = data_utils.rand_name("lb_member_member1-UPDATED")
-        member_update_kwargs = {
-            const.POOL_ID: member_kwargs[const.POOL_ID],
-            const.NAME: new_name,
-            const.ADMIN_STATE_UP: not member[const.ADMIN_STATE_UP],
-            const.WEIGHT: member[const.WEIGHT] + 1,
-            const.MONITOR_ADDRESS: '192.0.2.3',
-            const.MONITOR_PORT: member[const.MONITOR_PORT] + 1,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member_update_kwargs.update({
-                const.BACKUP: not member[const.BACKUP]
-            })
-
-        member = self.mem_member_client.update_member(
-            member[const.ID], **member_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        if not CONF.load_balancer.test_with_noop:
-            member = waiters.wait_for_status(
-                self.mem_member_client.show_member,
-                member[const.ID], const.OPERATING_STATUS,
-                const.NO_MONITOR,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout,
-                pool_id=self.pool_id)
-
-        # Operating status will be NO_MONITOR regardless of noop
-        self.assertEqual(const.NO_MONITOR, member[const.OPERATING_STATUS])
-
-        # Test changed items
-        equal_items = [const.NAME, const.ADMIN_STATE_UP, const.WEIGHT,
-                       const.MONITOR_ADDRESS, const.MONITOR_PORT]
-
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            equal_items.append(const.BACKUP)
-
-        for item in equal_items:
-            self.assertEqual(member_update_kwargs[item], member[item])
-
-        # Test unchanged items
-        equal_items = [const.ADDRESS, const.PROTOCOL_PORT]
-        if const.SUBNET_ID in member_kwargs:
-            equal_items.append(const.SUBNET_ID)
-        else:
-            self.assertIsNone(member.get(const.SUBNET_ID))
-
-        for item in equal_items:
-            self.assertEqual(member_kwargs[item], member[item])
-
-    @decorators.idempotent_id('83e0a9f2-491f-46a8-b3ce-6969d70a4e9f')
-    def test_member_batch_update(self):
-        """Tests member batch update.
-
-        * Create two members.
-        * Batch update the members so one is deleted, created, and updated
-        * Validate the member list is correct.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool3_member-batch")
-        pool = self.mem_pool_client.create_pool(
-            name=pool_name, loadbalancer_id=self.lb_id,
-            protocol=const.HTTP, lb_algorithm=const.LB_ALGORITHM_ROUND_ROBIN)
-        pool_id = pool[const.ID]
-        self.addClassResourceCleanup(
-            self.mem_pool_client.cleanup_pool, pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        member1_name = data_utils.rand_name("lb_member_member1-batch")
-        member1_kwargs = {
-            const.NAME: member1_name,
-            const.ADMIN_STATE_UP: True,
-            const.POOL_ID: pool_id,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 80,
-            const.WEIGHT: 50,
-            const.MONITOR_ADDRESS: '192.0.2.2',
-            const.MONITOR_PORT: 8080,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member1_kwargs.update({
-                const.BACKUP: False,
-            })
-
-        if self.lb_member_vip_subnet:
-            member1_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        member1 = self.mem_member_client.create_member(**member1_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member1[const.ID], pool_id=pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        member2_name = data_utils.rand_name("lb_member_member2-batch")
-        member2_kwargs = {
-            const.NAME: member2_name,
-            const.ADMIN_STATE_UP: True,
-            const.POOL_ID: pool_id,
-            const.ADDRESS: '192.0.2.3',
-            const.PROTOCOL_PORT: 81,
-            const.WEIGHT: 51,
-            const.MONITOR_ADDRESS: '192.0.2.4',
-            const.MONITOR_PORT: 8081,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member2_kwargs.update({
-                const.BACKUP: True,
-            })
-
-        if self.lb_member_vip_subnet:
-            member2_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        member2 = self.mem_member_client.create_member(**member2_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member2[const.ID], pool_id=pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        member3_name = data_utils.rand_name("lb_member_member3-batch")
-        member3_kwargs = {
-            const.NAME: member3_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: '192.0.2.5',
-            const.PROTOCOL_PORT: 82,
-            const.WEIGHT: 52,
-            const.MONITOR_ADDRESS: '192.0.2.6',
-            const.MONITOR_PORT: 8082,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member3_kwargs.update({
-                const.BACKUP: True,
-            })
-
-        if self.lb_member_vip_subnet:
-            member3_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        member2_name_update = data_utils.rand_name("lb_member_member2-new")
-        member2_kwargs[const.NAME] = member2_name_update
-        member2_kwargs.pop(const.POOL_ID)
-        batch_update_list = [member2_kwargs, member3_kwargs]
-
-        # Test that a user, without the load balancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.member_client.update_members,
-                pool_id=self.pool_id, members_list=batch_update_list)
-
-        # Assert we didn't go into PENDING_*
-        member_check = self.mem_member_client.show_member(
-            member2[const.ID], pool_id=pool_id)
-        self.assertEqual(const.ACTIVE, member_check[const.PROVISIONING_STATUS])
-        self.assertEqual(member2_name, member_check[const.NAME])
-
-        self.mem_member_client.update_members(
-            pool_id=pool_id, members_list=batch_update_list)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        members = self.mem_member_client.list_members(
-            pool_id,
-            query_params='{sort}={port}:{asc}'.format(
-                sort=const.SORT, port=const.PROTOCOL_PORT, asc=const.ASC))
-        for m in members:
-            self.addClassResourceCleanup(
-                self.mem_member_client.cleanup_member,
-                m[const.ID], pool_id=pool_id,
-                lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        # We should have two members: member2 and member3, in that order
-        self.assertEqual(2, len(members))
-        # Member2 is the same ID
-        self.assertEqual(member2[const.ID], members[0][const.ID])
-        # Member3 will have a different ID (not member1)
-        self.assertNotEqual(member1[const.ID], members[1][const.ID])
-
-        # Member2's name should be updated, and member3 should exist
-        self.assertEqual(member2_name_update, members[0][const.NAME])
-        self.assertEqual(member3_name, members[1][const.NAME])
-
-    @decorators.idempotent_id('f129ba5e-a16e-4178-924f-6a9c5b8b1589')
-    def test_member_delete(self):
-        """Tests member create and delete APIs.
-
-        * Creates a member.
-        * Validates that other accounts cannot delete the member
-        * Deletes the member.
-        * Validates the member is in the DELETED state.
-        """
-        member_name = data_utils.rand_name("lb_member_member1-delete")
-        member_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member_name,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 83,
-        }
-        member = self.mem_member_client.create_member(**member_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test that a user without the load balancer role cannot
-        # delete this member
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.member_client.delete_member,
-                member[const.ID], pool_id=self.pool_id)
-
-        # Test that a different user, with the load balancer member role
-        # cannot delete this member
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.member_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.delete_member,
-                              member[const.ID], pool_id=self.pool_id)
-
-        self.mem_member_client.delete_member(member[const.ID],
-                                             pool_id=self.pool_id)
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_member_client.show_member, member[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout,
-            pool_id=self.pool_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/api/v2/test_pool.py b/octavia_tempest_plugin/tests/api/v2/test_pool.py
deleted file mode 100644
index 28b95b6..0000000
--- a/octavia_tempest_plugin/tests/api/v2/test_pool.py
+++ /dev/null
@@ -1,720 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import time
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class PoolAPITest(test_base.LoadBalancerBaseTest):
-    """Test the pool object API."""
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(PoolAPITest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_pool")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_pool")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('7587fe48-87ba-4538-9f03-190911f100ff')
-    def test_pool_create_standalone(self):
-        self._test_pool_create(has_listener=False)
-
-    @decorators.idempotent_id('c9c0df79-f07e-428c-ae57-b9d4078eec79')
-    def test_pool_create_with_listener(self):
-        self._test_pool_create(has_listener=True)
-
-    def _test_pool_create(self, has_listener):
-        """Tests pool create and basic show APIs.
-
-        * Tests that users without the loadbalancer member role cannot
-          create pools.
-        * Create a fully populated pool.
-        * Show pool details.
-        * Validate the show reflects the requested values.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1-create")
-        pool_description = data_utils.arbitrary_string(size=255)
-        pool_sp_cookie_name = 'my_cookie'
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.DESCRIPTION: pool_description,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool_sp_cookie_name,
-            },
-        }
-        if has_listener:
-            pool_kwargs[const.LISTENER_ID] = self.listener_id
-        else:
-            pool_kwargs[const.LOADBALANCER_ID] = self.lb_id
-
-        # Test that a user without the load balancer role cannot
-        # create a pool
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.pool_client.create_pool,
-                **pool_kwargs)
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if has_listener and not CONF.load_balancer.test_with_noop:
-            pool = waiters.wait_for_status(
-                self.mem_pool_client.show_pool,
-                pool[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(pool_name, pool[const.NAME])
-        self.assertEqual(pool_description, pool[const.DESCRIPTION])
-        self.assertTrue(pool[const.ADMIN_STATE_UP])
-        parser.parse(pool[const.CREATED_AT])
-        parser.parse(pool[const.UPDATED_AT])
-        UUID(pool[const.ID])
-        # Operating status for a pool without members will be:
-        if has_listener and not CONF.load_balancer.test_with_noop:
-            # ONLINE if it is attached to a listener and is a live test
-            self.assertEqual(const.ONLINE, pool[const.OPERATING_STATUS])
-        else:
-            # OFFLINE if it is just on the LB directly or is in noop mode
-            self.assertEqual(const.OFFLINE, pool[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, pool[const.PROTOCOL])
-        self.assertEqual(1, len(pool[const.LOADBALANCERS]))
-        self.assertEqual(self.lb_id, pool[const.LOADBALANCERS][0][const.ID])
-        if has_listener:
-            self.assertEqual(1, len(pool[const.LISTENERS]))
-            self.assertEqual(self.listener_id,
-                             pool[const.LISTENERS][0][const.ID])
-        else:
-            self.assertEmpty(pool[const.LISTENERS])
-        self.assertEqual(const.LB_ALGORITHM_ROUND_ROBIN,
-                         pool[const.LB_ALGORITHM])
-        self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE))
-        self.assertEqual(const.SESSION_PERSISTENCE_APP_COOKIE,
-                         pool[const.SESSION_PERSISTENCE][const.TYPE])
-        self.assertEqual(pool_sp_cookie_name,
-                         pool[const.SESSION_PERSISTENCE][const.COOKIE_NAME])
-
-    @decorators.idempotent_id('6959a32e-fb34-4f3e-be68-8880c6450016')
-    def test_pool_list(self):
-        """Tests pool list API and field filtering.
-
-        * Create a clean loadbalancer.
-        * Create three pools.
-        * Validates that other accounts cannot list the pools.
-        * List the pools using the default sort order.
-        * List the pools using descending sort order.
-        * List the pools using ascending sort order.
-        * List the pools returning one field at a time.
-        * List the pools returning two fields.
-        * List the pools filtering to one of the three.
-        * List the pools filtered, one field, and sorted.
-        """
-        lb_name = data_utils.rand_name("lb_member_lb2_pool-list")
-        lb = self.mem_lb_client.create_loadbalancer(
-            name=lb_name,
-            vip_network_id=self.lb_member_vip_net[const.ID])
-        lb_id = lb[const.ID]
-        self.addCleanup(
-            self.mem_lb_client.cleanup_loadbalancer,
-            lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        pool1_name = data_utils.rand_name("lb_member_pool2-list")
-        pool1_desc = 'B'
-        pool1_sp_cookie_name = 'my_cookie1'
-        pool1_kwargs = {
-            const.NAME: pool1_name,
-            const.DESCRIPTION: pool1_desc,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool1_sp_cookie_name,
-            },
-            const.LOADBALANCER_ID: lb_id,
-        }
-        pool1 = self.mem_pool_client.create_pool(
-            **pool1_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool1[const.ID],
-            lb_client=self.mem_lb_client, lb_id=lb_id)
-        pool1 = waiters.wait_for_status(
-            self.mem_pool_client.show_pool, pool1[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        pool2_name = data_utils.rand_name("lb_member_pool1-list")
-        pool2_desc = 'A'
-        pool2_sp_cookie_name = 'my_cookie2'
-        pool2_kwargs = {
-            const.NAME: pool2_name,
-            const.DESCRIPTION: pool2_desc,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool2_sp_cookie_name,
-            },
-            const.LOADBALANCER_ID: lb_id,
-        }
-        pool2 = self.mem_pool_client.create_pool(
-            **pool2_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool2[const.ID],
-            lb_client=self.mem_lb_client, lb_id=lb_id)
-        pool2 = waiters.wait_for_status(
-            self.mem_pool_client.show_pool, pool2[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-        # Time resolution for created_at is only to the second, and we need to
-        # ensure that each object has a distinct creation time. Delaying one
-        # second is both a simple and a reliable way to accomplish this.
-        time.sleep(1)
-
-        pool3_name = data_utils.rand_name("lb_member_pool3-list")
-        pool3_desc = 'C'
-        pool3_kwargs = {
-            const.NAME: pool3_name,
-            const.DESCRIPTION: pool3_desc,
-            const.ADMIN_STATE_UP: False,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            # No session persistence, just so there's one test for that
-            const.LOADBALANCER_ID: lb_id,
-        }
-        pool3 = self.mem_pool_client.create_pool(
-            **pool3_kwargs)
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool3[const.ID],
-            lb_client=self.mem_lb_client, lb_id=lb_id)
-        pool3 = waiters.wait_for_status(
-            self.mem_pool_client.show_pool, pool3[const.ID],
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        # Test that a different user cannot list pools
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.pool_client
-            primary = member2_client.list_pools(
-                query_params='loadbalancer_id={lb_id}'.format(lb_id=lb_id))
-            self.assertEqual(0, len(primary))
-
-        # Test that a user without the lb member role cannot list load
-        # balancers
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.pool_client.list_pools)
-
-        # Check the default sort order, created_at
-        pools = self.mem_pool_client.list_pools(
-            query_params='loadbalancer_id={lb_id}'.format(lb_id=lb_id))
-        self.assertEqual(pool1[const.DESCRIPTION],
-                         pools[0][const.DESCRIPTION])
-        self.assertEqual(pool2[const.DESCRIPTION],
-                         pools[1][const.DESCRIPTION])
-        self.assertEqual(pool3[const.DESCRIPTION],
-                         pools[2][const.DESCRIPTION])
-
-        # Test sort descending by description
-        pools = self.mem_pool_client.list_pools(
-            query_params='loadbalancer_id={lb_id}&{sort}={descr}:{desc}'
-                         .format(lb_id=lb_id, sort=const.SORT,
-                                 descr=const.DESCRIPTION, desc=const.DESC))
-        self.assertEqual(pool1[const.DESCRIPTION],
-                         pools[1][const.DESCRIPTION])
-        self.assertEqual(pool2[const.DESCRIPTION],
-                         pools[2][const.DESCRIPTION])
-        self.assertEqual(pool3[const.DESCRIPTION],
-                         pools[0][const.DESCRIPTION])
-
-        # Test sort ascending by description
-        pools = self.mem_pool_client.list_pools(
-            query_params='loadbalancer_id={lb_id}&{sort}={descr}:{asc}'
-                         .format(lb_id=lb_id, sort=const.SORT,
-                                 descr=const.DESCRIPTION, asc=const.ASC))
-        self.assertEqual(pool1[const.DESCRIPTION],
-                         pools[1][const.DESCRIPTION])
-        self.assertEqual(pool2[const.DESCRIPTION],
-                         pools[0][const.DESCRIPTION])
-        self.assertEqual(pool3[const.DESCRIPTION],
-                         pools[2][const.DESCRIPTION])
-
-        # Test fields
-        for field in const.SHOW_POOL_RESPONSE_FIELDS:
-            pools = self.mem_pool_client.list_pools(
-                query_params='loadbalancer_id={lb_id}&{fields}={field}'
-                             .format(lb_id=lb_id,
-                                     fields=const.FIELDS, field=field))
-            self.assertEqual(1, len(pools[0]))
-            self.assertEqual(pool1[field], pools[0][field])
-            self.assertEqual(pool2[field], pools[1][field])
-            self.assertEqual(pool3[field], pools[2][field])
-
-        # Test multiple fields at the same time
-        pools = self.mem_pool_client.list_pools(
-            query_params='loadbalancer_id={lb_id}&{fields}={admin}&'
-                         '{fields}={created}'.format(
-                             lb_id=lb_id, fields=const.FIELDS,
-                             admin=const.ADMIN_STATE_UP,
-                             created=const.CREATED_AT))
-        self.assertEqual(2, len(pools[0]))
-        self.assertTrue(pools[0][const.ADMIN_STATE_UP])
-        parser.parse(pools[0][const.CREATED_AT])
-        self.assertTrue(pools[1][const.ADMIN_STATE_UP])
-        parser.parse(pools[1][const.CREATED_AT])
-        self.assertFalse(pools[2][const.ADMIN_STATE_UP])
-        parser.parse(pools[2][const.CREATED_AT])
-
-        # Test filtering
-        pools = self.mem_pool_client.list_pools(
-            query_params='loadbalancer_id={lb_id}&{desc}={lb_desc}'.format(
-                lb_id=lb_id, desc=const.DESCRIPTION,
-                lb_desc=pool2[const.DESCRIPTION]))
-        self.assertEqual(1, len(pools))
-        self.assertEqual(pool2[const.DESCRIPTION],
-                         pools[0][const.DESCRIPTION])
-
-        # Test combined params
-        pools = self.mem_pool_client.list_pools(
-            query_params='loadbalancer_id={lb_id}&{admin}={true}&'
-                         '{fields}={descr}&{fields}={id}&'
-                         '{sort}={descr}:{desc}'.format(
-                             lb_id=lb_id, admin=const.ADMIN_STATE_UP,
-                             true=const.ADMIN_STATE_UP_TRUE,
-                             fields=const.FIELDS, descr=const.DESCRIPTION,
-                             id=const.ID, sort=const.SORT, desc=const.DESC))
-        # Should get two pools
-        self.assertEqual(2, len(pools))
-        # pools should have two fields
-        self.assertEqual(2, len(pools[0]))
-        # Should be in descending order
-        self.assertEqual(pool2[const.DESCRIPTION],
-                         pools[1][const.DESCRIPTION])
-        self.assertEqual(pool1[const.DESCRIPTION],
-                         pools[0][const.DESCRIPTION])
-
-    @decorators.idempotent_id('b7932438-1aea-4175-a50c-984fee1c0cad')
-    def test_pool_show(self):
-        """Tests pool show API.
-
-        * Create a fully populated pool.
-        * Show pool details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the pool.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1-show")
-        pool_description = data_utils.arbitrary_string(size=255)
-        pool_sp_cookie_name = 'my_cookie'
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.DESCRIPTION: pool_description,
-            const.ADMIN_STATE_UP: True,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool_sp_cookie_name,
-            },
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(pool_name, pool[const.NAME])
-        self.assertEqual(pool_description, pool[const.DESCRIPTION])
-        self.assertTrue(pool[const.ADMIN_STATE_UP])
-        parser.parse(pool[const.CREATED_AT])
-        parser.parse(pool[const.UPDATED_AT])
-        UUID(pool[const.ID])
-        # Operating status for pools will always be offline without members
-        self.assertEqual(const.OFFLINE, pool[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, pool[const.PROTOCOL])
-        self.assertEqual(1, len(pool[const.LOADBALANCERS]))
-        self.assertEqual(self.lb_id, pool[const.LOADBALANCERS][0][const.ID])
-        self.assertEmpty(pool[const.LISTENERS])
-        self.assertEqual(const.LB_ALGORITHM_ROUND_ROBIN,
-                         pool[const.LB_ALGORITHM])
-        self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE))
-        self.assertEqual(const.SESSION_PERSISTENCE_APP_COOKIE,
-                         pool[const.SESSION_PERSISTENCE][const.TYPE])
-        self.assertEqual(pool_sp_cookie_name,
-                         pool[const.SESSION_PERSISTENCE][const.COOKIE_NAME])
-
-        # Test that a user with lb_admin role can see the pool
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            pool_client = self.os_roles_lb_admin.pool_client
-            pool_adm = pool_client.show_pool(pool[const.ID])
-            self.assertEqual(pool_name, pool_adm[const.NAME])
-
-        # Test that a user with cloud admin role can see the pool
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.pool_client.show_pool(
-                pool[const.ID])
-            self.assertEqual(pool_name, adm[const.NAME])
-
-        # Test that a different user, with load balancer member role, cannot
-        # see this pool
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.pool_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.show_pool,
-                              pool[const.ID])
-
-        # Test that a user, without the load balancer member role, cannot
-        # show pools
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.pool_client.show_pool,
-                pool[const.ID])
-
-    @decorators.idempotent_id('7bd0a6bf-57b4-46a6-83ef-f9991896658a')
-    def test_pool_update(self):
-        """Tests pool update and show APIs.
-
-        * Create a fully populated pool.
-        * Show pool details.
-        * Validate the show reflects the initial values.
-        * Validates that other accounts cannot update the pool.
-        * Update the pool details.
-        * Show pool details.
-        * Validate the show reflects the updated values.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1-update")
-        pool_description = data_utils.arbitrary_string(size=255)
-        pool_sp_cookie_name = 'my_cookie'
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.DESCRIPTION: pool_description,
-            const.ADMIN_STATE_UP: False,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool_sp_cookie_name,
-            },
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(pool_name, pool[const.NAME])
-        self.assertEqual(pool_description, pool[const.DESCRIPTION])
-        self.assertFalse(pool[const.ADMIN_STATE_UP])
-        parser.parse(pool[const.CREATED_AT])
-        parser.parse(pool[const.UPDATED_AT])
-        UUID(pool[const.ID])
-        # Operating status for pools will always be offline without members
-        self.assertEqual(const.OFFLINE, pool[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, pool[const.PROTOCOL])
-        self.assertEqual(1, len(pool[const.LOADBALANCERS]))
-        self.assertEqual(self.lb_id, pool[const.LOADBALANCERS][0][const.ID])
-        self.assertEmpty(pool[const.LISTENERS])
-        self.assertEqual(const.LB_ALGORITHM_ROUND_ROBIN,
-                         pool[const.LB_ALGORITHM])
-        self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE))
-        self.assertEqual(const.SESSION_PERSISTENCE_APP_COOKIE,
-                         pool[const.SESSION_PERSISTENCE][const.TYPE])
-        self.assertEqual(pool_sp_cookie_name,
-                         pool[const.SESSION_PERSISTENCE][const.COOKIE_NAME])
-
-        # Test that a user, without the load balancer member role, cannot
-        # use this command
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.pool_client.update_pool,
-                pool[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        pool_check = self.mem_pool_client.show_pool(
-            pool[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         pool_check[const.PROVISIONING_STATUS])
-        self.assertFalse(pool_check[const.ADMIN_STATE_UP])
-
-        # Test that a user, without the load balancer member role, cannot
-        # update this pool
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.pool_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.update_pool,
-                              pool[const.ID], admin_state_up=True)
-
-        # Assert we didn't go into PENDING_*
-        pool_check = self.mem_pool_client.show_pool(
-            pool[const.ID])
-        self.assertEqual(const.ACTIVE,
-                         pool_check[const.PROVISIONING_STATUS])
-        self.assertFalse(pool_check[const.ADMIN_STATE_UP])
-
-        new_name = data_utils.rand_name("lb_member_pool1-UPDATED")
-        new_description = data_utils.arbitrary_string(size=255,
-                                                      base_text='new')
-        pool_update_kwargs = {
-            const.NAME: new_name,
-            const.DESCRIPTION: new_description,
-            const.ADMIN_STATE_UP: True,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_HTTP_COOKIE,
-            },
-        }
-        pool = self.mem_pool_client.update_pool(
-            pool[const.ID], **pool_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(new_name, pool[const.NAME])
-        self.assertEqual(new_description, pool[const.DESCRIPTION])
-        self.assertTrue(pool[const.ADMIN_STATE_UP])
-        self.assertEqual(const.LB_ALGORITHM_ROUND_ROBIN,
-                         pool[const.LB_ALGORITHM])
-        self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE))
-        self.assertEqual(const.SESSION_PERSISTENCE_HTTP_COOKIE,
-                         pool[const.SESSION_PERSISTENCE][const.TYPE])
-        self.assertIsNone(
-            pool[const.SESSION_PERSISTENCE].get(const.COOKIE_NAME))
-
-        # Also test removing a Session Persistence
-        pool_update_kwargs = {
-            const.SESSION_PERSISTENCE: None,
-        }
-        pool = self.mem_pool_client.update_pool(
-            pool[const.ID], **pool_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        self.assertIsNone(pool.get(const.SESSION_PERSISTENCE))
-
-    @decorators.idempotent_id('35ed3800-7a4a-47a6-9b94-c1033fff1112')
-    def test_pool_delete(self):
-        """Tests pool create and delete APIs.
-
-        * Creates a pool.
-        * Validates that other accounts cannot delete the pool
-        * Deletes the pool.
-        * Validates the pool is in the DELETED state.
-        """
-        pool_name = data_utils.rand_name("lb_member_pool1-delete")
-        pool_sp_cookie_name = 'my_cookie'
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool_sp_cookie_name,
-            },
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test that a user without the load balancer role cannot
-        # delete this pool
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.pool_client.delete_pool,
-                pool[const.ID])
-
-        # Test that a different user, with the load balancer member role
-        # cannot delete this pool
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.pool_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.delete_pool,
-                              pool[const.ID])
-
-        self.mem_pool_client.delete_pool(pool[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_pool_client.show_pool, pool[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_amphora.py b/octavia_tempest_plugin/tests/scenario/v2/test_amphora.py
deleted file mode 100644
index 4f1480c..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_amphora.py
+++ /dev/null
@@ -1,179 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-from tempest.lib import exceptions
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class AmphoraScenarioTest(test_base.LoadBalancerBaseTest):
-    """Test the amphora object API."""
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(AmphoraScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_amphora")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-    def _expected_amp_count(self, amp_list):
-        self.assertNotEmpty(amp_list)
-        if amp_list[0][const.ROLE] in (const.ROLE_MASTER, const.ROLE_BACKUP):
-            return 2
-        return 1
-
-    @decorators.idempotent_id('a0e9ff99-2c4f-45d5-81c9-78d3107c236f')
-    def test_amphora_list_and_show(self):
-        """Tests amphora show API.
-
-        * Show amphora details.
-        * Validate the show reflects the requested values.
-        * Validates that other accounts cannot see the amphora.
-        """
-        lb_name = data_utils.rand_name("lb_member_lb2_amphora-list")
-        lb = self.mem_lb_client.create_loadbalancer(
-            name=lb_name,
-            vip_network_id=self.lb_member_vip_net[const.ID])
-        lb_id = lb[const.ID]
-        self.addCleanup(
-            self.mem_lb_client.cleanup_loadbalancer,
-            lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                lb_id,
-                                const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        # Test that a user with lb_admin role can list the amphora
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            amphora_client = self.os_roles_lb_admin.amphora_client
-            amphora_adm = amphora_client.list_amphorae()
-            self.assertTrue(
-                len(amphora_adm) >= 2 * self._expected_amp_count(amphora_adm))
-
-        # Test that a different user, with load balancer member role, cannot
-        # see this amphora
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            member2_client = self.os_roles_lb_member2.amphora_client
-            self.assertRaises(exceptions.Forbidden,
-                              member2_client.list_amphorae)
-
-        # Test that a user, without the load balancer member role, cannot
-        # list amphorae
-        if CONF.load_balancer.RBAC_test_type == const.ADVANCED:
-            self.assertRaises(
-                exceptions.Forbidden,
-                self.os_primary.amphora_client.list_amphorae)
-
-        # Test that a user with cloud admin role can list the amphorae
-        if not CONF.load_balancer.RBAC_test_type == const.NONE:
-            adm = self.os_admin.amphora_client.list_amphorae()
-            self.assertTrue(len(adm) >= 2 * self._expected_amp_count(adm))
-
-        # Get an actual list of the amphorae
-        amphorae = self.os_admin.amphora_client.list_amphorae()
-
-        # There should be AT LEAST 2, there may be more depending on the
-        # configured topology, or if there are other LBs created besides ours
-        self.assertTrue(
-            len(amphorae) >= 2 * self._expected_amp_count(amphorae))
-
-        show_amphora_response_fields = const.SHOW_AMPHORA_RESPONSE_FIELDS
-        if self.mem_amphora_client.is_version_supported(
-                self.api_version, '2.1'):
-            show_amphora_response_fields.append('created_at')
-            show_amphora_response_fields.append('updated_at')
-            show_amphora_response_fields.append('image_id')
-
-        for amp in amphorae:
-
-            # Make sure all of the fields exist on the amp list records
-            for field in show_amphora_response_fields:
-                self.assertIn(field, amp)
-
-            amp_id = amp[const.ID]
-            amp_obj = self.os_admin.amphora_client.show_amphora(
-                amphora_id=amp_id)
-
-            # Make sure all of the fields exist on the amp show record
-            for field in show_amphora_response_fields:
-                self.assertIn(field, amp_obj)
-
-            # Verify a few of the fields are the right type
-            if self.mem_amphora_client.is_version_supported(
-                    self.api_version, '2.1'):
-                parser.parse(amp_obj[const.CREATED_AT])
-                parser.parse(amp_obj[const.UPDATED_AT])
-            UUID(amp_obj[const.ID])
-            self.assertIn(amp_obj[const.STATUS], const.AMPHORA_STATUSES)
-
-            # We might have gotten unassigned/spare amps?
-            if amp_obj[const.STATUS] == const.STATUS_ALLOCATED:
-                # Only check the state of fields for the LB we created,
-                # otherwise some fields (HA_PORT_ID) may not yet be
-                # populated in amps for parallel tests.
-                if lb_id == amp_obj[const.LOADBALANCER_ID]:
-                    UUID(amp_obj[const.HA_PORT_ID])
-                    UUID(amp_obj[const.LOADBALANCER_ID])
-                    UUID(amp_obj[const.COMPUTE_ID])
-                    UUID(amp_obj[const.VRRP_PORT_ID])
-                    self.assertIn(amp_obj[const.ROLE], const.AMPHORA_ROLES)
-            else:
-                self.assertIsNone(amp_obj[const.ROLE])
-
-            # Test that all of the fields from the amp list match those
-            # from a show
-            for field in show_amphora_response_fields:
-                self.assertEqual(amp[field], amp_obj[field])
-
-        # Test filtering by loadbalancer_id
-        amphorae = self.os_admin.amphora_client.list_amphorae(
-            query_params='{loadbalancer_id}={lb_id}'.format(
-                loadbalancer_id=const.LOADBALANCER_ID, lb_id=self.lb_id))
-        self.assertEqual(self._expected_amp_count(amphorae), len(amphorae))
-        self.assertEqual(self.lb_id, amphorae[0][const.LOADBALANCER_ID])
-
-        amphorae = self.os_admin.amphora_client.list_amphorae(
-            query_params='{loadbalancer_id}={lb_id}'.format(
-                loadbalancer_id=const.LOADBALANCER_ID, lb_id=lb_id))
-        self.assertEqual(self._expected_amp_count(amphorae), len(amphorae))
-        self.assertEqual(lb_id, amphorae[0][const.LOADBALANCER_ID])
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_healthmonitor.py b/octavia_tempest_plugin/tests/scenario/v2/test_healthmonitor.py
deleted file mode 100644
index 7b769e1..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_healthmonitor.py
+++ /dev/null
@@ -1,184 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class HealthMonitorScenarioTest(test_base.LoadBalancerBaseTest):
-
-    @classmethod
-    def skip_checks(cls):
-        super(HealthMonitorScenarioTest, cls).skip_checks()
-        if not CONF.loadbalancer_feature_enabled.health_monitor_enabled:
-            cls.skip('Health Monitors not supported')
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(HealthMonitorScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_hm")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_hm")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('a51e09aa-6e44-4c67-a9e4-df70d0e08f96')
-    def test_healthmonitor_CRUD(self):
-        """Tests healthmonitor create, read, update, delete, and member status
-
-        * Create a fully populated healthmonitor.
-        * Show healthmonitor details.
-        * Update the healthmonitor.
-        * Delete the healthmonitor.
-        """
-        # Healthmonitor create
-        hm_name = data_utils.rand_name("lb_member_hm1-CRUD")
-        hm_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: hm_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 2,
-            const.MAX_RETRIES: 2,
-            const.MAX_RETRIES_DOWN: 2,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/',
-            const.EXPECTED_CODES: '200',
-            const.ADMIN_STATE_UP: True,
-        }
-
-        hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        parser.parse(hm[const.CREATED_AT])
-        parser.parse(hm[const.UPDATED_AT])
-        UUID(hm[const.ID])
-        self.assertEqual(const.ONLINE, hm[const.OPERATING_STATUS])
-
-        equal_items = [const.NAME, const.TYPE, const.DELAY, const.TIMEOUT,
-                       const.MAX_RETRIES, const.MAX_RETRIES_DOWN,
-                       const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES,
-                       const.ADMIN_STATE_UP]
-
-        for item in equal_items:
-            self.assertEqual(hm_kwargs[item], hm[item])
-
-        # Healthmonitor update
-        new_name = data_utils.rand_name("lb_member_hm1-update")
-        hm_update_kwargs = {
-            const.NAME: new_name,
-            const.DELAY: hm_kwargs[const.DELAY] + 1,
-            const.TIMEOUT: hm_kwargs[const.TIMEOUT] + 1,
-            const.MAX_RETRIES: hm_kwargs[const.MAX_RETRIES] + 1,
-            const.MAX_RETRIES_DOWN: hm_kwargs[const.MAX_RETRIES_DOWN] + 1,
-            const.HTTP_METHOD: const.POST,
-            const.URL_PATH: '/test',
-            const.EXPECTED_CODES: '201,202',
-            const.ADMIN_STATE_UP: not hm_kwargs[const.ADMIN_STATE_UP],
-        }
-        hm = self.mem_healthmonitor_client.update_healthmonitor(
-            hm[const.ID], **hm_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Test changed items
-        equal_items = [const.NAME, const.DELAY, const.TIMEOUT,
-                       const.MAX_RETRIES, const.MAX_RETRIES_DOWN,
-                       const.HTTP_METHOD, const.URL_PATH, const.EXPECTED_CODES,
-                       const.ADMIN_STATE_UP]
-
-        for item in equal_items:
-            self.assertEqual(hm_update_kwargs[item], hm[item])
-
-        # Test unchanged items
-        equal_items = [const.TYPE]
-        for item in equal_items:
-            self.assertEqual(hm_kwargs[item], hm[item])
-
-        # Healthmonitor delete
-        self.mem_healthmonitor_client.delete_healthmonitor(hm[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_l7policy.py b/octavia_tempest_plugin/tests/scenario/v2/test_l7policy.py
deleted file mode 100644
index 98d3bc6..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_l7policy.py
+++ /dev/null
@@ -1,202 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class L7PolicyScenarioTest(test_base.LoadBalancerBaseTest):
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(L7PolicyScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_l7policy")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_l7policy")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_l7policy")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('ffd598d9-d8cd-4586-a749-cde4897e64dd')
-    def test_l7policy_CRUD(self):
-        """Tests l7policy create, read, update, delete
-
-        * Create a fully populated l7policy.
-        * Show l7policy details.
-        * Update the l7policy.
-        * Delete the l7policy.
-        """
-
-        # L7Policy create
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1-CRUD")
-        l7policy_description = data_utils.arbitrary_string(size=255)
-        l7policy_kwargs = {
-            const.LISTENER_ID: self.listener_id,
-            const.NAME: l7policy_name,
-            const.DESCRIPTION: l7policy_description,
-            const.ADMIN_STATE_UP: False,
-            const.POSITION: 1,
-            const.ACTION: const.REDIRECT_TO_POOL,
-            const.REDIRECT_POOL_ID: self.pool_id,
-        }
-
-        l7policy = self.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7policy = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy,
-            l7policy[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(l7policy_name, l7policy[const.NAME])
-        self.assertEqual(l7policy_description, l7policy[const.DESCRIPTION])
-        self.assertFalse(l7policy[const.ADMIN_STATE_UP])
-        parser.parse(l7policy[const.CREATED_AT])
-        parser.parse(l7policy[const.UPDATED_AT])
-        UUID(l7policy[const.ID])
-        # Operating status will be OFFLINE while admin_state_up = False
-        self.assertEqual(const.OFFLINE, l7policy[const.OPERATING_STATUS])
-        self.assertEqual(self.listener_id, l7policy[const.LISTENER_ID])
-        self.assertEqual(1, l7policy[const.POSITION])
-        self.assertEqual(const.REDIRECT_TO_POOL, l7policy[const.ACTION])
-        self.assertEqual(self.pool_id, l7policy[const.REDIRECT_POOL_ID])
-        self.assertIsNone(l7policy.pop(const.REDIRECT_URL, None))
-
-        # L7Policy update
-        new_name = data_utils.rand_name("lb_member_l7policy1-update")
-        new_description = data_utils.arbitrary_string(size=255,
-                                                      base_text='new')
-        redirect_url = 'http://localhost'
-        l7policy_update_kwargs = {
-            const.NAME: new_name,
-            const.DESCRIPTION: new_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 2,
-            const.ACTION: const.REDIRECT_TO_URL,
-            const.REDIRECT_URL: redirect_url,
-        }
-        l7policy = self.mem_l7policy_client.update_l7policy(
-            l7policy[const.ID], **l7policy_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7policy = waiters.wait_for_status(
-            self.mem_l7policy_client.show_l7policy,
-            l7policy[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(new_name, l7policy[const.NAME])
-        self.assertEqual(new_description, l7policy[const.DESCRIPTION])
-        self.assertTrue(l7policy[const.ADMIN_STATE_UP])
-        # Operating status for a l7policy will be ONLINE if it is enabled:
-        self.assertEqual(const.ONLINE, l7policy[const.OPERATING_STATUS])
-        self.assertEqual(self.listener_id, l7policy[const.LISTENER_ID])
-        # Position will have recalculated to 1
-        self.assertEqual(1, l7policy[const.POSITION])
-        self.assertEqual(const.REDIRECT_TO_URL, l7policy[const.ACTION])
-        self.assertEqual(redirect_url, l7policy[const.REDIRECT_URL])
-        self.assertIsNone(l7policy.pop(const.REDIRECT_POOL_ID, None))
-
-        # L7Policy delete
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-        self.mem_l7policy_client.delete_l7policy(l7policy[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_l7policy_client.show_l7policy, l7policy[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_l7rule.py b/octavia_tempest_plugin/tests/scenario/v2/test_l7rule.py
deleted file mode 100644
index 3e14a74..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_l7rule.py
+++ /dev/null
@@ -1,195 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class L7RuleScenarioTest(test_base.LoadBalancerBaseTest):
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(L7RuleScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_l7rule")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_l7rule")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        l7policy_name = data_utils.rand_name("lb_member_l7policy1_l7rule")
-        l7policy_kwargs = {
-            const.NAME: l7policy_name,
-            const.LISTENER_ID: cls.listener_id,
-            const.ACTION: const.REJECT,
-        }
-        l7policy = cls.mem_l7policy_client.create_l7policy(**l7policy_kwargs)
-        cls.l7policy_id = l7policy[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_l7policy_client.cleanup_l7policy,
-            cls.l7policy_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('a1c268b9-5304-48c7-9a34-0ef0e8e9307e')
-    def test_l7rule_CRUD(self):
-        """Tests l7rule create, read, update, delete
-
-        * Create a fully populated l7rule.
-        * Show l7rule details.
-        * Update the l7rule.
-        * Delete the l7rule.
-        """
-
-        # L7Rule create
-        l7rule_kwargs = {
-            const.ADMIN_STATE_UP: False,
-            const.L7POLICY_ID: self.l7policy_id,
-            const.TYPE: const.HEADER,
-            const.VALUE: 'myvalue-create',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.KEY: 'mykey-create',
-            const.INVERT: False,
-        }
-
-        l7rule = self.mem_l7rule_client.create_l7rule(**l7rule_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule[const.ID], l7policy_id=self.l7policy_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7rule = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule,
-            l7rule[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=self.l7policy_id)
-
-        parser.parse(l7rule[const.CREATED_AT])
-        parser.parse(l7rule[const.UPDATED_AT])
-        UUID(l7rule[const.ID])
-        # Operating status will be OFFLINE while admin_state_up = False
-        self.assertEqual(const.OFFLINE, l7rule[const.OPERATING_STATUS])
-
-        equal_items = [const.ADMIN_STATE_UP, const.TYPE, const.VALUE,
-                       const.COMPARE_TYPE, const.KEY, const.INVERT]
-
-        for item in equal_items:
-            self.assertEqual(l7rule_kwargs[item], l7rule[item])
-
-        # L7Rule update
-        l7rule_update_kwargs = {
-            const.L7POLICY_ID: self.l7policy_id,
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.COOKIE,
-            const.VALUE: 'myvalue-UPDATED',
-            const.COMPARE_TYPE: const.CONTAINS,
-            const.KEY: 'mykey-UPDATED',
-            const.INVERT: True,
-        }
-        l7rule = self.mem_l7rule_client.update_l7rule(
-            l7rule[const.ID], **l7rule_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        l7rule = waiters.wait_for_status(
-            self.mem_l7rule_client.show_l7rule,
-            l7rule[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            l7policy_id=self.l7policy_id)
-
-        # Operating status for a l7rule will be ONLINE if it is enabled:
-        self.assertEqual(const.ONLINE, l7rule[const.OPERATING_STATUS])
-
-        # Test changed items (which is all of them, for l7rules)
-        equal_items = [const.ADMIN_STATE_UP, const.TYPE, const.VALUE,
-                       const.COMPARE_TYPE, const.KEY, const.INVERT]
-        for item in equal_items:
-            self.assertEqual(l7rule_update_kwargs[item], l7rule[item])
-
-        # L7Rule delete
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-        self.mem_l7rule_client.delete_l7rule(l7rule[const.ID],
-                                             l7policy_id=self.l7policy_id)
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_l7rule_client.show_l7rule, l7rule[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout,
-            l7policy_id=self.l7policy_id)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_listener.py b/octavia_tempest_plugin/tests/scenario/v2/test_listener.py
deleted file mode 100644
index 685c200..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_listener.py
+++ /dev/null
@@ -1,262 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from oslo_utils import strutils
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class ListenerScenarioTest(test_base.LoadBalancerBaseTest):
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(ListenerScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_listener")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        pool1_name = data_utils.rand_name("lb_member_pool1_listener")
-        pool1_kwargs = {
-            const.NAME: pool1_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        pool1 = cls.mem_pool_client.create_pool(**pool1_kwargs)
-        cls.pool1_id = pool1[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool1_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool2_name = data_utils.rand_name("lb_member_pool2_listener")
-        pool2_kwargs = {
-            const.NAME: pool2_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        pool2 = cls.mem_pool_client.create_pool(**pool2_kwargs)
-        cls.pool2_id = pool2[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool2_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('4a874014-b7d1-49a4-ac9a-2400b3434700')
-    def test_listener_CRUD(self):
-        """Tests listener create, read, update, delete
-
-        * Create a fully populated listener.
-        * Show listener details.
-        * Update the listener.
-        * Delete the listener.
-        """
-
-        # Listener create
-        listener_name = data_utils.rand_name("lb_member_listener1-CRUD")
-        listener_description = data_utils.arbitrary_string(size=255)
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.DESCRIPTION: listener_description,
-            const.ADMIN_STATE_UP: False,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: 80,
-            const.LOADBALANCER_ID: self.lb_id,
-            const.CONNECTION_LIMIT: 200,
-            const.INSERT_HEADERS: {
-                const.X_FORWARDED_FOR: "true",
-                const.X_FORWARDED_PORT: "true"
-            },
-            const.DEFAULT_POOL_ID: self.pool1_id,
-            # TODO(rm_work): need to finish the rest of this stuff
-            # const.DEFAULT_TLS_CONTAINER_REF: '',
-            # const.SNI_CONTAINER_REFS: [],
-        }
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            listener_kwargs.update({
-                const.TIMEOUT_CLIENT_DATA: 1000,
-                const.TIMEOUT_MEMBER_CONNECT: 1000,
-                const.TIMEOUT_MEMBER_DATA: 1000,
-                const.TIMEOUT_TCP_INSPECT: 50,
-            })
-
-        listener = self.mem_listener_client.create_listener(**listener_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_listener_client.cleanup_listener,
-            listener[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        listener = waiters.wait_for_status(
-            self.mem_listener_client.show_listener,
-            listener[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(listener_name, listener[const.NAME])
-        self.assertEqual(listener_description, listener[const.DESCRIPTION])
-        self.assertFalse(listener[const.ADMIN_STATE_UP])
-        parser.parse(listener[const.CREATED_AT])
-        parser.parse(listener[const.UPDATED_AT])
-        UUID(listener[const.ID])
-        # Operating status will be OFFLINE while admin_state_up = False
-        self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, listener[const.PROTOCOL])
-        self.assertEqual(80, listener[const.PROTOCOL_PORT])
-        self.assertEqual(200, listener[const.CONNECTION_LIMIT])
-        insert_headers = listener[const.INSERT_HEADERS]
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR]))
-        self.assertTrue(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT]))
-        self.assertEqual(self.pool1_id, listener[const.DEFAULT_POOL_ID])
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            self.assertEqual(1000, listener[const.TIMEOUT_CLIENT_DATA])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_CONNECT])
-            self.assertEqual(1000, listener[const.TIMEOUT_MEMBER_DATA])
-            self.assertEqual(50, listener[const.TIMEOUT_TCP_INSPECT])
-
-        # Listener update
-        new_name = data_utils.rand_name("lb_member_listener1-update")
-        new_description = data_utils.arbitrary_string(size=255,
-                                                      base_text='new')
-        listener_update_kwargs = {
-            const.NAME: new_name,
-            const.DESCRIPTION: new_description,
-            const.ADMIN_STATE_UP: True,
-            const.CONNECTION_LIMIT: 400,
-            const.INSERT_HEADERS: {
-                const.X_FORWARDED_FOR: "false",
-                const.X_FORWARDED_PORT: "false"
-            },
-            const.DEFAULT_POOL_ID: self.pool2_id,
-            # TODO(rm_work): need to finish the rest of this stuff
-            # const.DEFAULT_TLS_CONTAINER_REF: '',
-            # const.SNI_CONTAINER_REFS: [],
-        }
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            listener_update_kwargs.update({
-                const.TIMEOUT_CLIENT_DATA: 2000,
-                const.TIMEOUT_MEMBER_CONNECT: 2000,
-                const.TIMEOUT_MEMBER_DATA: 2000,
-                const.TIMEOUT_TCP_INSPECT: 100,
-            })
-
-        listener = self.mem_listener_client.update_listener(
-            listener[const.ID], **listener_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        listener = waiters.wait_for_status(
-            self.mem_listener_client.show_listener,
-            listener[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        if not CONF.load_balancer.test_with_noop:
-            listener = waiters.wait_for_status(
-                self.mem_listener_client.show_listener,
-                listener[const.ID], const.OPERATING_STATUS,
-                const.ONLINE,
-                CONF.load_balancer.build_interval,
-                CONF.load_balancer.build_timeout)
-
-        self.assertEqual(new_name, listener[const.NAME])
-        self.assertEqual(new_description, listener[const.DESCRIPTION])
-        self.assertTrue(listener[const.ADMIN_STATE_UP])
-        # Operating status is a measured status, so no-op will not go online
-        if CONF.load_balancer.test_with_noop:
-            self.assertEqual(const.OFFLINE, listener[const.OPERATING_STATUS])
-        else:
-            self.assertEqual(const.ONLINE, listener[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, listener[const.PROTOCOL])
-        self.assertEqual(80, listener[const.PROTOCOL_PORT])
-        self.assertEqual(400, listener[const.CONNECTION_LIMIT])
-        insert_headers = listener[const.INSERT_HEADERS]
-        self.assertFalse(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_FOR]))
-        self.assertFalse(
-            strutils.bool_from_string(insert_headers[const.X_FORWARDED_PORT]))
-        self.assertEqual(self.pool2_id, listener[const.DEFAULT_POOL_ID])
-        if self.mem_listener_client.is_version_supported(
-                self.api_version, '2.1'):
-            self.assertEqual(2000, listener[const.TIMEOUT_CLIENT_DATA])
-            self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_CONNECT])
-            self.assertEqual(2000, listener[const.TIMEOUT_MEMBER_DATA])
-            self.assertEqual(100, listener[const.TIMEOUT_TCP_INSPECT])
-
-        # Listener delete
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-        self.mem_listener_client.delete_listener(listener[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_listener_client.show_listener, listener[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_member.py b/octavia_tempest_plugin/tests/scenario/v2/test_member.py
deleted file mode 100644
index b30d651..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_member.py
+++ /dev/null
@@ -1,241 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class MemberScenarioTest(test_base.LoadBalancerBaseTest):
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(MemberScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_member")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_member")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_member")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LISTENER_ID: cls.listener_id,
-        }
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('15c8c3e3-569c-4029-95df-a9f72049e267')
-    def test_member_CRUD(self):
-        """Tests member create, read, update, delete
-
-        * Create a fully populated member.
-        * Show member details.
-        * Update the member.
-        * Delete the member.
-        """
-        # Member create
-        member_name = data_utils.rand_name("lb_member_member1-CRUD")
-        member_kwargs = {
-            const.NAME: member_name,
-            const.ADMIN_STATE_UP: True,
-            const.POOL_ID: self.pool_id,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 80,
-            const.WEIGHT: 50,
-            const.MONITOR_ADDRESS: '192.0.2.2',
-            const.MONITOR_PORT: 8080,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member_kwargs.update({
-                const.BACKUP: False,
-            })
-
-        if self.lb_member_vip_subnet:
-            member_kwargs[const.SUBNET_ID] = self.lb_member_vip_subnet[
-                const.ID]
-
-        member = self.mem_member_client.create_member(**member_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_member_client.cleanup_member,
-            member[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        parser.parse(member[const.CREATED_AT])
-        parser.parse(member[const.UPDATED_AT])
-        UUID(member[const.ID])
-
-        # Members may be in a transitional state initially
-        # like DOWN or MAINT, give it some time to stablize on
-        # NO_MONITOR. This is LIVE status.
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.OPERATING_STATUS,
-            const.NO_MONITOR,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout,
-            pool_id=self.pool_id)
-
-        equal_items = [const.NAME, const.ADMIN_STATE_UP, const.ADDRESS,
-                       const.PROTOCOL_PORT, const.WEIGHT,
-                       const.MONITOR_ADDRESS, const.MONITOR_PORT]
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            equal_items.append(const.BACKUP)
-
-        if const.SUBNET_ID in member_kwargs:
-            equal_items.append(const.SUBNET_ID)
-        else:
-            self.assertIsNone(member.get(const.SUBNET_ID))
-
-        for item in equal_items:
-            self.assertEqual(member_kwargs[item], member[item])
-
-        # Member update
-        new_name = data_utils.rand_name("lb_member_member1-update")
-        member_update_kwargs = {
-            const.POOL_ID: member_kwargs[const.POOL_ID],
-            const.NAME: new_name,
-            const.ADMIN_STATE_UP: not member[const.ADMIN_STATE_UP],
-            const.WEIGHT: member[const.WEIGHT] + 1,
-            const.MONITOR_ADDRESS: '192.0.2.3',
-            const.MONITOR_PORT: member[const.MONITOR_PORT] + 1,
-        }
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            member_update_kwargs.update({
-                const.BACKUP: not member[const.BACKUP],
-            })
-
-        member = self.mem_member_client.update_member(
-            member[const.ID], **member_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        member = waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        # Test changed items
-        equal_items = [const.NAME, const.ADMIN_STATE_UP, const.WEIGHT,
-                       const.MONITOR_ADDRESS, const.MONITOR_PORT]
-        if self.mem_member_client.is_version_supported(
-                self.api_version, '2.1'):
-            equal_items.append(const.BACKUP)
-
-        for item in equal_items:
-            self.assertEqual(member_update_kwargs[item], member[item])
-
-        # Test unchanged items
-        equal_items = [const.ADDRESS, const.PROTOCOL_PORT]
-        if const.SUBNET_ID in member_kwargs:
-            equal_items.append(const.SUBNET_ID)
-        else:
-            self.assertIsNone(member.get(const.SUBNET_ID))
-
-        for item in equal_items:
-            self.assertEqual(member_kwargs[item], member[item])
-
-        # Member delete
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-        self.mem_member_client.delete_member(member[const.ID],
-                                             pool_id=self.pool_id)
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_member_client.show_member, member[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout,
-            pool_id=self.pool_id)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_pool.py b/octavia_tempest_plugin/tests/scenario/v2/test_pool.py
deleted file mode 100644
index 1ddc8b2..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_pool.py
+++ /dev/null
@@ -1,204 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from uuid import UUID
-
-from dateutil import parser
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-
-
-class PoolScenarioTest(test_base.LoadBalancerBaseTest):
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(PoolScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_pool")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        cls._setup_lb_network_kwargs(lb_kwargs)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_pool")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @decorators.idempotent_id('dfa120bf-81b9-4f22-bb5e-7df660c18173')
-    def test_pool_standalone_CRUD(self):
-        self._test_pool_CRUD(has_listener=False)
-
-    @decorators.idempotent_id('087da8ab-79c7-48ba-871c-5769185cea3e')
-    def test_pool_with_listener_CRUD(self):
-        self._test_pool_CRUD(has_listener=True)
-
-    def _test_pool_CRUD(self, has_listener):
-        """Tests pool create, read, update, delete
-
-        * Create a fully populated pool.
-        * Show pool details.
-        * Update the pool.
-        * Delete the pool.
-        """
-        # Pool create
-        pool_name = data_utils.rand_name("lb_member_pool1-CRUD")
-        pool_description = data_utils.arbitrary_string(size=255)
-        pool_sp_cookie_name = 'my_cookie'
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.DESCRIPTION: pool_description,
-            const.ADMIN_STATE_UP: False,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_APP_COOKIE,
-                const.COOKIE_NAME: pool_sp_cookie_name,
-            },
-        }
-        if has_listener:
-            pool_kwargs[const.LISTENER_ID] = self.listener_id
-        else:
-            pool_kwargs[const.LOADBALANCER_ID] = self.lb_id
-
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        self.addClassResourceCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(pool_name, pool[const.NAME])
-        self.assertEqual(pool_description, pool[const.DESCRIPTION])
-        self.assertFalse(pool[const.ADMIN_STATE_UP])
-        parser.parse(pool[const.CREATED_AT])
-        parser.parse(pool[const.UPDATED_AT])
-        UUID(pool[const.ID])
-        self.assertEqual(const.OFFLINE, pool[const.OPERATING_STATUS])
-        self.assertEqual(const.HTTP, pool[const.PROTOCOL])
-        self.assertEqual(1, len(pool[const.LOADBALANCERS]))
-        self.assertEqual(self.lb_id, pool[const.LOADBALANCERS][0][const.ID])
-        if has_listener:
-            self.assertEqual(1, len(pool[const.LISTENERS]))
-            self.assertEqual(self.listener_id,
-                             pool[const.LISTENERS][0][const.ID])
-        else:
-            self.assertEmpty(pool[const.LISTENERS])
-        self.assertEqual(const.LB_ALGORITHM_ROUND_ROBIN,
-                         pool[const.LB_ALGORITHM])
-        self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE))
-        self.assertEqual(const.SESSION_PERSISTENCE_APP_COOKIE,
-                         pool[const.SESSION_PERSISTENCE][const.TYPE])
-        self.assertEqual(pool_sp_cookie_name,
-                         pool[const.SESSION_PERSISTENCE][const.COOKIE_NAME])
-
-        # Pool update
-        new_name = data_utils.rand_name("lb_member_pool1-update")
-        new_description = data_utils.arbitrary_string(size=255,
-                                                      base_text='new')
-        pool_update_kwargs = {
-            const.NAME: new_name,
-            const.DESCRIPTION: new_description,
-            const.ADMIN_STATE_UP: True,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_LEAST_CONNECTIONS,
-            const.SESSION_PERSISTENCE: {
-                const.TYPE: const.SESSION_PERSISTENCE_HTTP_COOKIE,
-            },
-        }
-        pool = self.mem_pool_client.update_pool(
-            pool[const.ID], **pool_update_kwargs)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        pool = waiters.wait_for_status(
-            self.mem_pool_client.show_pool,
-            pool[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        self.assertEqual(new_name, pool[const.NAME])
-        self.assertEqual(new_description, pool[const.DESCRIPTION])
-        self.assertTrue(pool[const.ADMIN_STATE_UP])
-        self.assertEqual(const.LB_ALGORITHM_LEAST_CONNECTIONS,
-                         pool[const.LB_ALGORITHM])
-        self.assertIsNotNone(pool.get(const.SESSION_PERSISTENCE))
-        self.assertEqual(const.SESSION_PERSISTENCE_HTTP_COOKIE,
-                         pool[const.SESSION_PERSISTENCE][const.TYPE])
-        self.assertIsNone(
-            pool[const.SESSION_PERSISTENCE].get(const.COOKIE_NAME))
-
-        # Pool delete
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer,
-            self.lb_id, const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-        self.mem_pool_client.delete_pool(pool[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_pool_client.show_pool, pool[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
diff --git a/octavia_tempest_plugin/tests/scenario/v2/test_traffic_ops.py b/octavia_tempest_plugin/tests/scenario/v2/test_traffic_ops.py
deleted file mode 100644
index 627c261..0000000
--- a/octavia_tempest_plugin/tests/scenario/v2/test_traffic_ops.py
+++ /dev/null
@@ -1,622 +0,0 @@
-# Copyright 2018 GoDaddy
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-import testtools
-
-from oslo_log import log as logging
-from tempest import config
-from tempest.lib.common.utils import data_utils
-from tempest.lib import decorators
-
-from octavia_tempest_plugin.common import constants as const
-from octavia_tempest_plugin.tests import test_base
-from octavia_tempest_plugin.tests import waiters
-
-CONF = config.CONF
-LOG = logging.getLogger(__name__)
-
-
-@testtools.skipUnless(
-    CONF.validation.run_validation,
-    'Traffic tests will not work without run_validation enabled.')
-class TrafficOperationsScenarioTest(test_base.LoadBalancerBaseTestWithCompute):
-
-    @classmethod
-    def resource_setup(cls):
-        """Setup resources needed by the tests."""
-        super(TrafficOperationsScenarioTest, cls).resource_setup()
-
-        lb_name = data_utils.rand_name("lb_member_lb1_operations")
-        lb_kwargs = {const.PROVIDER: CONF.load_balancer.provider,
-                     const.NAME: lb_name}
-
-        # TODO(rm_work): Make this work with ipv6 and split this test for both
-        ip_version = 4
-        cls._setup_lb_network_kwargs(lb_kwargs, ip_version)
-
-        lb = cls.mem_lb_client.create_loadbalancer(**lb_kwargs)
-        cls.lb_id = lb[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_lb_client.cleanup_loadbalancer,
-            cls.lb_id)
-
-        if CONF.validation.connect_method == 'floating':
-            port_id = lb[const.VIP_PORT_ID]
-            result = cls.lb_mem_float_ip_client.create_floatingip(
-                floating_network_id=CONF.network.public_network_id,
-                port_id=port_id)
-            floating_ip = result['floatingip']
-            LOG.info('lb1_floating_ip: {}'.format(floating_ip))
-            cls.addClassResourceCleanup(
-                waiters.wait_for_not_found,
-                cls.lb_mem_float_ip_client.delete_floatingip,
-                cls.lb_mem_float_ip_client.show_floatingip,
-                floatingip_id=floating_ip['id'])
-            cls.lb_vip_address = floating_ip['floating_ip_address']
-        else:
-            cls.lb_vip_address = lb[const.VIP_ADDRESS]
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.lb_build_interval,
-                                CONF.load_balancer.lb_build_timeout)
-
-        listener_name = data_utils.rand_name("lb_member_listener1_operations")
-        listener_kwargs = {
-            const.NAME: listener_name,
-            const.PROTOCOL: const.HTTP,
-            const.PROTOCOL_PORT: '80',
-            const.LOADBALANCER_ID: cls.lb_id,
-        }
-        listener = cls.mem_listener_client.create_listener(**listener_kwargs)
-        cls.listener_id = listener[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_listener_client.cleanup_listener,
-            cls.listener_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        pool_name = data_utils.rand_name("lb_member_pool1_operations")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LISTENER_ID: cls.listener_id,
-        }
-        pool = cls.mem_pool_client.create_pool(**pool_kwargs)
-        cls.pool_id = pool[const.ID]
-        cls.addClassResourceCleanup(
-            cls.mem_pool_client.cleanup_pool,
-            cls.pool_id,
-            lb_client=cls.mem_lb_client, lb_id=cls.lb_id)
-
-        waiters.wait_for_status(cls.mem_lb_client.show_loadbalancer,
-                                cls.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-    @testtools.skipIf(CONF.load_balancer.test_with_noop,
-                      'Traffic tests will not work in noop mode.')
-    @decorators.idempotent_id('6751135d-e15a-4e22-89f4-bfcc3408d424')
-    def test_basic_traffic(self):
-        """Tests sending traffic through a loadbalancer
-
-        * Set up members on a loadbalancer.
-        * Test traffic to ensure it is balanced properly.
-        """
-        # Set up Member 1 for Webserver 1
-        member1_name = data_utils.rand_name("lb_member_member1-traffic")
-        member1_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member1_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: self.webserver1_ip,
-            const.PROTOCOL_PORT: 80,
-        }
-        if self.lb_member_1_subnet:
-            member1_kwargs[const.SUBNET_ID] = self.lb_member_1_subnet[const.ID]
-
-        member1 = self.mem_member_client.create_member(
-            **member1_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member1[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Set up Member 2 for Webserver 2
-        member2_name = data_utils.rand_name("lb_member_member2-traffic")
-        member2_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member2_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: self.webserver2_ip,
-            const.PROTOCOL_PORT: 80,
-        }
-        if self.lb_member_2_subnet:
-            member2_kwargs[const.SUBNET_ID] = self.lb_member_2_subnet[const.ID]
-
-        member2 = self.mem_member_client.create_member(
-            **member2_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member2[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Send some traffic
-        self.check_members_balanced(self.lb_vip_address)
-
-    @decorators.idempotent_id('a16f8eb4-a77c-4b0e-8b1b-91c237039713')
-    def test_healthmonitor_traffic(self):
-        """Tests traffic is correctly routed based on healthmonitor status
-
-        * Create three members:
-          * One should be working, and ONLINE with a healthmonitor (passing)
-          * One should be working, and ERROR with a healthmonitor (failing)
-          * One should be disabled, and OFFLINE with a healthmonitor
-        * Verify members are in their correct respective operating statuses.
-        * Verify that traffic is balanced evenly between the working members.
-        * Create a fully populated healthmonitor.
-        * Verify members are in their correct respective operating statuses.
-        * Verify that traffic is balanced *unevenly*.
-        * Delete the healthmonitor.
-        * Verify members are in their correct respective operating statuses.
-        * Verify that traffic is balanced evenly between the working members.
-        """
-        member1_name = data_utils.rand_name("lb_member_member1-hm-traffic")
-        member1_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member1_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: self.webserver1_ip,
-            const.PROTOCOL_PORT: 80,
-        }
-        if self.lb_member_1_subnet:
-            member1_kwargs[const.SUBNET_ID] = self.lb_member_1_subnet[const.ID]
-
-        member1 = self.mem_member_client.create_member(
-            **member1_kwargs)
-        member1_id = member1[const.ID]
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member1_id, pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Set up Member 2 for Webserver 2
-        member2_name = data_utils.rand_name("lb_member_member2-hm-traffic")
-        member2_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member2_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: self.webserver2_ip,
-            const.PROTOCOL_PORT: 80,
-            const.MONITOR_PORT: 9999,  # We want this to go offline with a HM
-        }
-        if self.lb_member_2_subnet:
-            member2_kwargs[const.SUBNET_ID] = self.lb_member_2_subnet[const.ID]
-
-        member2 = self.mem_member_client.create_member(
-            **member2_kwargs)
-        member2_id = member2[const.ID]
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member2_id, pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Set up Member 3 as a non-existent disabled node
-        member3_name = data_utils.rand_name("lb_member_member3-hm-traffic")
-        member3_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member3_name,
-            const.ADMIN_STATE_UP: False,
-            const.ADDRESS: '192.0.2.1',
-            const.PROTOCOL_PORT: 80,
-        }
-
-        member3 = self.mem_member_client.create_member(
-            **member3_kwargs)
-        member3_id = member3[const.ID]
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member3_id, pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Wait for members to adjust to the correct OPERATING_STATUS
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member1_id, const.OPERATING_STATUS,
-            const.NO_MONITOR,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member2_id, const.OPERATING_STATUS,
-            const.NO_MONITOR,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member3_id, const.OPERATING_STATUS,
-            const.OFFLINE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        # Send some traffic and verify it is balanced
-        self.check_members_balanced(self.lb_vip_address,
-                                    traffic_member_count=2)
-
-        # Create the healthmonitor
-        hm_name = data_utils.rand_name("lb_member_hm1-hm-traffic")
-        hm_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: hm_name,
-            const.TYPE: const.HEALTH_MONITOR_HTTP,
-            const.DELAY: 2,
-            const.TIMEOUT: 2,
-            const.MAX_RETRIES: 2,
-            const.MAX_RETRIES_DOWN: 2,
-            const.HTTP_METHOD: const.GET,
-            const.URL_PATH: '/',
-            const.EXPECTED_CODES: '200',
-            const.ADMIN_STATE_UP: True,
-        }
-
-        hm = self.mem_healthmonitor_client.create_healthmonitor(**hm_kwargs)
-        self.addCleanup(
-            self.mem_healthmonitor_client.cleanup_healthmonitor,
-            hm[const.ID], lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-        hm = waiters.wait_for_status(
-            self.mem_healthmonitor_client.show_healthmonitor,
-            hm[const.ID], const.PROVISIONING_STATUS,
-            const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Wait for members to adjust to the correct OPERATING_STATUS
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member1_id, const.OPERATING_STATUS,
-            const.ONLINE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member2_id, const.OPERATING_STATUS,
-            const.ERROR,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member3_id, const.OPERATING_STATUS,
-            const.OFFLINE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        # Send some traffic and verify it is *unbalanced*, as expected
-        self.check_members_balanced(self.lb_vip_address,
-                                    traffic_member_count=1)
-
-        # Delete the healthmonitor
-        self.mem_healthmonitor_client.delete_healthmonitor(hm[const.ID])
-
-        waiters.wait_for_deleted_status_or_not_found(
-            self.mem_healthmonitor_client.show_healthmonitor, hm[const.ID],
-            const.PROVISIONING_STATUS,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Wait for members to adjust to the correct OPERATING_STATUS
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member1_id, const.OPERATING_STATUS,
-            const.NO_MONITOR,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member2_id, const.OPERATING_STATUS,
-            const.NO_MONITOR,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-        waiters.wait_for_status(
-            self.mem_member_client.show_member,
-            member3_id, const.OPERATING_STATUS,
-            const.OFFLINE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout,
-            pool_id=self.pool_id)
-
-        # Send some traffic and verify it is balanced again
-        self.check_members_balanced(self.lb_vip_address)
-
-    @decorators.idempotent_id('3558186d-6dcd-4d9d-b7f7-adc190b66149')
-    def test_l7policies_and_l7rules(self):
-        """Tests sending traffic through a loadbalancer with l7rules
-
-        * Create an extra pool.
-        * Put one member on the default pool, and one on the second pool.
-        * Create a policy/rule to redirect to the second pool.
-        * Create a policy/rule to redirect to the identity URI.
-        * Create a policy/rule to reject connections.
-        * Test traffic to ensure it goes to the correct place.
-        """
-        # Create a second pool
-        pool_name = data_utils.rand_name("lb_member_pool2_l7redirect")
-        pool_kwargs = {
-            const.NAME: pool_name,
-            const.PROTOCOL: const.HTTP,
-            const.LB_ALGORITHM: const.LB_ALGORITHM_ROUND_ROBIN,
-            const.LOADBALANCER_ID: self.lb_id,
-        }
-        pool = self.mem_pool_client.create_pool(**pool_kwargs)
-        pool_id = pool[const.ID]
-        self.addCleanup(
-            self.mem_pool_client.cleanup_pool,
-            pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-
-        waiters.wait_for_status(self.mem_lb_client.show_loadbalancer,
-                                self.lb_id, const.PROVISIONING_STATUS,
-                                const.ACTIVE,
-                                CONF.load_balancer.build_interval,
-                                CONF.load_balancer.build_timeout)
-
-        # Set up Member 1 for Webserver 1 on the default pool
-        member1_name = data_utils.rand_name("lb_member_member1-l7redirect")
-        member1_kwargs = {
-            const.POOL_ID: self.pool_id,
-            const.NAME: member1_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: self.webserver1_ip,
-            const.PROTOCOL_PORT: 80,
-        }
-        if self.lb_member_1_subnet:
-            member1_kwargs[const.SUBNET_ID] = self.lb_member_1_subnet[const.ID]
-
-        member1 = self.mem_member_client.create_member(
-            **member1_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member1[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Set up Member 2 for Webserver 2 on the alternate pool
-        member2_name = data_utils.rand_name("lb_member_member2-l7redirect")
-        member2_kwargs = {
-            const.POOL_ID: pool_id,
-            const.NAME: member2_name,
-            const.ADMIN_STATE_UP: True,
-            const.ADDRESS: self.webserver2_ip,
-            const.PROTOCOL_PORT: 80,
-        }
-        if self.lb_member_2_subnet:
-            member2_kwargs[const.SUBNET_ID] = self.lb_member_2_subnet[const.ID]
-
-        member2 = self.mem_member_client.create_member(
-            **member2_kwargs)
-        self.addCleanup(
-            self.mem_member_client.cleanup_member,
-            member2[const.ID], pool_id=self.pool_id,
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.check_interval,
-            CONF.load_balancer.check_timeout)
-
-        # Create the l7policy to redirect to the alternate pool
-        l7policy1_name = data_utils.rand_name("lb_member_l7policy1-l7redirect")
-        l7policy1_description = data_utils.arbitrary_string(size=255)
-        l7policy1_kwargs = {
-            const.LISTENER_ID: self.listener_id,
-            const.NAME: l7policy1_name,
-            const.DESCRIPTION: l7policy1_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-            const.ACTION: const.REDIRECT_TO_POOL,
-            const.REDIRECT_POOL_ID: pool_id,
-        }
-        l7policy1 = self.mem_l7policy_client.create_l7policy(
-            **l7policy1_kwargs)
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy1[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Redirect slow queries to the alternate pool
-        l7rule1_kwargs = {
-            const.L7POLICY_ID: l7policy1[const.ID],
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.PATH,
-            const.VALUE: '/slow',
-            const.COMPARE_TYPE: const.STARTS_WITH,
-            const.INVERT: False,
-        }
-
-        l7rule1 = self.mem_l7rule_client.create_l7rule(**l7rule1_kwargs)
-        self.addCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule1[const.ID], l7policy_id=l7rule1_kwargs[const.L7POLICY_ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Create the l7policy to redirect to the identity URI
-        l7policy2_name = data_utils.rand_name("lb_member_l7policy2-l7redirect")
-        l7policy2_description = data_utils.arbitrary_string(size=255)
-        l7policy2_kwargs = {
-            const.LISTENER_ID: self.listener_id,
-            const.NAME: l7policy2_name,
-            const.DESCRIPTION: l7policy2_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-            const.ACTION: const.REDIRECT_TO_URL,
-            const.REDIRECT_URL: CONF.identity.uri_v3,
-        }
-        l7policy2 = self.mem_l7policy_client.create_l7policy(
-            **l7policy2_kwargs)
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy2[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Redirect queries for 'turtles' to identity
-        l7rule2_kwargs = {
-            const.L7POLICY_ID: l7policy2[const.ID],
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.PATH,
-            const.VALUE: '/turtles',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.INVERT: False,
-        }
-
-        l7rule2 = self.mem_l7rule_client.create_l7rule(**l7rule2_kwargs)
-        self.addCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule2[const.ID], l7policy_id=l7rule2_kwargs[const.L7POLICY_ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Create the l7policy to reject requests
-        l7policy3_name = data_utils.rand_name("lb_member_l7policy3-l7redirect")
-        l7policy3_description = data_utils.arbitrary_string(size=255)
-        l7policy3_kwargs = {
-            const.LISTENER_ID: self.listener_id,
-            const.NAME: l7policy3_name,
-            const.DESCRIPTION: l7policy3_description,
-            const.ADMIN_STATE_UP: True,
-            const.POSITION: 1,
-            const.ACTION: const.REJECT,
-        }
-        l7policy3 = self.mem_l7policy_client.create_l7policy(
-            **l7policy3_kwargs)
-        self.addCleanup(
-            self.mem_l7policy_client.cleanup_l7policy,
-            l7policy3[const.ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Reject requests that include the header data 'reject=true'
-        l7rule3_kwargs = {
-            const.L7POLICY_ID: l7policy3[const.ID],
-            const.ADMIN_STATE_UP: True,
-            const.TYPE: const.HEADER,
-            const.KEY: 'reject',
-            const.VALUE: 'true',
-            const.COMPARE_TYPE: const.EQUAL_TO,
-            const.INVERT: False,
-        }
-
-        l7rule3 = self.mem_l7rule_client.create_l7rule(**l7rule3_kwargs)
-        self.addCleanup(
-            self.mem_l7rule_client.cleanup_l7rule,
-            l7rule3[const.ID], l7policy_id=l7rule3_kwargs[const.L7POLICY_ID],
-            lb_client=self.mem_lb_client, lb_id=self.lb_id)
-        waiters.wait_for_status(
-            self.mem_lb_client.show_loadbalancer, self.lb_id,
-            const.PROVISIONING_STATUS, const.ACTIVE,
-            CONF.load_balancer.build_interval,
-            CONF.load_balancer.build_timeout)
-
-        # Assert that normal traffic goes to pool1->member1
-        url_for_member1 = 'http://{}/'.format(self.lb_vip_address)
-        self.assertConsistentResponse((200, self.webserver1_response),
-                                      url_for_member1)
-
-        # Assert that slow traffic goes to pool2->member2
-        url_for_member2 = 'http://{}/slow?delay=1s'.format(self.lb_vip_address)
-        self.assertConsistentResponse((200, self.webserver2_response),
-                                      url_for_member2)
-
-        # Assert that /turtles is redirected to identity
-        url_for_identity = 'http://{}/turtles'.format(self.lb_vip_address)
-        self.assertConsistentResponse((302, CONF.identity.uri_v3),
-                                      url_for_identity,
-                                      redirect=True)
-
-        # Assert that traffic with header 'reject=true' is rejected
-        self.assertConsistentResponse((403, None),
-                                      url_for_member1,
-                                      headers={'reject': 'true'})