octavia 13.0.0.0rc1__py3-none-any.whl → 14.0.0__py3-none-any.whl

octavia/tests/unit/amphorae/backends/agent/api_server/test_osutils.py

@@ -163,7 +163,8 @@ class TestOSUtils(base.TestCase):
             mtu=MTU,
             vrrp_info=None,
             fixed_ips=None,
-            topology="SINGLE")
+            topology="SINGLE",
+            is_sriov=False)
         mock_vip_interface_file.return_value.write.assert_called_once()
 
         # Now test with an IPv6 VIP
@@ -193,7 +194,8 @@ class TestOSUtils(base.TestCase):
             mtu=MTU,
             vrrp_info=None,
             fixed_ips=None,
-            topology="SINGLE")
+            topology="SINGLE",
+            is_sriov=False)
 
     @mock.patch('octavia.amphorae.backends.utils.interface_file.'
                 'PortInterfaceFile')

octavia/tests/unit/amphorae/backends/utils/test_interface.py

@@ -15,6 +15,7 @@
 import errno
 import os
 import socket
+import subprocess
 from unittest import mock
 
 import pyroute2
@@ -448,6 +449,150 @@ class TestInterface(base.TestCase):
             mock.call(["post-up", "eth1"])
         ])
 
+    @mock.patch('octavia.amphorae.backends.utils.network_namespace.'
+                'NetworkNamespace')
+    @mock.patch('octavia.amphorae.backends.utils.nftable_utils.'
+                'write_nftable_vip_rules_file')
+    @mock.patch('pyroute2.IPRoute.rule')
+    @mock.patch('pyroute2.IPRoute.route')
+    @mock.patch('pyroute2.IPRoute.addr')
+    @mock.patch('pyroute2.IPRoute.link')
+    @mock.patch('pyroute2.IPRoute.get_links')
+    @mock.patch('pyroute2.IPRoute.link_lookup')
+    @mock.patch('subprocess.check_output')
+    def test_up_sriov(self, mock_check_output, mock_link_lookup,
+                      mock_get_links, mock_link, mock_addr, mock_route,
+                      mock_rule, mock_nftable, mock_netns):
+        iface = interface_file.InterfaceFile(
+            name="fake-eth1",
+            if_type="vip",
+            mtu=1450,
+            addresses=[{
+                consts.ADDRESS: '192.0.2.4',
+                consts.PREFIXLEN: 24
+            }, {
+                consts.ADDRESS: '198.51.100.4',
+                consts.PREFIXLEN: 16
+            }, {
+                consts.ADDRESS: '2001:db8::3',
+                consts.PREFIXLEN: 64
+            }],
+            routes=[{
+                consts.DST: '203.0.113.0/24',
+                consts.GATEWAY: '192.0.2.1',
+                consts.TABLE: 10,
+                consts.ONLINK: True
+            }, {
+                consts.DST: '198.51.100.0/24',
+                consts.GATEWAY: '192.0.2.2',
+                consts.PREFSRC: '192.0.2.4',
+                consts.SCOPE: 'link'
+            }, {
+                consts.DST: '2001:db8:2::1/128',
+                consts.GATEWAY: '2001:db8::1'
+            }],
+            rules=[{
+                consts.SRC: '203.0.113.1',
+                consts.SRC_LEN: 32,
+                consts.TABLE: 20,
+            }, {
+                consts.SRC: '2001:db8::1',
+                consts.SRC_LEN: 128,
+                consts.TABLE: 40,
+            }],
+            scripts={
+                consts.IFACE_UP: [{
+                    consts.COMMAND: "post-up fake-eth1"
+                }],
+                consts.IFACE_DOWN: [{
+                    consts.COMMAND: "post-down fake-eth1"
+                }],
+            },
+            is_sriov=True)
+
+        idx = mock.MagicMock()
+        mock_link_lookup.return_value = [idx]
+
+        mock_get_links.return_value = [{
+            consts.STATE: consts.IFACE_DOWN
+        }]
+
+        controller = interface.InterfaceController()
+        controller.up(iface)
+
+        mock_link.assert_called_once_with(
+            controller.SET,
+            index=idx,
+            state=consts.IFACE_UP,
+            mtu=1450)
+
+        mock_addr.assert_has_calls([
+            mock.call(controller.ADD,
+                      index=idx,
+                      address='192.0.2.4',
+                      prefixlen=24,
+                      family=socket.AF_INET),
+            mock.call(controller.ADD,
+                      index=idx,
+                      address='198.51.100.4',
+                      prefixlen=16,
+                      family=socket.AF_INET),
+            mock.call(controller.ADD,
+                      index=idx,
+                      address='2001:db8::3',
+                      prefixlen=64,
+                      family=socket.AF_INET6)
+        ])
+
+        mock_route.assert_has_calls([
+            mock.call(controller.ADD,
+                      oif=idx,
+                      dst='203.0.113.0/24',
+                      gateway='192.0.2.1',
+                      table=10,
+                      onlink=True,
+                      family=socket.AF_INET),
+            mock.call(controller.ADD,
+                      oif=idx,
+                      dst='198.51.100.0/24',
+                      gateway='192.0.2.2',
+                      prefsrc='192.0.2.4',
+                      scope='link',
+                      family=socket.AF_INET),
+            mock.call(controller.ADD,
+                      oif=idx,
+                      dst='2001:db8:2::1/128',
+                      gateway='2001:db8::1',
+                      family=socket.AF_INET6)])
+
+        mock_rule.assert_has_calls([
+            mock.call(controller.ADD,
+                      src="203.0.113.1",
+                      src_len=32,
+                      table=20,
+                      family=socket.AF_INET),
+            mock.call(controller.ADD,
+                      src="2001:db8::1",
+                      src_len=128,
+                      table=40,
+                      family=socket.AF_INET6)])
+
+        mock_check_output.assert_has_calls([
+            mock.call([consts.NFT_CMD, consts.NFT_ADD, 'table',
+                       consts.NFT_FAMILY, consts.NFT_VIP_TABLE], stderr=-2),
+            mock.call([consts.NFT_CMD, consts.NFT_ADD, 'chain',
+                       consts.NFT_FAMILY, consts.NFT_VIP_TABLE,
+                       consts.NFT_VIP_CHAIN, '{', 'type', 'filter', 'hook',
+                       'ingress', 'device', 'fake-eth1', 'priority',
+                       consts.NFT_SRIOV_PRIORITY, ';', 'policy', 'drop', ';',
+                       '}'], stderr=-2),
+            mock.call([consts.NFT_CMD, '-o', '-f', consts.NFT_VIP_RULES_FILE],
+                      stderr=-2),
+            mock.call(["post-up", "fake-eth1"])
+        ])
+
+        mock_nftable.assert_called_once_with('fake-eth1', [])
+
     @mock.patch('pyroute2.IPRoute.rule')
     @mock.patch('pyroute2.IPRoute.route')
     @mock.patch('pyroute2.IPRoute.addr')
@@ -714,7 +859,9 @@ class TestInterface(base.TestCase):
                       table=254,
                       family=socket.AF_INET)])
 
-        mock_check_output.assert_not_called()
+        mock_check_output.assert_has_calls([
+            mock.call(["post-up", "eth1"])
+        ])
 
     @mock.patch('pyroute2.IPRoute.rule')
     @mock.patch('pyroute2.IPRoute.route')
@@ -1297,3 +1444,56 @@ class TestInterface(base.TestCase):
 
         addr = controller._normalize_ip_network(None)
         self.assertIsNone(addr)
+
+    @mock.patch('octavia.amphorae.backends.utils.nftable_utils.'
+                'load_nftables_file')
+    @mock.patch('octavia.amphorae.backends.utils.nftable_utils.'
+                'write_nftable_vip_rules_file')
+    @mock.patch('subprocess.check_output')
+    def test__setup_nftables_chain(self, mock_check_output, mock_write_rules,
+                                   mock_load_rules):
+
+        controller = interface.InterfaceController()
+
+        mock_check_output.side_effect = [
+            mock.DEFAULT, mock.DEFAULT,
+            subprocess.CalledProcessError(cmd=consts.NFT_CMD, returncode=-1),
+            mock.DEFAULT,
+            subprocess.CalledProcessError(cmd=consts.NFT_CMD, returncode=-1)]
+
+        interface_mock = mock.MagicMock()
+        interface_mock.name = 'fake2'
+
+        # Test succeessful path
+        controller._setup_nftables_chain(interface_mock)
+
+        mock_write_rules.assert_called_once_with('fake2', [])
+        mock_load_rules.assert_called_once_with()
+        mock_check_output.assert_has_calls([
+            mock.call([consts.NFT_CMD, 'add', 'table', consts.NFT_FAMILY,
+                       consts.NFT_VIP_TABLE], stderr=subprocess.STDOUT),
+            mock.call([consts.NFT_CMD, 'add', 'chain', consts.NFT_FAMILY,
+                       consts.NFT_VIP_TABLE, consts.NFT_VIP_CHAIN, '{',
+                       'type', 'filter', 'hook', 'ingress', 'device',
+                       'fake2', 'priority', consts.NFT_SRIOV_PRIORITY, ';',
+                       'policy', 'drop', ';', '}'], stderr=subprocess.STDOUT)])
+
+        # Test first nft call fails
+        mock_write_rules.reset_mock()
+        mock_load_rules.reset_mock()
+        mock_check_output.reset_mock()
+
+        self.assertRaises(subprocess.CalledProcessError,
+                          controller._setup_nftables_chain, interface_mock)
+        mock_check_output.assert_called_once()
+        mock_write_rules.assert_not_called()
+
+        # Test second nft call fails
+        mock_write_rules.reset_mock()
+        mock_load_rules.reset_mock()
+        mock_check_output.reset_mock()
+
+        self.assertRaises(subprocess.CalledProcessError,
+                          controller._setup_nftables_chain, interface_mock)
+        self.assertEqual(2, mock_check_output.call_count)
+        mock_write_rules.assert_not_called()

octavia/tests/unit/amphorae/backends/utils/test_keepalivedlvs_query.py

@@ -620,7 +620,7 @@ class LvsQueryTestCase(base.TestCase):
     def test_get_lvs_listener_pool_status_when_not_get_realserver_result(
             self, mock_get_mapping, mock_os_stat):
         # This will hit if the kernel lvs file (/proc/net/ip_vs)
-        # lose its content. So at this moment, eventhough we configure the
+        # lose its content. So at this moment, even though we configure the
         # pool and member into udp keepalived config file, we have to set
         # ths status of pool and its members to DOWN.
         mock_os_stat.side_effect = (

octavia/tests/unit/amphorae/backends/utils/test_nftable_utils.py

@@ -0,0 +1,194 @@
+# Copyright 2024 Red Hat, Inc. All rights reserved.
+#
+# 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 os
+import stat
+import subprocess
+from unittest import mock
+
+from octavia_lib.common import constants as lib_consts
+from webob import exc
+
+from octavia.amphorae.backends.utils import nftable_utils
+from octavia.common import constants as consts
+from octavia.common import exceptions
+import octavia.tests.unit.base as base
+
+
+class TestNFTableUtils(base.TestCase):
+    @mock.patch('os.open')
+    @mock.patch('os.path.isfile')
+    def test_write_nftable_vip_rules_file_exists(self, mock_isfile, mock_open):
+        """Test when a rules file exists and no new rules
+
+        When an existing rules file is present and we call
+        write_nftable_vip_rules_file with no rules, the method should not
+        overwrite the existing rules.
+        """
+        mock_isfile.return_value = True
+
+        nftable_utils.write_nftable_vip_rules_file('fake-eth2', [])
+
+        mock_open.assert_not_called()
+
+    @mock.patch('os.open')
+    @mock.patch('os.path.isfile')
+    def test_write_nftable_vip_rules_file_rules(self, mock_isfile,
+                                                mock_open):
+        """Test when a rules file exists and rules are passed in
+
+        This should create a simple rules file with the base chain and rules.
+        """
+        mock_isfile.return_value = True
+        mock_open.return_value = 'fake-fd'
+
+        test_rule_1 = {consts.CIDR: None,
+                       consts.PROTOCOL: lib_consts.PROTOCOL_TCP,
+                       consts.PORT: 1234}
+        test_rule_2 = {consts.CIDR: '192.0.2.0/24',
+                       consts.PROTOCOL: consts.VRRP,
+                       consts.PORT: 4321}
+
+        mocked_open = mock.mock_open()
+        with mock.patch.object(os, 'fdopen', mocked_open):
+            nftable_utils.write_nftable_vip_rules_file(
+                'fake-eth2', [test_rule_1, test_rule_2])
+
+        mocked_open.assert_called_once_with('fake-fd', 'w')
+        mock_open.assert_called_once_with(
+            consts.NFT_VIP_RULES_FILE,
+            (os.O_WRONLY | os.O_CREAT | os.O_TRUNC),
+            (stat.S_IRUSR | stat.S_IWUSR))
+
+        handle = mocked_open()
+        handle.write.assert_has_calls([
+            mock.call(f'table {consts.NFT_FAMILY} {consts.NFT_VIP_TABLE} '
+                      '{}\n'),
+            mock.call(f'delete table {consts.NFT_FAMILY} '
+                      f'{consts.NFT_VIP_TABLE}\n'),
+            mock.call(f'table {consts.NFT_FAMILY} {consts.NFT_VIP_TABLE} '
+                      '{\n'),
+            mock.call(f'  chain {consts.NFT_VIP_CHAIN} {{\n'),
+            mock.call('    type filter hook ingress device fake-eth2 '
+                      f'priority {consts.NFT_SRIOV_PRIORITY}; policy drop;\n'),
+            mock.call('      icmp type destination-unreachable accept\n'),
+            mock.call('      icmpv6 type { nd-neighbor-solicit, '
+                      'nd-router-advert, nd-neighbor-advert, packet-too-big, '
+                      'destination-unreachable } accept\n'),
+            mock.call('      udp sport 67 udp dport 68 accept\n'),
+            mock.call('      udp sport 547 udp dport 546 accept\n'),
+            mock.call('      tcp dport 1234 accept\n'),
+            mock.call('      ip saddr 192.0.2.0/24 ip protocol 112 accept\n'),
+            mock.call('  }\n'),
+            mock.call('}\n')
+        ])
+
+    @mock.patch('os.open')
+    @mock.patch('os.path.isfile')
+    def test_write_nftable_vip_rules_file_missing(self, mock_isfile,
+                                                  mock_open):
+        """Test when a rules file does not exist and no new rules
+
+        This should create a simple rules file with the base chain.
+        """
+        mock_isfile.return_value = False
+        mock_open.return_value = 'fake-fd'
+
+        mocked_open = mock.mock_open()
+        with mock.patch.object(os, 'fdopen', mocked_open):
+            nftable_utils.write_nftable_vip_rules_file('fake-eth2', [])
+
+        mocked_open.assert_called_once_with('fake-fd', 'w')
+        mock_open.assert_called_once_with(
+            consts.NFT_VIP_RULES_FILE,
+            (os.O_WRONLY | os.O_CREAT | os.O_TRUNC),
+            (stat.S_IRUSR | stat.S_IWUSR))
+
+        handle = mocked_open()
+        handle.write.assert_has_calls([
+            mock.call(f'table {consts.NFT_FAMILY} {consts.NFT_VIP_TABLE} '
+                      '{\n'),
+            mock.call(f'  chain {consts.NFT_VIP_CHAIN} {{\n'),
+            mock.call('    type filter hook ingress device fake-eth2 '
+                      f'priority {consts.NFT_SRIOV_PRIORITY}; policy drop;\n'),
+            mock.call('      icmp type destination-unreachable accept\n'),
+            mock.call('      icmpv6 type { nd-neighbor-solicit, '
+                      'nd-router-advert, nd-neighbor-advert, packet-too-big, '
+                      'destination-unreachable } accept\n'),
+            mock.call('      udp sport 67 udp dport 68 accept\n'),
+            mock.call('      udp sport 547 udp dport 546 accept\n'),
+            mock.call('  }\n'),
+            mock.call('}\n')
+        ])
+
+    @mock.patch('octavia.common.utils.ip_version')
+    def test__build_rule_cmd(self, mock_ip_version):
+
+        mock_ip_version.side_effect = [4, 6, 99]
+
+        cmd = nftable_utils._build_rule_cmd({
+            consts.CIDR: '192.0.2.0/24',
+            consts.PROTOCOL: lib_consts.PROTOCOL_SCTP,
+            consts.PORT: 1234})
+        self.assertEqual('ip saddr 192.0.2.0/24 sctp dport 1234 accept', cmd)
+
+        cmd = nftable_utils._build_rule_cmd({
+            consts.CIDR: '2001:db8::/32',
+            consts.PROTOCOL: lib_consts.PROTOCOL_TCP,
+            consts.PORT: 1235})
+        self.assertEqual('ip6 saddr 2001:db8::/32 tcp dport 1235 accept', cmd)
+
+        self.assertRaises(exc.HTTPBadRequest, nftable_utils._build_rule_cmd,
+                          {consts.CIDR: '192/32',
+                           consts.PROTOCOL: lib_consts.PROTOCOL_TCP,
+                           consts.PORT: 1237})
+
+        cmd = nftable_utils._build_rule_cmd({
+            consts.CIDR: None,
+            consts.PROTOCOL: lib_consts.PROTOCOL_UDP,
+            consts.PORT: 1236})
+        self.assertEqual('udp dport 1236 accept', cmd)
+
+        cmd = nftable_utils._build_rule_cmd({
+            consts.CIDR: None,
+            consts.PROTOCOL: consts.VRRP,
+            consts.PORT: 1237})
+        self.assertEqual('ip protocol 112 accept', cmd)
+
+        self.assertRaises(exc.HTTPBadRequest, nftable_utils._build_rule_cmd,
+                          {consts.CIDR: None,
+                           consts.PROTOCOL: 'bad-protocol',
+                           consts.PORT: 1237})
+
+    @mock.patch('octavia.amphorae.backends.utils.network_namespace.'
+                'NetworkNamespace')
+    @mock.patch('subprocess.check_output')
+    def test_load_nftables_file(self, mock_check_output, mock_netns):
+
+        mock_netns.side_effect = [
+            mock.DEFAULT,
+            subprocess.CalledProcessError(cmd=consts.NFT_CMD, returncode=-1),
+            exceptions.AmphoraNetworkConfigException]
+
+        nftable_utils.load_nftables_file()
+
+        mock_netns.assert_called_once_with(consts.AMPHORA_NAMESPACE)
+        mock_check_output.assert_called_once_with([
+            consts.NFT_CMD, '-o', '-f', consts.NFT_VIP_RULES_FILE],
+            stderr=subprocess.STDOUT)
+
+        self.assertRaises(subprocess.CalledProcessError,
+                          nftable_utils.load_nftables_file)
+
+        self.assertRaises(exceptions.AmphoraNetworkConfigException,
+                          nftable_utils.load_nftables_file)

octavia/tests/unit/amphorae/drivers/haproxy/test_rest_api_driver.py

@@ -13,7 +13,7 @@
 # under the License.
 from unittest import mock
 
-from octavia.amphorae.driver_exceptions.exceptions import AmpVersionUnsupported
+from octavia.amphorae.driver_exceptions import exceptions as driver_except
 from octavia.amphorae.drivers.haproxy import exceptions as exc
 from octavia.amphorae.drivers.haproxy import rest_api_driver
 import octavia.tests.unit.base as base
@@ -76,9 +76,9 @@ class TestHAProxyAmphoraDriver(base.TestCase):
         mock_api_version.reset_mock()
         client_mock.reset_mock()
 
-        result = self.driver.get_interface_from_ip(amphora_mock, IP_ADDRESS)
-
-        self.assertIsNone(result)
+        self.assertRaises(
+            exc.NotFound,
+            self.driver.get_interface_from_ip, amphora_mock, IP_ADDRESS)
         mock_api_version.assert_called_once_with(amphora_mock, None)
         client_mock.get_interface.assert_called_once_with(
             amphora_mock, IP_ADDRESS, None, log_error=False)
@@ -87,6 +87,28 @@ class TestHAProxyAmphoraDriver(base.TestCase):
         mock_amp = mock.MagicMock()
         mock_amp.api_version = "0.5"
 
-        self.assertRaises(AmpVersionUnsupported,
+        self.assertRaises(driver_except.AmpVersionUnsupported,
                           self.driver._populate_amphora_api_version,
                           mock_amp)
+
+    @mock.patch('octavia.amphorae.drivers.haproxy.rest_api_driver.'
+                'HaproxyAmphoraLoadBalancerDriver.'
+                '_populate_amphora_api_version')
+    def test_set_interface_rules(self, mock_api_version):
+
+        IP_ADDRESS = '203.0.113.44'
+        amphora_mock = mock.MagicMock()
+        amphora_mock.api_version = '0'
+        client_mock = mock.MagicMock()
+        client_mock.set_interface_rules.side_effect = [mock.DEFAULT,
+                                                       exc.NotFound]
+        self.driver.clients['0'] = client_mock
+
+        self.driver.set_interface_rules(amphora_mock, IP_ADDRESS, 'fake_rules')
+        mock_api_version.assert_called_once_with(amphora_mock, None)
+        client_mock.set_interface_rules.assert_called_once_with(
+            amphora_mock, IP_ADDRESS, 'fake_rules', timeout_dict=None)
+
+        self.assertRaises(driver_except.AmpDriverNotImplementedError,
+                          self.driver.set_interface_rules, amphora_mock,
+                          IP_ADDRESS, 'fake_rules')

octavia/tests/unit/amphorae/drivers/haproxy/test_rest_api_driver_1_0.py

@@ -113,7 +113,8 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
                             'vrrp_ip': self.amp.vrrp_ip,
                             'mtu': FAKE_MTU,
                             'host_routes': host_routes_data,
-                            'additional_vips': []}
+                            'additional_vips': [],
+                            'is_sriov': False}
 
         self.timeout_dict = {constants.REQ_CONN_TIMEOUT: 1,
                              constants.REQ_READ_TIMEOUT: 2,
@@ -766,6 +767,7 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
                 'host_routes': netinfo['host_routes']
             }
         ]
+        netinfo['is_sriov'] = False
         self.driver.clients[API_VERSION].plug_vip.assert_called_once_with(
             self.amp, self.lb.vip.ip_address, netinfo)
 
@@ -815,7 +817,8 @@ class TestHaproxyAmphoraLoadBalancerDriverTest(base.TestCase):
                                vrrp_ip=self.amp.vrrp_ip,
                                host_routes=[],
                                additional_vips=[],
-                               mtu=FAKE_MTU
+                               mtu=FAKE_MTU,
+                               is_sriov=False
                            )))
 
     def test_post_network_plug_with_host_routes(self):
@@ -1545,3 +1548,13 @@ class TestAmphoraAPIClientTest(base.TestCase):
         self.assertRaises(exc.InternalServerError,
                           self.driver.update_agent_config, self.amp,
                           "some_file")
+
+    @requests_mock.mock()
+    def test_set_interface_rules(self, m):
+        ip_addr = '192.0.2.44'
+        rules = ('[{"protocol":"TCP","cidr":"192.0.2.0/24","port":8080},'
+                 '{"protocol":"UDP","cidr":null,"port":80}]')
+        m.put(f'{self.base_url_ver}/interface/{ip_addr}/rules')
+
+        self.driver.set_interface_rules(self.amp, ip_addr, rules)
+        self.assertTrue(m.called)

octavia/tests/unit/amphorae/drivers/keepalived/test_vrrp_rest_driver.py

@@ -107,6 +107,9 @@ class TestVRRPRestDriver(base.TestCase):
 
         self.keepalived_mixin.start_vrrp_service(self.amphora_mock)
 
+        populate_mock = self.keepalived_mixin._populate_amphora_api_version
+        populate_mock.assert_called_once_with(self.amphora_mock,
+                                              timeout_dict=None)
         self.clients[API_VERSION].start_vrrp.assert_called_once_with(
             self.amphora_mock, timeout_dict=None)
 
@@ -121,6 +124,20 @@ class TestVRRPRestDriver(base.TestCase):
 
         self.clients[API_VERSION].start_vrrp.assert_not_called()
 
+        # With timeout_dict
+        self.clients[API_VERSION].start_vrrp.reset_mock()
+        populate_mock.reset_mock()
+
+        timeout_dict = mock.Mock()
+        self.keepalived_mixin.start_vrrp_service(self.amphora_mock,
+                                                 timeout_dict=timeout_dict)
+
+        populate_mock = self.keepalived_mixin._populate_amphora_api_version
+        populate_mock.assert_called_once_with(self.amphora_mock,
+                                              timeout_dict=timeout_dict)
+        self.clients[API_VERSION].start_vrrp.assert_called_once_with(
+            self.amphora_mock, timeout_dict=timeout_dict)
+
     def test_reload_vrrp_service(self):
 
         self.keepalived_mixin.reload_vrrp_service(self.lb_mock)

octavia/tests/unit/amphorae/drivers/noop_driver/test_driver.py

@@ -57,7 +57,8 @@ class TestNoopAmphoraLoadBalancerDriver(base.TestCase):
                              constants.CONN_MAX_RETRIES: 3,
                              constants.CONN_RETRY_INTERVAL: 4}
 
-    def test_update_amphora_listeners(self):
+    @mock.patch('octavia.db.api.get_session')
+    def test_update_amphora_listeners(self, mock_session):
         self.driver.update_amphora_listeners(self.load_balancer, self.amphora,
                                              self.timeout_dict)
         self.assertEqual((self.listener, self.amphora.id, self.timeout_dict,

octavia/tests/unit/api/v2/types/test_pool.py

@@ -17,8 +17,12 @@ from wsme import exc
 from wsme.rest import json as wsme_json
 from wsme import types as wsme_types
 
+from octavia.api.common import types
+from octavia.api.v2.types import health_monitor as health_monitor_type
+from octavia.api.v2.types import member as member_type
 from octavia.api.v2.types import pool as pool_type
 from octavia.common import constants
+from octavia.common import data_models
 from octavia.tests.unit.api.common import base
 
 
@@ -224,3 +228,70 @@ class TestSessionPersistencePUT(base.BaseTypesTest, TestSessionPersistence):
         body = {"cookie_name": "cookie\nmonster"}
         self.assertRaises(exc.InvalidInput, wsme_json.fromjson, self._type,
                           body)
+
+
+class TestPoolResponse(base.BaseTypesTest):
+
+    _type = pool_type.PoolResponse
+
+    def test_pool_response_with_health_monitor(self):
+        health_monitor_id = uuidutils.generate_uuid()
+        health_monitor_model = data_models.HealthMonitor(id=health_monitor_id)
+        pool_model = data_models.Pool(health_monitor=health_monitor_model)
+        pool = self._type.from_data_model(data_model=pool_model)
+        self.assertEqual(pool.healthmonitor_id, health_monitor_id)
+
+    def test_pool_response_with_members(self):
+        member_id = uuidutils.generate_uuid()
+        members = [data_models.Member(id=member_id)]
+        pool_model = data_models.Pool(members=members)
+        pool = self._type.from_data_model(data_model=pool_model)
+        self.assertIsInstance(pool.members[0], types.IdOnlyType)
+        self.assertEqual(pool.members[0].id, member_id)
+
+    def test_pool_response_with_load_balancer(self):
+        load_balancer_id = uuidutils.generate_uuid()
+        load_balancer = data_models.LoadBalancer(id=load_balancer_id)
+        pool_model = data_models.Pool(load_balancer=load_balancer)
+        pool = self._type.from_data_model(data_model=pool_model)
+        self.assertIsInstance(pool.loadbalancers[0], types.IdOnlyType)
+        self.assertEqual(pool.loadbalancers[0].id, load_balancer_id)
+
+    def test_pool_response_with_session_persistence(self):
+        session_persistence = data_models.SessionPersistence(
+            cookie_name="test"
+        )
+        pool_model = data_models.Pool(session_persistence=session_persistence)
+        pool = self._type.from_data_model(data_model=pool_model)
+        self.assertEqual(pool.session_persistence.cookie_name, "test")
+
+    def test_pool_response_without_children(self):
+        pool = self._type.from_data_model(data_model=data_models.Pool())
+        self.assertEqual(len(pool.loadbalancers), 0)
+        self.assertIsNone(pool.session_persistence)
+        self.assertEqual(len(pool.members), 0)
+        self.assertEqual(len(pool.listeners), 0)
+        self.assertEqual(pool.healthmonitor_id, wsme_types.Unset)
+
+
+class TestPoolFullResponse(base.BaseTypesTest):
+
+    _type = pool_type.PoolFullResponse
+
+    def test_pool_full_response_with_health_monitor(self):
+        health_monitor_model = data_models.HealthMonitor()
+        pool_model = data_models.Pool(health_monitor=health_monitor_model)
+        pool = self._type.from_data_model(data_model=pool_model)
+        self.assertIsInstance(
+            pool.healthmonitor, health_monitor_type.HealthMonitorFullResponse
+        )
+
+    def test_pool_full_response_with_members(self):
+        members = [data_models.Member()]
+        pool_model = data_models.Pool(members=members)
+        pool = self._type.from_data_model(data_model=pool_model)
+        self.assertIsInstance(pool.members[0], member_type.MemberFullResponse)
+
+    def test_pool_full_response_without_children(self):
+        pool = self._type.from_data_model(data_model=data_models.Pool())
+        self.assertIsNone(pool.healthmonitor)