octavia 12.0.0.0rc2__py3-none-any.whl → 13.0.0.0rc1__py3-none-any.whl

octavia/tests/unit/network/drivers/neutron/test_allowed_address_pairs.py

@@ -11,16 +11,17 @@
 #    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 copy
 from unittest import mock
 
-from neutronclient.common import exceptions as neutron_exceptions
 from novaclient.client import exceptions as nova_exceptions
+import openstack.exceptions as os_exceptions
+from openstack.network.v2.port import Port
+from openstack.network.v2.security_group import SecurityGroup
+from openstack.network.v2.subnet import Subnet
 from oslo_config import cfg
 from oslo_config import fixture as oslo_fixture
 from oslo_utils import uuidutils
 
-from octavia.common import clients
 from octavia.common import constants
 from octavia.common import data_models
 from octavia.common import exceptions
@@ -59,17 +60,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
 
     def setUp(self):
         super().setUp()
-        with mock.patch('octavia.common.clients.neutron_client.Client',
-                        autospec=True) as neutron_client:
+        with mock.patch('octavia.common.clients.openstack.connection'
+                        '.Connection', autospec=True) as os_connection:
             with mock.patch('stevedore.driver.DriverManager.driver',
                             autospec=True):
-                client = neutron_client(clients.NEUTRON_VERSION)
-                client.list_extensions.return_value = {
-                    'extensions': [
-                        {'alias': allowed_address_pairs.AAP_EXT_ALIAS},
-                        {'alias': neutron_base.SEC_GRP_EXT_ALIAS}
-                    ]
-                }
+                network_proxy = os_connection().network
+                network_proxy.find_extension = (
+                    lambda x: 'alias' if x in (
+                        allowed_address_pairs.AAP_EXT_ALIAS,
+                        neutron_base.SEC_GRP_EXT_ALIAS)
+                    else None)
                 self.k_session = mock.patch(
                     'keystoneauth1.session.Session').start()
                 self.driver = allowed_address_pairs.AllowedAddressPairsDriver()
@@ -108,18 +108,13 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb.vip.load_balancer = lb
         vip = lb.vip
         sec_grp_id = 'lb-sec-grp1'
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
-        delete_port = self.driver.neutron_client.delete_port
-        delete_sec_grp = self.driver.neutron_client.delete_security_group
-        list_security_groups = self.driver.neutron_client.list_security_groups
-        security_groups = {
-            'security_groups': [
-                {'id': sec_grp_id}
-            ]
-        }
-        list_security_groups.return_value = security_groups
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(
+            device_owner=allowed_address_pairs.OCTAVIA_OWNER)
+        delete_port = self.driver.network_proxy.delete_port
+        delete_sec_grp = self.driver.network_proxy.delete_security_group
+        list_security_groups = self.driver.network_proxy.find_security_group
+        list_security_groups.return_value = SecurityGroup(id=sec_grp_id)
         self.driver.deallocate_vip(vip)
         calls = [mock.call(vip.port_id)]
         for amp in lb.amphorae:
@@ -132,38 +127,27 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb.vip.load_balancer = lb
         vip = lb.vip
         sec_grp_id = 'lb-sec-grp1'
-        show_port = self.driver.neutron_client.show_port
-        port = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
+        show_port = self.driver.network_proxy.get_port
+        port = Port(device_owner=allowed_address_pairs.OCTAVIA_OWNER)
         show_port.side_effect = [port, Exception]
-        list_security_groups = self.driver.neutron_client.list_security_groups
-        security_groups = {
-            'security_groups': [
-                {'id': sec_grp_id}
-            ]
-        }
-        list_security_groups.return_value = security_groups
+        list_security_groups = self.driver.network_proxy.find_security_group
+        list_security_groups.return_value = SecurityGroup(id=sec_grp_id)
         self.driver.deallocate_vip(vip)
-        self.driver.neutron_client.update_port.assert_not_called()
+        self.driver.network_proxy.update_port.assert_not_called()
 
     def test_deallocate_vip_port_deleted(self):
         lb = dmh.generate_load_balancer_tree()
         lb.vip.load_balancer = lb
         vip = lb.vip
         sec_grp_id = 'lb-sec-grp1'
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
-        delete_port = self.driver.neutron_client.delete_port
-        delete_port.side_effect = neutron_exceptions.NotFound
-        delete_sec_grp = self.driver.neutron_client.delete_security_group
-        list_security_groups = self.driver.neutron_client.list_security_groups
-        security_groups = {
-            'security_groups': [
-                {'id': sec_grp_id}
-            ]
-        }
-        list_security_groups.return_value = security_groups
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(
+            device_owner=allowed_address_pairs.OCTAVIA_OWNER)
+        delete_port = self.driver.network_proxy.delete_port
+        delete_port.side_effect = os_exceptions.ResourceNotFound
+        delete_sec_grp = self.driver.network_proxy.delete_security_group
+        find_security_group = self.driver.network_proxy.find_security_group
+        find_security_group.return_value = SecurityGroup(id=sec_grp_id)
         self.driver.deallocate_vip(vip)
         calls = [mock.call(vip.port_id)]
         for amp in lb.amphorae:
@@ -175,16 +159,13 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb = dmh.generate_load_balancer_tree()
         lb.vip.load_balancer = lb
         vip = lb.vip
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
-        delete_port = self.driver.neutron_client.delete_port
-        delete_sec_grp = self.driver.neutron_client.delete_security_group
-        list_security_groups = self.driver.neutron_client.list_security_groups
-        security_groups = {
-            'security_groups': []
-        }
-        list_security_groups.return_value = security_groups
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(
+            device_owner=allowed_address_pairs.OCTAVIA_OWNER)
+        delete_port = self.driver.network_proxy.delete_port
+        delete_sec_grp = self.driver.network_proxy.delete_security_group
+        list_security_groups = self.driver.network_proxy.find_security_group
+        list_security_groups.return_value = None
         self.driver.deallocate_vip(vip)
         delete_port.assert_called_with(vip.port_id)
         delete_sec_grp.assert_not_called()
@@ -193,10 +174,10 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb = dmh.generate_load_balancer_tree()
         vip = data_models.Vip(port_id='1')
         vip.load_balancer = lb
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
-        delete_port = self.driver.neutron_client.delete_port
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(
+            device_owner=allowed_address_pairs.OCTAVIA_OWNER)
+        delete_port = self.driver.network_proxy.delete_port
         delete_port.side_effect = [None, None, TypeError]
         self.assertRaises(network_base.DeallocateVIPException,
                           self.driver.deallocate_vip, vip)
@@ -209,27 +190,22 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb = dmh.generate_load_balancer_tree()
         lb.vip.load_balancer = lb
         vip = lb.vip
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
-        delete_port = self.driver.neutron_client.delete_port
-        list_ports = self.driver.neutron_client.list_ports
-        list_security_groups = self.driver.neutron_client.list_security_groups
-        delete_sec_grp = self.driver.neutron_client.delete_security_group
-        security_groups = {
-            'security_groups': [
-                {'id': t_constants.MOCK_SECURITY_GROUP_ID}
-            ]
-        }
-        list_security_groups.return_value = security_groups
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(
+            device_owner=allowed_address_pairs.OCTAVIA_OWNER)
+        delete_port = self.driver.network_proxy.delete_port
+        list_ports = self.driver.network_proxy.ports
+        find_security_group = self.driver.network_proxy.find_security_group
+        delete_sec_grp = self.driver.network_proxy.delete_security_group
+        security_group = SecurityGroup(id=t_constants.MOCK_SECURITY_GROUP_ID)
+        find_security_group.return_value = security_group
         delete_grp_results = [
             network_base.DeallocateVIPException
             for _ in range(max_retries + 1)]  # Total tries = max_retries + 1
         delete_grp_results.append(None)
         delete_sec_grp.side_effect = delete_grp_results
-        list_ports.side_effect = [{
-            "ports": [t_constants.MOCK_NEUTRON_PORT['port'],
-                      t_constants.MOCK_NEUTRON_PORT2['port']]}]
+        list_ports.return_value = iter([t_constants.MOCK_NEUTRON_PORT,
+                                        t_constants.MOCK_NEUTRON_PORT2])
         self.driver.deallocate_vip(vip)
         # First we expect the amp's ports to be deleted
         dp_calls = [mock.call(amp.vrrp_port_id) for amp in lb.amphorae]
@@ -248,19 +224,19 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb = dmh.generate_load_balancer_tree()
         vip = data_models.Vip(port_id='1')
         vip.load_balancer = lb
-        show_port = self.driver.neutron_client.show_port
-        show_port.side_effect = neutron_exceptions.PortNotFoundClient
+        show_port = self.driver.network_proxy.get_port
+        show_port.side_effect = os_exceptions.ResourceNotFound
         self.driver.deallocate_vip(vip)
 
     def test_deallocate_vip_when_port_not_found_for_update(self):
         lb = dmh.generate_load_balancer_tree()
         vip = data_models.Vip(port_id='1')
         vip.load_balancer = lb
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
-            'device_owner': allowed_address_pairs.OCTAVIA_OWNER}}
-        update_port = self.driver.neutron_client.update_port
-        update_port.side_effect = neutron_exceptions.PortNotFoundClient
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(
+            device_owner=allowed_address_pairs.OCTAVIA_OWNER)
+        update_port = self.driver.network_proxy.update_port
+        update_port.side_effect = os_exceptions.ResourceNotFound
         self.driver.deallocate_vip(vip)
 
     def test_deallocate_vip_when_port_not_owned_by_octavia(self):
@@ -268,23 +244,19 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lb.vip.load_balancer = lb
         vip = lb.vip
         sec_grp_id = 'lb-sec-grp1'
-        show_port = self.driver.neutron_client.show_port
-        show_port.return_value = {'port': {
+        show_port = self.driver.network_proxy.get_port
+        show_port.return_value = Port(**{
             'id': vip.port_id,
             'device_owner': 'neutron:LOADBALANCERV2',
-            'security_groups': [sec_grp_id]}}
-        update_port = self.driver.neutron_client.update_port
-        delete_sec_grp = self.driver.neutron_client.delete_security_group
-        list_security_groups = self.driver.neutron_client.list_security_groups
-        security_groups = {
-            'security_groups': [
-                {'id': sec_grp_id}
-            ]
-        }
-        list_security_groups.return_value = security_groups
+            'security_groups': [sec_grp_id]})
+        update_port = self.driver.network_proxy.update_port
+        delete_sec_grp = self.driver.network_proxy.delete_security_group
+        list_security_groups = self.driver.network_proxy.find_security_group
+        list_security_groups.return_value = SecurityGroup(id=sec_grp_id)
         self.driver.deallocate_vip(vip)
-        expected_port_update = {'port': {'security_groups': []}}
-        update_port.assert_called_once_with(vip.port_id, expected_port_update)
+        expected_port_update = {'security_group_ids': []}
+        update_port.assert_called_once_with(vip.port_id,
+                                            **expected_port_update)
         delete_sec_grp.assert_called_once_with(sec_grp_id)
 
     def test_deallocate_vip_when_vip_port_not_found(self):
@@ -295,8 +267,8 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         session_mock = mock.MagicMock()
         session_mock.get_project_id.return_value = admin_project_id
         self.k_session.return_value = session_mock
-        show_port = self.driver.neutron_client.show_port
-        show_port.side_effect = neutron_exceptions.PortNotFoundClient
+        show_port = self.driver.network_proxy.get_port
+        show_port.side_effect = os_exceptions.ResourceNotFound
         self.driver.deallocate_vip(vip)
 
     def test_plug_aap_errors_when_nova_cant_find_network_to_attach(self):
@@ -317,8 +289,8 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         network_attach = self.driver.compute.attach_network_or_port
         network_attach.return_value = t_constants.MOCK_NOVA_INTERFACE
 
-        update_port = self.driver.neutron_client.update_port
-        update_port.side_effect = neutron_exceptions.PortNotFoundClient
+        update_port = self.driver.network_proxy.update_port
+        update_port.side_effect = os_exceptions.ResourceNotFound
         self.assertRaises(network_base.PortNotFound,
                           self.driver.plug_aap_port, lb, lb.vip,
                           lb.amphorae[0], subnet)
@@ -408,40 +380,40 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         subnet = network_models.Subnet(id=t_constants.MOCK_VIP_SUBNET_ID,
                                        network_id=t_constants.MOCK_VIP_NET_ID)
 
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_MANAGEMENT_PORT1['port']
-        port2 = t_constants.MOCK_MANAGEMENT_PORT2['port']
-        list_ports.side_effect = [{'ports': [port1]}, {'ports': [port2]}]
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_MANAGEMENT_PORT1
+        port2 = t_constants.MOCK_MANAGEMENT_PORT2
+        list_ports.return_value = iter([port1, port2])
         network_attach = self.driver.compute.attach_network_or_port
         network_attach.side_effect = [t_constants.MOCK_VRRP_INTERFACE1]
-        update_port = self.driver.neutron_client.update_port
-        expected_aap = {'port': {'allowed_address_pairs':
-                                 [{'ip_address': lb.vip.ip_address}]}}
+        update_port = self.driver.network_proxy.update_port
+        expected_aap = {
+            'allowed_address_pairs': [{'ip_address': lb.vip.ip_address}]}
         amp = self.driver.plug_aap_port(lb, lb.vip, lb.amphorae[0], subnet)
-        update_port.assert_any_call(amp.vrrp_port_id, expected_aap)
+        update_port.assert_any_call(amp.vrrp_port_id, **expected_aap)
         self.assertIn(amp.vrrp_ip, [t_constants.MOCK_VRRP_IP1,
                                     t_constants.MOCK_VRRP_IP2])
         self.assertEqual(lb.vip.ip_address, amp.ha_ip)
 
     @mock.patch('octavia.network.drivers.neutron.utils.'
-                'convert_port_dict_to_model')
+                'convert_port_to_model')
     def test_plug_aap_port_create_fails(self, mock_convert):
         lb = dmh.generate_load_balancer_tree()
 
         subnet = network_models.Subnet(id=t_constants.MOCK_VIP_SUBNET_ID,
                                        network_id=t_constants.MOCK_VIP_NET_ID)
 
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_MANAGEMENT_PORT1['port']
-        port2 = t_constants.MOCK_MANAGEMENT_PORT2['port']
-        list_ports.side_effect = [{'ports': [port1]}, {'ports': [port2]}]
-        port_create = self.driver.neutron_client.create_port
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_MANAGEMENT_PORT1
+        port2 = t_constants.MOCK_MANAGEMENT_PORT2
+        list_ports.return_value = iter([port1, port2])
+        port_create = self.driver.network_proxy.create_port
         port_create.side_effect = [Exception('Create failure')]
         self.assertRaises(network_base.PlugVIPException,
                           self.driver.plug_aap_port,
                           lb, lb.vip, lb.amphorae[0], subnet)
         mock_convert.assert_not_called()
-        self.driver.neutron_client.delete_port.assert_not_called()
+        self.driver.network_proxy.delete_port.assert_not_called()
 
     def test_plug_aap_port_attach_fails(self):
         lb = dmh.generate_load_balancer_tree()
@@ -449,16 +421,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         subnet = network_models.Subnet(id=t_constants.MOCK_VIP_SUBNET_ID,
                                        network_id=t_constants.MOCK_VIP_NET_ID)
 
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_MANAGEMENT_PORT1['port']
-        port2 = t_constants.MOCK_MANAGEMENT_PORT2['port']
-        list_ports.side_effect = [{'ports': [port1]}, {'ports': [port2]}]
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_MANAGEMENT_PORT1
+        port2 = t_constants.MOCK_MANAGEMENT_PORT2
+        list_ports.return_value = iter([port1, port2])
         network_attach = self.driver.compute.attach_network_or_port
         network_attach.side_effect = [Exception('Attach failure')]
         self.assertRaises(network_base.PlugVIPException,
                           self.driver.plug_aap_port,
                           lb, lb.vip, lb.amphorae[0], subnet)
-        self.driver.neutron_client.delete_port.assert_called_once()
+        self.driver.network_proxy.delete_port.assert_called_once()
 
     def test_plug_aap_port_with_add_vips(self):
         additional_vips = [
@@ -470,21 +442,20 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         subnet = network_models.Subnet(id=t_constants.MOCK_VIP_SUBNET_ID,
                                        network_id=t_constants.MOCK_VIP_NET_ID)
 
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_MANAGEMENT_PORT1['port']
-        port2 = t_constants.MOCK_MANAGEMENT_PORT2['port']
-        list_ports.side_effect = [{'ports': [port1]}, {'ports': [port2]}]
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_MANAGEMENT_PORT1
+        port2 = t_constants.MOCK_MANAGEMENT_PORT2
+        list_ports.return_value = iter([port1, port2])
         network_attach = self.driver.compute.attach_network_or_port
         network_attach.side_effect = [t_constants.MOCK_VRRP_INTERFACE1]
-        update_port = self.driver.neutron_client.update_port
+        update_port = self.driver.network_proxy.update_port
         amp = self.driver.plug_aap_port(lb, lb.vip, lb.amphorae[0], subnet)
         expected_aap = {
-            'port': {
-                'allowed_address_pairs':
-                    [{'ip_address': lb.vip.ip_address},
-                     {'ip_address': lb.additional_vips[0].ip_address}]}}
+            'allowed_address_pairs':
+                [{'ip_address': lb.vip.ip_address},
+                 {'ip_address': lb.additional_vips[0].ip_address}]}
 
-        update_port.assert_any_call(amp.vrrp_port_id, expected_aap)
+        update_port.assert_any_call(amp.vrrp_port_id, **expected_aap)
         self.assertIn(amp.vrrp_ip, [t_constants.MOCK_VRRP_IP1,
                                     t_constants.MOCK_VRRP_IP2])
         self.assertEqual(lb.vip.ip_address, amp.ha_ip)
@@ -505,14 +476,14 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         subnet = network_models.Subnet(
             id=t_constants.MOCK_MANAGEMENT_SUBNET_ID,
             network_id=t_constants.MOCK_MANAGEMENT_NET_ID)
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_MANAGEMENT_PORT1['port']
-        port2 = t_constants.MOCK_MANAGEMENT_PORT2['port']
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_MANAGEMENT_PORT1
+        port2 = t_constants.MOCK_MANAGEMENT_PORT2
         self._set_safely(t_constants.MOCK_MANAGEMENT_FIXED_IPS1[0],
                          'ip_address', lb.amphorae[0].lb_network_ip)
         self._set_safely(t_constants.MOCK_MANAGEMENT_FIXED_IPS2[0],
                          'ip_address', lb.amphorae[1].lb_network_ip)
-        list_ports.side_effect = [{'ports': [port1]}, {'ports': [port2]}]
+        list_ports.side_effect = [iter([port1]), iter([port2])]
         network_attach = self.driver.compute.attach_network_or_port
         self._set_safely(t_constants.MOCK_VRRP_INTERFACE1,
                          'net_id', t_constants.MOCK_MANAGEMENT_NET_ID)
@@ -523,11 +494,11 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         self._set_safely(t_constants.MOCK_VRRP_FIXED_IPS2[0],
                          'subnet_id', t_constants.MOCK_MANAGEMENT_SUBNET_ID)
         network_attach.side_effect = [t_constants.MOCK_VRRP_INTERFACE1]
-        update_port = self.driver.neutron_client.update_port
-        expected_aap = {'port': {'allowed_address_pairs':
-                                 [{'ip_address': lb.vip.ip_address}]}}
+        update_port = self.driver.network_proxy.update_port
+        expected_aap = {
+            'allowed_address_pairs': [{'ip_address': lb.vip.ip_address}]}
         amp = self.driver.plug_aap_port(lb, lb.vip, lb.amphorae[0], subnet)
-        update_port.assert_any_call(amp.vrrp_port_id, expected_aap)
+        update_port.assert_any_call(amp.vrrp_port_id, **expected_aap)
         self.assertIn(amp.vrrp_ip, [t_constants.MOCK_VRRP_IP1,
                                     t_constants.MOCK_VRRP_IP2])
         self.assertEqual(lb.vip.ip_address, amp.ha_ip)
@@ -557,7 +528,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         self.assertFalse(result)
 
     def test_allocate_vip_when_port_already_provided(self):
-        show_port = self.driver.neutron_client.show_port
+        show_port = self.driver.network_proxy.get_port
         show_port.return_value = t_constants.MOCK_NEUTRON_PORT
         fake_lb_vip = data_models.Vip(
             port_id=t_constants.MOCK_PORT_ID,
@@ -580,15 +551,15 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         bad_existing_port.port_id = uuidutils.generate_uuid()
         bad_existing_port.network_id = uuidutils.generate_uuid()
         bad_existing_port.subnet_id = uuidutils.generate_uuid()
-        show_port = self.driver.neutron_client.show_port
+        show_port = self.driver.network_proxy.get_port
         show_port.return_value = bad_existing_port
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
+        show_subnet = self.driver.network_proxy.get_subnet
         show_subnet.return_value = {'subnet': {
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
@@ -601,19 +572,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                            project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'project_id': 'test-project',
-                'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID}]
-            }
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'project_id': 'test-project',
+            'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID}]
         }
-        self.driver.neutron_client.delete_port.assert_called_once_with(
+        self.driver.network_proxy.delete_port.assert_called_once_with(
             t_constants.MOCK_PORT_ID)
-        create_port.assert_called_once_with(exp_create_port_call)
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
         self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
@@ -627,13 +596,13 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                 '_check_extension_enabled', return_value=True)
     def test_allocate_vip_when_port_not_found(self, mock_check_ext,
                                               mock_get_port):
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
+        show_subnet = self.driver.network_proxy.get_subnet
         show_subnet.return_value = {'subnet': {
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
@@ -645,17 +614,15 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                            project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'project_id': 'test-project',
-                'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID}]
-            }
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'project_id': 'test-project',
+            'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID}]
         }
-        create_port.assert_called_once_with(exp_create_port_call)
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
         self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
@@ -681,7 +648,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         fake_lb_vip = data_models.Vip(
             subnet_id=t_constants.MOCK_SUBNET_ID)
         fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip)
-        create_port = self.driver.neutron_client.create_port
+        create_port = self.driver.network_proxy.create_port
         create_port.side_effect = Exception
         self.assertRaises(network_base.AllocateVIPException,
                           self.driver.allocate_vip, fake_lb)
@@ -689,17 +656,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch('octavia.network.drivers.neutron.base.BaseNeutronDriver.'
                 '_check_extension_enabled', return_value=True)
     def test_allocate_vip_when_no_port_provided(self, mock_check_ext):
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
-        show_subnet.return_value = {'subnet': {
+        show_subnet = self.driver.network_proxy.get_subnet
+        show_subnet.return_value = {
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
-        }}
+        }
         fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID,
                                       network_id=t_constants.MOCK_NETWORK_ID,
                                       ip_address=t_constants.MOCK_IP_ADDRESS)
@@ -707,18 +674,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                            project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'project_id': 'test-project',
-                'fixed_ips': [{'ip_address': t_constants.MOCK_IP_ADDRESS,
-                               'subnet_id': t_constants.MOCK_SUBNET_ID}]
-            }
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'project_id': 'test-project',
+            'fixed_ips': [{'ip_address': t_constants.MOCK_IP_ADDRESS,
+                           'subnet_id': t_constants.MOCK_SUBNET_ID}]
         }
-        create_port.assert_called_once_with(exp_create_port_call)
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
         self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
@@ -729,17 +694,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch('octavia.network.drivers.neutron.base.BaseNeutronDriver.'
                 '_check_extension_enabled', return_value=True)
     def test_allocate_vip_when_no_port_fixed_ip(self, mock_check_ext):
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
-        show_subnet.return_value = {'subnet': {
+        show_subnet = self.driver.network_proxy.get_subnet
+        show_subnet.return_value = Subnet(**{
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
-        }}
+        })
         fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID,
                                       network_id=t_constants.MOCK_NETWORK_ID,
                                       ip_address=t_constants.MOCK_IP_ADDRESS)
@@ -747,18 +712,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                            project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'project_id': 'test-project',
-                'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID,
-                               'ip_address': t_constants.MOCK_IP_ADDRESS}]
-            }
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'project_id': 'test-project',
+            'fixed_ips': [{'subnet_id': t_constants.MOCK_SUBNET_ID,
+                           'ip_address': t_constants.MOCK_IP_ADDRESS}]
         }
-        create_port.assert_called_once_with(exp_create_port_call)
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
         self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
@@ -769,31 +732,29 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch('octavia.network.drivers.neutron.base.BaseNeutronDriver.'
                 '_check_extension_enabled', return_value=True)
     def test_allocate_vip_when_no_port_no_fixed_ip(self, mock_check_ext):
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
-        show_subnet.return_value = {'subnet': {
+        show_subnet = self.driver.network_proxy.get_subnet
+        show_subnet.return_value = {
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
-        }}
+        }
         fake_lb_vip = data_models.Vip(network_id=t_constants.MOCK_NETWORK_ID)
         fake_lb = data_models.LoadBalancer(id='1', vip=fake_lb_vip,
                                            project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'project_id': 'test-project'}
-        }
-        create_port.assert_called_once_with(exp_create_port_call)
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'project_id': 'test-project'}
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_PORT_ID, vip.port_id)
         self.assertEqual(fake_lb.id, vip.load_balancer_id)
@@ -802,17 +763,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch('octavia.network.drivers.neutron.base.BaseNeutronDriver.'
                 '_check_extension_enabled', return_value=False)
     def test_allocate_vip_when_no_port_provided_tenant(self, mock_check_ext):
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
-        show_subnet.return_value = {'subnet': {
+        show_subnet = self.driver.network_proxy.get_subnet
+        show_subnet.return_value = {
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
-        }}
+        }
         fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID,
                                       network_id=t_constants.MOCK_NETWORK_ID,
                                       ip_address=t_constants.MOCK_IP_ADDRESS)
@@ -820,18 +781,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                            project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'tenant_id': 'test-project',
-                'fixed_ips': [{'ip_address': t_constants.MOCK_IP_ADDRESS,
-                               'subnet_id': t_constants.MOCK_SUBNET_ID}]
-            }
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'tenant_id': 'test-project',
+            'fixed_ips': [{'ip_address': t_constants.MOCK_IP_ADDRESS,
+                           'subnet_id': t_constants.MOCK_SUBNET_ID}]
         }
-        create_port.assert_called_once_with(exp_create_port_call)
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
         self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
@@ -842,17 +801,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch('octavia.network.drivers.neutron.base.BaseNeutronDriver.'
                 '_check_extension_enabled', return_value=False)
     def test_allocate_vip_with_additional_vips(self, mock_check_ext):
-        port_create_dict = copy.deepcopy(t_constants.MOCK_NEUTRON_PORT)
-        port_create_dict['port']['device_owner'] = (
+        port_create_dict = Port(**t_constants.MOCK_NEUTRON_PORT.to_dict())
+        port_create_dict['device_owner'] = (
             allowed_address_pairs.OCTAVIA_OWNER)
-        port_create_dict['port']['device_id'] = 'lb-1'
-        create_port = self.driver.neutron_client.create_port
+        port_create_dict['device_id'] = 'lb-1'
+        create_port = self.driver.network_proxy.create_port
         create_port.return_value = port_create_dict
-        show_subnet = self.driver.neutron_client.show_subnet
-        show_subnet.return_value = {'subnet': {
+        show_subnet = self.driver.network_proxy.get_subnet
+        show_subnet.return_value = {
             'id': t_constants.MOCK_SUBNET_ID,
             'network_id': t_constants.MOCK_NETWORK_ID
-        }}
+        }
         fake_lb_vip = data_models.Vip(subnet_id=t_constants.MOCK_SUBNET_ID,
                                       network_id=t_constants.MOCK_NETWORK_ID,
                                       ip_address=t_constants.MOCK_IP_ADDRESS)
@@ -865,21 +824,19 @@ class TestAllowedAddressPairsDriver(base.TestCase):
             project_id='test-project')
         vip, additional_vips = self.driver.allocate_vip(fake_lb)
         exp_create_port_call = {
-            'port': {
-                'name': 'octavia-lb-1',
-                'network_id': t_constants.MOCK_NETWORK_ID,
-                'device_id': 'lb-1',
-                'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
-                'admin_state_up': False,
-                'tenant_id': 'test-project',
-                'fixed_ips': [
-                    {'ip_address': t_constants.MOCK_IP_ADDRESS,
-                     'subnet_id': t_constants.MOCK_SUBNET_ID},
-                    {'ip_address': t_constants.MOCK_IP_ADDRESS2},
-                    {'subnet_id': t_constants.MOCK_SUBNET_ID3}]
-            }
+            'name': 'octavia-lb-1',
+            'network_id': t_constants.MOCK_NETWORK_ID,
+            'device_id': 'lb-1',
+            'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
+            'admin_state_up': False,
+            'tenant_id': 'test-project',
+            'fixed_ips': [
+                {'ip_address': t_constants.MOCK_IP_ADDRESS,
+                 'subnet_id': t_constants.MOCK_SUBNET_ID},
+                {'ip_address': t_constants.MOCK_IP_ADDRESS2},
+                {'subnet_id': t_constants.MOCK_SUBNET_ID3}]
         }
-        create_port.assert_called_once_with(exp_create_port_call)
+        create_port.assert_called_once_with(**exp_create_port_call)
         self.assertIsInstance(vip, data_models.Vip)
         self.assertEqual(t_constants.MOCK_IP_ADDRESS, vip.ip_address)
         self.assertEqual(t_constants.MOCK_SUBNET_ID, vip.subnet_id)
@@ -892,23 +849,22 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     def test_unplug_aap_port_errors_when_update_port_cant_find_port(
             self, mock_time_sleep, mock_time_time):
         lb = dmh.generate_load_balancer_tree()
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_NEUTRON_PORT['port']
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_NEUTRON_PORT
         port2 = {
             'id': '4', 'network_id': '3', 'fixed_ips':
-            [{'ip_address': '10.0.0.2'}]
+                [{'ip_address': '10.0.0.2'}]
         }
         subnet = network_models.Subnet(
             id=t_constants.MOCK_MANAGEMENT_SUBNET_ID,
             network_id='3')
         list_ports.side_effect = [
-            {'ports': [port1, port2]},
-            {'ports': [port1, port2]},
-            {'ports': [port1]}
+            iter([port1, port2]),
+            iter([port1, port2]),
+            iter([port1]),
         ]
-        mock_time_time.side_effect = [1, 1, 2]
-        update_port = self.driver.neutron_client.update_port
-        update_port.side_effect = neutron_exceptions.PortNotFoundClient
+        update_port = self.driver.network_proxy.update_port
+        update_port.side_effect = os_exceptions.ResourceNotFound
         self.assertRaises(network_base.UnplugVIPException,
                           self.driver.unplug_aap_port, lb.vip, lb.amphorae[0],
                           subnet)
@@ -918,25 +874,25 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     def test_unplug_aap_errors_when_update_port_fails(
             self, mock_time_sleep, mock_time_time):
         lb = dmh.generate_load_balancer_tree()
-        port1 = t_constants.MOCK_NEUTRON_PORT['port']
+        port1 = t_constants.MOCK_NEUTRON_PORT
         port2 = {
             'id': '4', 'network_id': '3', 'fixed_ips':
-            [{'ip_address': '10.0.0.2'}]
+                [{'ip_address': '10.0.0.2'}]
         }
 
         subnet = network_models.Subnet(
             id=t_constants.MOCK_MANAGEMENT_SUBNET_ID,
             network_id='3')
 
-        list_ports = self.driver.neutron_client.list_ports
+        list_ports = self.driver.network_proxy.ports
         list_ports.side_effect = [
-            {'ports': [port1, port2]},
-            {'ports': [port1, port2]},
-            {'ports': [port1]}
+            iter([port1, port2]),
+            iter([port1, port2]),
+            iter([port1]),
         ]
         mock_time_time.side_effect = [1, 1, 2]
 
-        update_port = self.driver.neutron_client.update_port
+        update_port = self.driver.network_proxy.update_port
         update_port.side_effect = TypeError
         self.assertRaises(network_base.UnplugVIPException,
                           self.driver.unplug_aap_port, lb.vip,
@@ -944,8 +900,8 @@ class TestAllowedAddressPairsDriver(base.TestCase):
 
     def test_unplug_vip_errors_when_vip_subnet_not_found(self):
         lb = dmh.generate_load_balancer_tree()
-        show_subnet = self.driver.neutron_client.show_subnet
-        show_subnet.side_effect = neutron_exceptions.NotFound
+        show_subnet = self.driver.network_proxy.get_subnet
+        show_subnet.side_effect = os_exceptions.ResourceNotFound
         self.assertRaises(network_base.PluggedVIPNotFound,
                           self.driver.unplug_vip, lb, lb.vip)
 
@@ -953,7 +909,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                 'AllowedAddressPairsDriver.unplug_aap_port')
     def test_unplug_vip(self, mock):
         lb = dmh.generate_load_balancer_tree()
-        show_subnet = self.driver.neutron_client.show_subnet
+        show_subnet = self.driver.network_proxy.get_subnet
         show_subnet.return_value = t_constants.MOCK_SUBNET
         self.driver.unplug_vip(lb, lb.vip)
         self.assertEqual(len(lb.amphorae), mock.call_count)
@@ -965,27 +921,27 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     def test_unplug_aap_port(self, mock_unplug_network,
                              mock_time_sleep, mock_time_time):
         lb = dmh.generate_load_balancer_tree()
-        update_port = self.driver.neutron_client.update_port
-        port1 = t_constants.MOCK_NEUTRON_PORT['port']
+        update_port = self.driver.network_proxy.update_port
+        port1 = t_constants.MOCK_NEUTRON_PORT
         port2 = {
             'id': '4', 'network_id': '3', 'fixed_ips':
-            [{'ip_address': '10.0.0.2'}]
+                [{'ip_address': '10.0.0.2'}]
         }
         subnet = network_models.Subnet(
             id=t_constants.MOCK_MANAGEMENT_SUBNET_ID,
             network_id='3')
-        list_ports = self.driver.neutron_client.list_ports
+        list_ports = self.driver.network_proxy.ports
         list_ports.side_effect = [
-            {'ports': [port1, port2]},
-            {'ports': [port1, port2]},
-            {'ports': [port1]}
+            iter([port1, port2]),
+            iter([port1, port2]),
+            iter([port1]),
         ]
         mock_time_time.side_effect = [1, 1, 2]
-        get_port = self.driver.neutron_client.get_port
-        get_port.side_effect = neutron_exceptions.NotFound
+        get_port = self.driver.network_proxy.get_port
+        get_port.side_effect = os_exceptions.ResourceNotFound
         self.driver.unplug_aap_port(lb.vip, lb.amphorae[0], subnet)
-        clear_aap = {'port': {'allowed_address_pairs': []}}
-        update_port.assert_called_once_with(port2.get('id'), clear_aap)
+        clear_aap = {'allowed_address_pairs': []}
+        update_port.assert_called_once_with(port2.get('id'), **clear_aap)
         mock_unplug_network.assert_called_once_with(
             lb.amphorae[0].compute_id, subnet.network_id)
 
@@ -1032,15 +988,15 @@ class TestAllowedAddressPairsDriver(base.TestCase):
 
     def test_unplug_network_when_compute_port_cant_be_found(self):
         net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
-        list_ports = self.driver.neutron_client.list_ports
-        list_ports.return_value = {'ports': []}
+        list_ports = self.driver.network_proxy.ports
+        list_ports.return_value = iter([])
         self.assertRaises(network_base.NetworkNotFound,
                           self.driver.unplug_network,
                           t_constants.MOCK_COMPUTE_ID, net_id)
 
     def test_unplug_network_when_list_ports_fails(self):
         net_id = t_constants.MOCK_NOVA_INTERFACE.net_id
-        list_ports = self.driver.neutron_client.list_ports
+        list_ports = self.driver.network_proxy.ports
         list_ports.side_effect = Exception
         self.assertRaises(network_base.NetworkException,
                           self.driver.unplug_network,
@@ -1049,16 +1005,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch("time.time")
     @mock.patch("time.sleep")
     def test_unplug_network(self, mock_time_sleep, mock_time_time):
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_NEUTRON_PORT['port']
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_NEUTRON_PORT
         port2 = {
             'id': '4', 'network_id': '3', 'fixed_ips':
-            [{'ip_address': '10.0.0.2'}]
+                [{'ip_address': '10.0.0.2'}]
         }
         list_ports.side_effect = [
-            {'ports': [port1, port2]},
-            {'ports': [port1, port2]},
-            {'ports': [port1]}
+            iter([port1, port2]),
+            iter([port1, port2]),
+            iter([port1]),
         ]
         port_detach = self.driver.compute.detach_port
 
@@ -1076,13 +1032,14 @@ class TestAllowedAddressPairsDriver(base.TestCase):
     @mock.patch("octavia.network.drivers.neutron.allowed_address_pairs.LOG")
     def test_unplug_network_timeout(self, mock_log,
                                     mock_time_sleep, mock_time_time):
-        list_ports = self.driver.neutron_client.list_ports
-        port1 = t_constants.MOCK_NEUTRON_PORT['port']
-        port2 = {
+        list_ports = self.driver.network_proxy.ports
+        port1 = t_constants.MOCK_NEUTRON_PORT
+        port2 = Port(**{
             'id': '4', 'network_id': '3', 'fixed_ips':
-            [{'ip_address': '10.0.0.2'}]
-        }
-        list_ports.return_value = {'ports': [port1, port2]}
+                [{'ip_address': '10.0.0.2'}]
+        })
+
+        list_ports.side_effect = [iter([port1, port2]) for _ in range(7)]
         port_detach = self.driver.compute.detach_port
 
         mock_time_time.side_effect = [0, 0, 1, 2, 10, 20, 100, 300]
@@ -1099,12 +1056,13 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         lc_1 = data_models.ListenerCidr('l1', '10.0.101.0/24')
         lc_2 = data_models.ListenerCidr('l2', '10.0.102.0/24')
         lc_3 = data_models.ListenerCidr('l2', '10.0.103.0/24')
+        lc_4 = data_models.ListenerCidr('l2', '2001:0DB8::/32')
         listeners = [data_models.Listener(protocol_port=80, peer_port=1024,
                                           protocol=constants.PROTOCOL_TCP,
                                           allowed_cidrs=[lc_1]),
                      data_models.Listener(protocol_port=443, peer_port=1025,
                                           protocol=constants.PROTOCOL_TCP,
-                                          allowed_cidrs=[lc_2, lc_3]),
+                                          allowed_cidrs=[lc_2, lc_3, lc_4]),
                      data_models.Listener(protocol_port=50, peer_port=1026,
                                           protocol=constants.PROTOCOL_UDP)]
         vip = data_models.Vip(ip_address='10.0.0.2')
@@ -1113,94 +1071,101 @@ class TestAllowedAddressPairsDriver(base.TestCase):
             ip_address=self.IPV6_ADDRESS_1)
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip,
                                       additional_vips=[additional_vip])
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]}
-        fake_rules = {
-            'security_group_rules': [
-                {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp',
-                 'remote_ip_prefix': '10.0.101.0/24'},
-                {'id': 'rule-22', 'port_range_max': 22, 'protocol': 'tcp'}
-            ]
-        }
-        list_rules = self.driver.neutron_client.list_security_group_rules
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = {'id': 'secgrp-1'}
+        fake_rules = [
+            {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp',
+             'remote_ip_prefix': '10.0.101.0/24'},
+            {'id': 'rule-22', 'port_range_max': 22, 'protocol': 'tcp'}
+        ]
+        list_rules = self.driver.network_proxy.security_group_rules
         list_rules.return_value = fake_rules
-        delete_rule = self.driver.neutron_client.delete_security_group_rule
-        create_rule = self.driver.neutron_client.create_security_group_rule
+        delete_rule = self.driver.network_proxy.delete_security_group_rule
+        create_rule = self.driver.network_proxy.create_security_group_rule
         self.driver.update_vip(lb)
         delete_rule.assert_called_once_with('rule-22')
         expected_create_rule_1 = {
-            'security_group_rule': {
-                'security_group_id': 'secgrp-1',
-                'direction': 'ingress',
-                'protocol': 'tcp',
-                'port_range_min': 1024,
-                'port_range_max': 1024,
-                'ethertype': 'IPv4',
-                'remote_ip_prefix': None
-            }
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'tcp',
+            'port_range_min': 1024,
+            'port_range_max': 1024,
+            'ethertype': 'IPv4',
+            'remote_ip_prefix': None
         }
         expected_create_rule_udp_peer = {
-            'security_group_rule': {
-                'security_group_id': 'secgrp-1',
-                'direction': 'ingress',
-                'protocol': 'tcp',
-                'port_range_min': 1026,
-                'port_range_max': 1026,
-                'ethertype': 'IPv4',
-                'remote_ip_prefix': None
-            }
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'tcp',
+            'port_range_min': 1026,
+            'port_range_max': 1026,
+            'ethertype': 'IPv4',
+            'remote_ip_prefix': None
         }
         expected_create_rule_2 = {
-            'security_group_rule': {
-                'security_group_id': 'secgrp-1',
-                'direction': 'ingress',
-                'protocol': 'tcp',
-                'port_range_min': 1025,
-                'port_range_max': 1025,
-                'ethertype': 'IPv4',
-                'remote_ip_prefix': None
-            }
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'tcp',
+            'port_range_min': 1025,
+            'port_range_max': 1025,
+            'ethertype': 'IPv4',
+            'remote_ip_prefix': None
         }
         expected_create_rule_3 = {
-            'security_group_rule': {
-                'security_group_id': 'secgrp-1',
-                'direction': 'ingress',
-                'protocol': 'tcp',
-                'port_range_min': 443,
-                'port_range_max': 443,
-                'ethertype': 'IPv4',
-                'remote_ip_prefix': '10.0.102.0/24'
-            }
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'tcp',
+            'port_range_min': 443,
+            'port_range_max': 443,
+            'ethertype': 'IPv4',
+            'remote_ip_prefix': '10.0.102.0/24'
         }
         expected_create_rule_4 = {
-            'security_group_rule': {
-                'security_group_id': 'secgrp-1',
-                'direction': 'ingress',
-                'protocol': 'tcp',
-                'port_range_min': 443,
-                'port_range_max': 443,
-                'ethertype': 'IPv4',
-                'remote_ip_prefix': '10.0.103.0/24'
-            }
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'tcp',
+            'port_range_min': 443,
+            'port_range_max': 443,
+            'ethertype': 'IPv4',
+            'remote_ip_prefix': '10.0.103.0/24'
+        }
+        expected_create_rule_5 = {
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'tcp',
+            'port_range_min': 443,
+            'port_range_max': 443,
+            'ethertype': 'IPv6',
+            'remote_ip_prefix': '2001:0DB8::/32'
         }
-        expected_create_rule_udp = {
-            'security_group_rule': {
-                'security_group_id': 'secgrp-1',
-                'direction': 'ingress',
-                'protocol': 'udp',
-                'port_range_min': 50,
-                'port_range_max': 50,
-                'ethertype': 'IPv4',
-                'remote_ip_prefix': None
-            }
+        expected_create_rule_udp_1 = {
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'udp',
+            'port_range_min': 50,
+            'port_range_max': 50,
+            'ethertype': 'IPv4',
+            'remote_ip_prefix': None
+        }
+        expected_create_rule_udp_2 = {
+            'security_group_id': 'secgrp-1',
+            'direction': 'ingress',
+            'protocol': 'udp',
+            'port_range_min': 50,
+            'port_range_max': 50,
+            'ethertype': 'IPv6',
+            'remote_ip_prefix': None
         }
 
-        create_rule.assert_has_calls([mock.call(expected_create_rule_1),
-                                      mock.call(expected_create_rule_udp_peer),
-                                      mock.call(expected_create_rule_2),
-                                      mock.call(expected_create_rule_3),
-                                      mock.call(expected_create_rule_4),
-                                      mock.call(expected_create_rule_udp)],
+        create_rule.assert_has_calls([mock.call(**expected_create_rule_1),
+                                      mock.call(
+                                          **expected_create_rule_udp_peer),
+                                      mock.call(**expected_create_rule_2),
+                                      mock.call(**expected_create_rule_3),
+                                      mock.call(**expected_create_rule_4),
+                                      mock.call(**expected_create_rule_5),
+                                      mock.call(**expected_create_rule_udp_1),
+                                      mock.call(**expected_create_rule_udp_2)],
                                      any_order=True)
 
     def test_update_vip_when_protocol_and_peer_ports_overlap(self):
@@ -1214,18 +1179,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                           allowed_cidrs=[lc_1])]
         vip = data_models.Vip(ip_address='10.0.0.2')
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip)
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]}
-        fake_rules = {
-            'security_group_rules': [
-                {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp'},
-                {'id': 'rule-22', 'port_range_max': 22, 'protocol': 'tcp'}
-            ]
-        }
-        list_rules = self.driver.neutron_client.list_security_group_rules
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = {'id': 'secgrp-1'}
+        fake_rules = [
+            {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp'},
+            {'id': 'rule-22', 'port_range_max': 22, 'protocol': 'tcp'}
+        ]
+        list_rules = self.driver.network_proxy.security_group_rules
         list_rules.return_value = fake_rules
-        delete_rule = self.driver.neutron_client.delete_security_group_rule
-        create_rule = self.driver.neutron_client.create_security_group_rule
+        delete_rule = self.driver.network_proxy.delete_security_group_rule
+        create_rule = self.driver.network_proxy.create_security_group_rule
         self.driver.update_vip(lb)
         delete_rule.assert_called_once_with('rule-22')
 
@@ -1245,19 +1208,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                          provisioning_status=constants.PENDING_DELETE)]
         vip = data_models.Vip(ip_address='10.0.0.2')
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip)
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]}
-        fake_rules = {
-            'security_group_rules': [
-                {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp'},
-                {'id': 'rule-22', 'port_range_max': 443, 'protocol': 'tcp'},
-                {'id': 'rule-udp-50', 'port_range_max': 50, 'protocol': 'tcp'}
-            ]
-        }
-        list_rules = self.driver.neutron_client.list_security_group_rules
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = {'id': 'secgrp-1'}
+        fake_rules = [
+            {'id': 'rule-80', 'port_range_max': 80, 'protocol': 'tcp'},
+            {'id': 'rule-22', 'port_range_max': 443, 'protocol': 'tcp'},
+            {'id': 'rule-udp-50', 'port_range_max': 50, 'protocol': 'tcp'}
+        ]
+        list_rules = self.driver.network_proxy.security_group_rules
         list_rules.return_value = fake_rules
-        delete_rule = self.driver.neutron_client.delete_security_group_rule
-        create_rule = self.driver.neutron_client.create_security_group_rule
+        delete_rule = self.driver.network_proxy.delete_security_group_rule
+        create_rule = self.driver.network_proxy.create_security_group_rule
         self.driver.update_vip(lb)
         delete_rule.assert_has_calls(
             [mock.call('rule-22'), mock.call('rule-udp-50')])
@@ -1267,17 +1228,15 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         listeners = []
         vip = data_models.Vip(ip_address='10.0.0.2')
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip)
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]}
-        fake_rules = {
-            'security_group_rules': [
-                {'id': 'all-egress', 'protocol': None, 'direction': 'egress'},
-                {'id': 'ssh-rule', 'protocol': 'tcp', 'port_range_max': 22}
-            ]
-        }
-        list_rules = self.driver.neutron_client.list_security_group_rules
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = {'id': 'secgrp-1'}
+        fake_rules = [
+            {'id': 'all-egress', 'protocol': None, 'direction': 'egress'},
+            {'id': 'ssh-rule', 'protocol': 'tcp', 'port_range_max': 22}
+        ]
+        list_rules = self.driver.network_proxy.security_group_rules
         list_rules.return_value = fake_rules
-        delete_rule = self.driver.neutron_client.delete_security_group_rule
+        delete_rule = self.driver.network_proxy.delete_security_group_rule
         self.driver.update_vip(lb)
         delete_rule.assert_called_once_with('ssh-rule')
 
@@ -1285,18 +1244,16 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         listeners = []
         vip = data_models.Vip(ip_address='10.0.0.2')
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip)
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': [{'id': 'secgrp-1'}]}
-        fake_rules = {
-            'security_group_rules': [
-                {'id': 'all-egress', 'protocol': None, 'direction': 'egress'},
-                {'id': 'ssh-rule', 'protocol': 'tcp', 'port_range_max': 22}
-            ]
-        }
-        list_rules = self.driver.neutron_client.list_security_group_rules
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = {'id': 'secgrp-1'}
+        fake_rules = [
+            {'id': 'all-egress', 'protocol': None, 'direction': 'egress'},
+            {'id': 'ssh-rule', 'protocol': 'tcp', 'port_range_max': 22}
+        ]
+        list_rules = self.driver.network_proxy.security_group_rules
         list_rules.return_value = fake_rules
-        delete_rule = self.driver.neutron_client.delete_security_group_rule
-        delete_rule.side_effect = neutron_exceptions.NotFound
+        delete_rule = self.driver.network_proxy.delete_security_group_rule
+        delete_rule.side_effect = os_exceptions.ResourceNotFound
         self.driver.update_vip(lb)
         delete_rule.assert_called_once_with('ssh-rule')
 
@@ -1304,8 +1261,8 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         listeners = []
         vip = data_models.Vip(ip_address='10.0.0.2')
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip)
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': []}
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = None
         self.assertRaises(exceptions.MissingVIPSecurityGroup,
                           self.driver.update_vip,
                           lb)
@@ -1317,25 +1274,27 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         listeners = []
         vip = data_models.Vip(ip_address='10.0.0.2')
         lb = data_models.LoadBalancer(id='1', listeners=listeners, vip=vip)
-        list_sec_grps = self.driver.neutron_client.list_security_groups
-        list_sec_grps.return_value = {'security_groups': []}
+        list_sec_grps = self.driver.network_proxy.find_security_group
+        list_sec_grps.return_value = None
         self.driver.update_vip(lb, for_delete=True)
         update_rules.assert_not_called()
 
     def test_failover_preparation(self):
         original_dns_integration_state = self.driver.dns_integration_enabled
         self.driver.dns_integration_enabled = False
-        ports = {"ports": [
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
-                            "ip_address": self.IP_ADDRESS_1}],
-             "id": self.FIXED_IP_ID_1, "network_id": self.NETWORK_ID_1},
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
-                            "ip_address": self.IP_ADDRESS_2}],
-             "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2}]}
-        self.driver.neutron_client.list_ports.return_value = ports
-        self.driver.neutron_client.show_port = mock.Mock(
+        ports = [
+            Port(**{"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
+                                   "ip_address": self.IP_ADDRESS_1}],
+                    "id": self.FIXED_IP_ID_1,
+                    "network_id": self.NETWORK_ID_1}),
+            Port(**{"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
+                                   "ip_address": self.IP_ADDRESS_2}],
+                    "id": self.FIXED_IP_ID_2,
+                    "network_id": self.NETWORK_ID_2})]
+        self.driver.network_proxy.ports.return_value = ports
+        self.driver.network_proxy.get_port = mock.Mock(
             side_effect=self._failover_show_port_side_effect)
-        port_update = self.driver.neutron_client.update_port
+        port_update = self.driver.network_proxy.update_port
         amphora = data_models.Amphora(
             id=self.AMPHORA_ID, load_balancer_id=self.LB_ID,
             compute_id=self.COMPUTE_ID, status=self.ACTIVE,
@@ -1346,38 +1305,42 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         self.driver.dns_integration_enabled = original_dns_integration_state
 
     def test_failover_preparation_dns_integration(self):
-        ports = {"ports": [
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
-                            "ip_address": self.IP_ADDRESS_1}],
-             "id": self.FIXED_IP_ID_1, "network_id": self.NETWORK_ID_1},
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
-                            "ip_address": self.IP_ADDRESS_2}],
-             "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2}]}
+        ports = [
+            Port(**{"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
+                                   "ip_address": self.IP_ADDRESS_1}],
+                    "id": self.FIXED_IP_ID_1,
+                    "network_id": self.NETWORK_ID_1}),
+            Port(**{"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
+                                   "ip_address": self.IP_ADDRESS_2}],
+                    "id": self.FIXED_IP_ID_2,
+                    "network_id": self.NETWORK_ID_2})]
         original_dns_integration_state = self.driver.dns_integration_enabled
         self.driver.dns_integration_enabled = True
-        self.driver.neutron_client.list_ports.return_value = ports
-        self.driver.neutron_client.show_port = mock.Mock(
+        self.driver.network_proxy.ports.return_value = ports
+        self.driver.network_proxy.get_port = mock.Mock(
             side_effect=self._failover_show_port_side_effect)
-        port_update = self.driver.neutron_client.update_port
+        port_update = self.driver.network_proxy.update_port
         amphora = data_models.Amphora(
             id=self.AMPHORA_ID, load_balancer_id=self.LB_ID,
             compute_id=self.COMPUTE_ID, status=self.ACTIVE,
             lb_network_ip=self.LB_NET_IP, ha_port_id=self.HA_PORT_ID,
             ha_ip=self.HA_IP)
         self.driver.failover_preparation(amphora)
-        port_update.assert_called_once_with(ports['ports'][1].get('id'),
-                                            {'port': {'dns_name': ''}})
+        port_update.assert_called_once_with(ports[1].get('id'),
+                                            dns_name='')
         self.driver.dns_integration_enabled = original_dns_integration_state
 
     def _failover_show_port_side_effect(self, port_id):
         if port_id == self.LB_NET_PORT_ID:
-            return {"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
-                                   "ip_address": self.IP_ADDRESS_1}],
-                    "id": self.FIXED_IP_ID_1, "network_id": self.NETWORK_ID_1}
+            return Port(**{"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
+                                          "ip_address": self.IP_ADDRESS_1}],
+                           "id": self.FIXED_IP_ID_1,
+                           "network_id": self.NETWORK_ID_1})
         if port_id == self.HA_PORT_ID:
-            return {"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
-                                   "ip_address": self.IP_ADDRESS_2}],
-                    "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2}
+            return Port(**{"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
+                                          "ip_address": self.IP_ADDRESS_2}],
+                           "id": self.FIXED_IP_ID_2,
+                           "network_id": self.NETWORK_ID_2})
 
     def test_plug_port(self):
         port = mock.MagicMock()
@@ -1434,7 +1397,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         vip_mock = mock.MagicMock()
         amphora_mock.status = constants.DELETED
         load_balancer_mock.amphorae = [amphora_mock]
-        show_port = self.driver.neutron_client.show_port
+        show_port = self.driver.network_proxy.get_port
         show_port.side_effect = [
             t_constants.MOCK_NEUTRON_PORT, t_constants.MOCK_NEUTRON_PORT,
             t_constants.MOCK_NEUTRON_PORT, t_constants.MOCK_NEUTRON_PORT,
@@ -1444,15 +1407,15 @@ class TestAllowedAddressPairsDriver(base.TestCase):
             t_constants.MOCK_NEUTRON_PORT, t_constants.MOCK_NEUTRON_PORT,
             t_constants.MOCK_NEUTRON_PORT, t_constants.MOCK_NEUTRON_PORT,
             Exception('boom')]
-        fake_subnet = {'subnet': {
+        fake_subnet = Subnet(**{
             'id': t_constants.MOCK_SUBNET_ID,
             'gateway_ip': t_constants.MOCK_IP_ADDRESS,
-            'cidr': t_constants.MOCK_CIDR}}
-        fake_subnet2 = {'subnet': {
+            'cidr': t_constants.MOCK_CIDR})
+        fake_subnet2 = Subnet(**{
             'id': t_constants.MOCK_SUBNET_ID2,
             'gateway_ip': t_constants.MOCK_IP_ADDRESS2,
-            'cidr': t_constants.MOCK_CIDR}}
-        show_subnet = self.driver.neutron_client.show_subnet
+            'cidr': t_constants.MOCK_CIDR})
+        show_subnet = self.driver.network_proxy.get_subnet
         show_subnet.return_value = fake_subnet
         configs = self.driver.get_network_configs(load_balancer_mock)
         self.assertEqual({}, configs)
@@ -1479,10 +1442,10 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         # will return the same values if a method happens to call it
         # multiple times for different subnets. We should be able to verify
         # different requests get different expected data.
-        expected_port_id = t_constants.MOCK_NEUTRON_PORT['port']['id']
+        expected_port_id = t_constants.MOCK_NEUTRON_PORT['id']
         self.assertEqual(expected_port_id, config.ha_port.id)
         self.assertEqual(expected_port_id, config.vrrp_port.id)
-        expected_subnet_id = fake_subnet['subnet']['id']
+        expected_subnet_id = fake_subnet['id']
         self.assertEqual(expected_subnet_id, config.ha_subnet.id)
         self.assertEqual(expected_subnet_id, config.vrrp_subnet.id)
 
@@ -1520,10 +1483,10 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         # will return the same values if a method happens to call it
         # multiple times for different subnets. We should be able to verify
         # different requests get different expected data.
-        expected_port_id = t_constants.MOCK_NEUTRON_PORT['port']['id']
+        expected_port_id = t_constants.MOCK_NEUTRON_PORT['id']
         self.assertEqual(expected_port_id, config.ha_port.id)
         self.assertEqual(expected_port_id, config.vrrp_port.id)
-        expected_subnet_id = fake_subnet['subnet']['id']
+        expected_subnet_id = fake_subnet['id']
         self.assertEqual(expected_subnet_id, config.ha_subnet.id)
         self.assertEqual(expected_subnet_id, config.vrrp_subnet.id)
 
@@ -1533,84 +1496,17 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         configs = self.driver.get_network_configs(load_balancer_mock)
         self.assertEqual(1, len(configs))
 
-    @mock.patch('time.sleep')
-    def test_wait_for_port_detach(self, mock_sleep):
-        amphora = data_models.Amphora(
-            id=self.AMPHORA_ID, load_balancer_id=self.LB_ID,
-            compute_id=self.COMPUTE_ID, status=self.ACTIVE,
-            lb_network_ip=self.LB_NET_IP, ha_port_id=self.HA_PORT_ID,
-            ha_ip=self.HA_IP)
-        ports = {"ports": [
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
-                            "ip_address": self.IP_ADDRESS_1}],
-             "id": self.FIXED_IP_ID_1, "network_id": self.NETWORK_ID_1},
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
-                            "ip_address": self.IP_ADDRESS_2}],
-             "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2}]}
-        show_port_1_without_device_id = {"fixed_ips": [
-            {"subnet_id": self.SUBNET_ID_1, "ip_address": self.IP_ADDRESS_1}],
-            "id": self.FIXED_IP_ID_1, "network_id": self.NETWORK_ID_1,
-            "device_id": ''}
-        show_port_2_with_device_id = {"fixed_ips": [
-            {"subnet_id": self.SUBNET_ID_2, "ip_address": self.IP_ADDRESS_2}],
-            "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2,
-            "device_id": self.DEVICE_ID}
-        show_port_2_without_device_id = {"fixed_ips": [
-            {"subnet_id": self.SUBNET_ID_2, "ip_address": self.IP_ADDRESS_2}],
-            "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2,
-            "device_id": None}
-        self.driver.neutron_client.list_ports.return_value = ports
-        port_mock = mock.MagicMock()
-        port_mock.get = mock.Mock(
-            side_effect=[show_port_1_without_device_id,
-                         show_port_2_with_device_id,
-                         show_port_2_with_device_id,
-                         show_port_2_without_device_id])
-        self.driver.neutron_client.show_port.return_value = port_mock
-        self.driver.wait_for_port_detach(amphora)
-        self.assertEqual(1, mock_sleep.call_count)
-
-    @mock.patch('time.time')
-    @mock.patch('time.sleep')
-    def test_wait_for_port_detach_timeout(self, mock_sleep, mock_time):
-        mock_time.side_effect = [1, 2, 6]
-        conf = oslo_fixture.Config(cfg.CONF)
-        conf.config(group="networking", port_detach_timeout=5)
-        amphora = data_models.Amphora(
-            id=self.AMPHORA_ID, load_balancer_id=self.LB_ID,
-            compute_id=self.COMPUTE_ID, status=self.ACTIVE,
-            lb_network_ip=self.LB_NET_IP, ha_port_id=self.HA_PORT_ID,
-            ha_ip=self.HA_IP)
-        ports = {"ports": [
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_1,
-                            "ip_address": self.IP_ADDRESS_1}],
-             "id": self.FIXED_IP_ID_1, "network_id": self.NETWORK_ID_1},
-            {"fixed_ips": [{"subnet_id": self.SUBNET_ID_2,
-                            "ip_address": self.IP_ADDRESS_2}],
-             "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2}]}
-        show_port_1_with_device_id = {"fixed_ips": [
-            {"subnet_id": self.SUBNET_ID_2, "ip_address": self.IP_ADDRESS_2}],
-            "id": self.FIXED_IP_ID_2, "network_id": self.NETWORK_ID_2,
-            "device_id": self.DEVICE_ID}
-        self.driver.neutron_client.list_ports.return_value = ports
-        port_mock = mock.MagicMock()
-        port_mock.get = mock.Mock(
-            return_value=show_port_1_with_device_id)
-        self.driver.neutron_client.show_port.return_value = port_mock
-        self.assertRaises(network_base.TimeoutException,
-                          self.driver.wait_for_port_detach,
-                          amphora)
-
     def test_delete_port(self):
         PORT_ID = uuidutils.generate_uuid()
 
-        self.driver.neutron_client.delete_port.side_effect = [
-            mock.DEFAULT, neutron_exceptions.NotFound, Exception('boom')]
+        self.driver.network_proxy.delete_port.side_effect = [
+            mock.DEFAULT, os_exceptions.ResourceNotFound,
+            Exception('boom')]
 
         # Test successful delete
         self.driver.delete_port(PORT_ID)
 
-        self.driver.neutron_client.delete_port.assert_called_once_with(PORT_ID)
+        self.driver.network_proxy.delete_port.assert_called_once_with(PORT_ID)
 
         # Test port NotFound (does not raise)
         self.driver.delete_port(PORT_ID)
@@ -1623,24 +1519,24 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         PORT_ID = uuidutils.generate_uuid()
         TEST_STATE = 'test state'
 
-        self.driver.neutron_client.update_port.side_effect = [
-            mock.DEFAULT, neutron_exceptions.NotFound, Exception('boom')]
+        self.driver.network_proxy.update_port.side_effect = [
+            mock.DEFAULT, os_exceptions.ResourceNotFound, Exception('boom')]
 
         # Test successful state set
         self.driver.set_port_admin_state_up(PORT_ID, TEST_STATE)
 
-        self.driver.neutron_client.update_port.assert_called_once_with(
-            PORT_ID, {'port': {'admin_state_up': TEST_STATE}})
+        self.driver.network_proxy.update_port.assert_called_once_with(
+            PORT_ID, admin_state_up=TEST_STATE)
 
         # Test port NotFound
         self.assertRaises(network_base.PortNotFound,
                           self.driver.set_port_admin_state_up,
-                          PORT_ID, {'port': {'admin_state_up': TEST_STATE}})
+                          PORT_ID, TEST_STATE)
 
         # Test unknown exception
         self.assertRaises(exceptions.NetworkServiceError,
                           self.driver.set_port_admin_state_up, PORT_ID,
-                          {'port': {'admin_state_up': TEST_STATE}})
+                          TEST_STATE)
 
     def test_create_port(self):
         ADMIN_STATE_UP = False
@@ -1655,7 +1551,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         SUBNET1_ID = uuidutils.generate_uuid()
         FIXED_IPS = [{'subnet_id': SUBNET1_ID, 'ip_address': IP_ADDRESS1}]
 
-        MOCK_NEUTRON_PORT = {'port': {
+        MOCK_NEUTRON_PORT = Port(**{
             'network_id': NETWORK_ID, 'device_id': t_constants.MOCK_DEVICE_ID,
             'device_owner': t_constants.MOCK_DEVICE_OWNER,
             'id': t_constants.MOCK_PORT_ID, 'name': FAKE_NAME,
@@ -1666,7 +1562,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
             'fixed_ips': [{'ip_address': IP_ADDRESS1,
                            'subnet_id': SUBNET1_ID}],
             'security_groups': [],
-            'qos_policy_id': QOS_POLICY_ID}}
+            'qos_policy_id': QOS_POLICY_ID})
 
         reference_port_dict = {'admin_state_up': ADMIN_STATE_UP,
                                'device_id': t_constants.MOCK_DEVICE_ID,
@@ -1682,7 +1578,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                                'security_group_ids': [],
                                'status': t_constants.MOCK_STATUS}
 
-        self.driver.neutron_client.create_port.side_effect = [
+        self.driver.network_proxy.create_port.side_effect = [
             MOCK_NEUTRON_PORT, MOCK_NEUTRON_PORT, Exception('boom')]
 
         # Test successful path
@@ -1693,8 +1589,8 @@ class TestAllowedAddressPairsDriver(base.TestCase):
             qos_policy_id=QOS_POLICY_ID)
 
         self.assertEqual(reference_port_dict, result.to_dict())
-        self.driver.neutron_client.create_port.assert_called_once_with(
-            {'port': {
+        self.driver.network_proxy.create_port.assert_called_once_with(
+            **{
                 'network_id': NETWORK_ID, 'admin_state_up': ADMIN_STATE_UP,
                 'device_owner': allowed_address_pairs.OCTAVIA_OWNER,
                 'allowed_address_pairs': [
@@ -1702,7 +1598,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                 'fixed_ips': [{
                     'subnet_id': SUBNET1_ID, 'ip_address': IP_ADDRESS1}],
                 'name': FAKE_NAME, 'qos_policy_id': QOS_POLICY_ID,
-                'security_groups': [SECURITY_GROUP_ID]}})
+                'security_groups': [SECURITY_GROUP_ID]})
 
         # Test minimal successful path
         result = self.driver.create_port(NETWORK_ID)
@@ -1720,8 +1616,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
 
         # Test the case of security groups disabled in neutron
         FAKE_SG_NAME = 'Fake_SG_name'
-        FAKE_NEUTRON_SECURITY_GROUPS = {'security_groups': [
-            t_constants.MOCK_SECURITY_GROUP]}
+        FAKE_NEUTRON_SECURITY_GROUPS = iter([t_constants.MOCK_SECURITY_GROUP])
         reference_sg_dict = {'id': t_constants.MOCK_SECURITY_GROUP_ID,
                              'name': t_constants.MOCK_SECURITY_GROUP_NAME,
                              'description': '', 'tags': [],
@@ -1729,15 +1624,15 @@ class TestAllowedAddressPairsDriver(base.TestCase):
                              'stateful': None,
                              'project_id': t_constants.MOCK_PROJECT_ID}
 
-        neutron_client = self.driver.neutron_client
-        neutron_client.list_security_groups.side_effect = [
-            FAKE_NEUTRON_SECURITY_GROUPS, None, Exception('boom')]
+        network_proxy = self.driver.network_proxy
+        network_proxy.security_groups.side_effect = [
+            FAKE_NEUTRON_SECURITY_GROUPS, iter([]), Exception('boom')]
 
         self.driver.sec_grp_enabled = False
         result = self.driver.get_security_group(FAKE_SG_NAME)
 
         self.assertIsNone(result)
-        neutron_client.list_security_groups.assert_not_called()
+        network_proxy.security_groups.assert_not_called()
 
         # Test successful get of the security group
         self.driver.sec_grp_enabled = True
@@ -1745,7 +1640,7 @@ class TestAllowedAddressPairsDriver(base.TestCase):
         result = self.driver.get_security_group(FAKE_SG_NAME)
 
         self.assertEqual(reference_sg_dict, result.to_dict())
-        neutron_client.list_security_groups.assert_called_once_with(
+        network_proxy.security_groups.assert_called_once_with(
             name=FAKE_SG_NAME)
 
         # Test no security groups returned