octavia 13.0.0__py3-none-any.whl → 14.0.0__py3-none-any.whl

octavia/tests/unit/certificates/manager/test_barbican.py

@@ -15,7 +15,6 @@ from unittest import mock
 import uuid
 
 from barbicanclient.v1 import secrets
-from OpenSSL import crypto
 
 import octavia.certificates.common.barbican as barbican_common
 import octavia.certificates.common.cert as cert
@@ -138,10 +137,11 @@ class TestBarbicanManager(base.TestCase):
                          sorted(data.get_intermediates()))
         self.assertIsNone(data.get_private_key_passphrase())
 
-    @mock.patch('OpenSSL.crypto.load_pkcs12')
+    @mock.patch('cryptography.hazmat.primitives.serialization.pkcs12.'
+                'load_pkcs12')
     def test_get_cert_bad_pkcs12(self, mock_load_pkcs12):
 
-        mock_load_pkcs12.side_effect = [crypto.Error]
+        mock_load_pkcs12.side_effect = [ValueError]
 
         # Mock out the client
         self.bc.secrets.get.return_value = self.secret_pkcs12

octavia/tests/unit/certificates/manager/test_noop.py

@@ -0,0 +1,53 @@
+# Copyright 2023 Red Hat
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from oslo_utils import uuidutils
+
+from octavia.certificates.common import cert
+from octavia.certificates.manager import noop as noop_cert_mgr
+from octavia.tests.common import sample_certs
+import octavia.tests.unit.base as base
+
+
+class TestNoopManager(base.TestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.manager = noop_cert_mgr.NoopCertManager()
+
+    def test_store_cert(self):
+        certificate = self.manager.store_cert(
+            None,
+            sample_certs.X509_CERT,
+            sample_certs.X509_CERT_KEY_ENCRYPTED,
+            sample_certs.X509_IMDS,
+            private_key_passphrase=sample_certs.X509_CERT_KEY_PASSPHRASE)
+        self.assertIsNotNone(certificate)
+        self.assertIsInstance(certificate, cert.Cert)
+
+    def test_get_cert(self):
+        cert_ref = uuidutils.generate_uuid()
+        certificate = self.manager.get_cert(
+            context=None,
+            cert_ref=cert_ref)
+        self.assertIsNotNone(certificate)
+        self.assertIsInstance(certificate, cert.Cert)
+
+    def test_get_secret(self):
+        secret_ref = uuidutils.generate_uuid()
+        secret = self.manager.get_secret(
+            context=None,
+            secret_ref=secret_ref)
+        self.assertIsNotNone(secret)
+        self.assertIsInstance(secret, cert.Cert)

octavia/tests/unit/common/jinja/haproxy/combined_listeners/test_jinja_cfg.py

@@ -813,7 +813,6 @@ class TestHaproxyCfg(base.TestCase):
               "    balance roundrobin\n"
               "    cookie SRV insert indirect nocache\n"
               "    timeout check 31s\n"
-              "    option ssl-hello-chk\n"
               "    fullconn {maxconn}\n"
               "    option allbackups\n"
               "    timeout connect 5000\n"
@@ -1331,11 +1330,11 @@ class TestHaproxyCfg(base.TestCase):
               "    timeout connect 5000\n"
               "    timeout server 50000\n"
               "    server sample_member_id_1 10.0.0.99:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_1 "
-              "{opts} alpn {alpn}\n"
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_1 {opts} alpn {alpn}\n"
               "    server sample_member_id_2 10.0.0.98:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_2 "
-              "{opts} alpn {alpn}\n\n").format(
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_2 {opts} alpn {alpn}\n\n").format(
             maxconn=constants.HAPROXY_DEFAULT_MAXCONN,
             opts="ssl crt %s verify none sni ssl_fc_sni" % cert_file_path +
                  " ciphers " + constants.CIPHERS_OWASP_SUITE_B +
@@ -1410,11 +1409,11 @@ class TestHaproxyCfg(base.TestCase):
               "    timeout connect 5000\n"
               "    timeout server 50000\n"
               "    server sample_member_id_1 10.0.0.99:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_1 "
-              "{opts} alpn {alpn}\n"
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_1 {opts} alpn {alpn}\n"
               "    server sample_member_id_2 10.0.0.98:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_2 "
-              "{opts} alpn {alpn}\n\n").format(
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_2 {opts} alpn {alpn}\n\n").format(
             maxconn=constants.HAPROXY_DEFAULT_MAXCONN,
             opts="ssl crt %s verify none sni ssl_fc_sni" % cert_file_path +
                  " ciphers " + constants.CIPHERS_OWASP_SUITE_B,
@@ -1450,11 +1449,11 @@ class TestHaproxyCfg(base.TestCase):
               "    timeout connect 5000\n"
               "    timeout server 50000\n"
               "    server sample_member_id_1 10.0.0.99:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_1 "
-              "{opts} alpn {alpn}\n"
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_1 {opts} alpn {alpn}\n"
               "    server sample_member_id_2 10.0.0.98:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_2 "
-              "{opts} alpn {alpn}\n\n").format(
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_2 {opts} alpn {alpn}\n\n").format(
             maxconn=constants.HAPROXY_DEFAULT_MAXCONN,
             opts="ssl crt %s verify none sni ssl_fc_sni" % cert_file_path +
                  " no-sslv3 no-tlsv10 no-tlsv11",
@@ -1550,11 +1549,11 @@ class TestHaproxyCfg(base.TestCase):
               "    timeout connect 5000\n"
               "    timeout server 50000\n"
               "    server sample_member_id_1 10.0.0.99:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_1 "
-              "{opts} alpn {alpn}\n"
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_1 {opts} alpn {alpn}\n"
               "    server sample_member_id_2 10.0.0.98:82 weight 13 "
-              "check inter 30s fall 3 rise 2 cookie sample_member_id_2 "
-              "{opts} alpn {alpn}\n\n").format(
+              "check check-alpn {alpn} inter 30s fall 3 rise 2 cookie "
+              "sample_member_id_2 {opts} alpn {alpn}\n\n").format(
             maxconn=constants.HAPROXY_DEFAULT_MAXCONN,
             opts="%s %s %s %s %s %s" % (
                 "ssl", "crt", pool_client_cert,

octavia/tests/unit/common/sample_configs/sample_configs_combined.py

@@ -670,9 +670,11 @@ def sample_vrrp_group_tuple():
         smtp_connect_timeout='')
 
 
-def sample_vip_tuple(ip_address='10.0.0.2', subnet_id='vip_subnet_uuid'):
-    vip = collections.namedtuple('vip', ('ip_address', 'subnet_id'))
-    return vip(ip_address=ip_address, subnet_id=subnet_id)
+def sample_vip_tuple(ip_address='10.0.0.2', subnet_id='vip_subnet_uuid',
+                     vnic_type='normal'):
+    vip = collections.namedtuple('vip', ('ip_address', 'subnet_id',
+                                         'vnic_type'))
+    return vip(ip_address=ip_address, subnet_id=subnet_id, vnic_type=vnic_type)
 
 
 def sample_listener_tuple(proto=None, monitor=True, alloc_default_pool=True,

octavia/tests/unit/common/test_config.py

@@ -78,3 +78,38 @@ class TestConfig(base.TestCase):
         self.assertEqual(
             3,
             conf.conf.haproxy_amphora.active_connection_retry_interval)
+
+    def test_handle_neutron_deprecations(self):
+        conf = self.useFixture(oslo_fixture.Config(config.cfg.CONF))
+
+        # The deprecated settings are copied to the new settings
+        conf.config(endpoint='my_endpoint',
+                    endpoint_type='internal',
+                    ca_certificates_file='/path/to/certs',
+                    group='neutron')
+
+        config.handle_neutron_deprecations()
+
+        self.assertEqual('my_endpoint', conf.conf.neutron.endpoint_override)
+        self.assertEqual(['internal'], conf.conf.neutron.valid_interfaces)
+        self.assertEqual('/path/to/certs', conf.conf.neutron.cafile)
+
+    # Test case for https://bugs.launchpad.net/octavia/+bug/2051604
+    def test_handle_neutron_deprecations_with_precedence(self):
+        conf = self.useFixture(oslo_fixture.Config(config.cfg.CONF))
+
+        # The deprecated settings should not override the new settings when
+        # they exist
+        conf.config(endpoint='my_old_endpoint',
+                    endpoint_type='old_type',
+                    ca_certificates_file='/path/to/old_certs',
+                    endpoint_override='my_endpoint',
+                    valid_interfaces=['internal'],
+                    cafile='/path/to/certs',
+                    group='neutron')
+
+        config.handle_neutron_deprecations()
+
+        self.assertEqual('my_endpoint', conf.conf.neutron.endpoint_override)
+        self.assertEqual(['internal'], conf.conf.neutron.valid_interfaces)
+        self.assertEqual('/path/to/certs', conf.conf.neutron.cafile)

octavia/tests/unit/common/test_keystone.py

@@ -52,3 +52,35 @@ class TestKeystoneSession(base.TestCase):
             [call("Overriding [%s].%s with '%s'", 'neutron', 'cafile',
                   'bar')]
         )
+
+    # Test case for https://bugs.launchpad.net/octavia/+bug/2051604
+    @mock.patch("octavia.common.keystone.ks_loading"
+                ".load_auth_from_conf_options")
+    @mock.patch("octavia.common.keystone.LOG")
+    def test_get_auth_neutron_override_endpoint(self,
+                                                mock_log,
+                                                mock_load_auth):
+        opt_mock = mock.MagicMock()
+        opt_mock.dest = "foo"
+        conf = oslo_fixture.Config(cfg.CONF)
+        conf.conf.set_default('endpoint_override', 'default_endpoint',
+                              'service_auth')
+        conf.conf.set_default('endpoint_override', 'new_endpoint',
+                              'neutron')
+
+        mock_load_auth.side_effect = [
+            ks_exceptions.auth_plugins.MissingRequiredOptions(
+                [opt_mock]),
+            None,
+            None
+        ]
+
+        sess = ks.KeystoneSession("neutron")
+        sess.get_auth()
+
+        # [service_auth].endpoint_override should not override
+        # [neutron].endpoint_override
+        self.assertNotIn(
+            call("Overriding [%s].%s with '%s'", 'neutron',
+                 'endpoint_override', 'default_endpoint'),
+            mock_log.debug.mock_calls)

octavia/tests/unit/common/test_utils.py

@@ -13,6 +13,7 @@
 #    under the License.
 from unittest import mock
 
+from octavia_lib.common import constants as lib_consts
 from oslo_utils import uuidutils
 
 from octavia.common import constants
@@ -139,3 +140,41 @@ class TestConfig(base.TestCase):
         expected_sg_name = constants.VIP_SECURITY_GROUP_PREFIX + FAKE_LB_ID
         self.assertEqual(expected_sg_name,
                          utils.get_vip_security_group_name(FAKE_LB_ID))
+
+    def test_map_protocol_to_nftable_protocol(self):
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_TCP})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_HTTP})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_HTTPS})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_TERMINATED_HTTPS})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_PROXY})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_PROXYV2})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_UDP})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_UDP}, result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_SCTP})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_SCTP},
+                         result)
+
+        result = utils.map_protocol_to_nftable_protocol(
+            {constants.PROTOCOL: lib_consts.PROTOCOL_PROMETHEUS})
+        self.assertEqual({constants.PROTOCOL: lib_consts.PROTOCOL_TCP}, result)

octavia/tests/unit/compute/drivers/test_nova_driver.py

@@ -457,6 +457,28 @@ class TestNovaClient(base.TestCase):
                           self.manager.attach_network_or_port,
                           self.compute_id, self.network_id)
 
+    def test_attach_network_or_port_fail_claim_pci_exception(self):
+        self.manager.manager.interface_attach.side_effect = [
+            nova_exceptions.BadRequest('Failed to claim PCI device'),
+            nova_exceptions.BadRequest('NotAClaimFailure')]
+        self.assertRaises(exceptions.ComputeNoResourcesException,
+                          self.manager.attach_network_or_port,
+                          self.compute_id, self.network_id)
+        self.assertRaises(nova_exceptions.BadRequest,
+                          self.manager.attach_network_or_port,
+                          self.compute_id, self.network_id)
+
+    def test_attach_network_or_port_port_bind_fail_exception(self):
+        self.manager.manager.interface_attach.side_effect = [
+            nova_exceptions.ClientException('PortBindingFailed'),
+            nova_exceptions.ClientException('NotABindFailure')]
+        self.assertRaises(exceptions.ComputeNoResourcesException,
+                          self.manager.attach_network_or_port,
+                          self.compute_id, self.network_id)
+        self.assertRaises(nova_exceptions.ClientException,
+                          self.manager.attach_network_or_port,
+                          self.compute_id, self.network_id)
+
     def test_attach_network_or_port_unknown_exception(self):
         self.manager.manager.interface_attach.side_effect = [Exception('boom')]
         self.assertRaises(exceptions.ComputeUnknownException,

octavia/tests/unit/controller/worker/test_task_utils.py

@@ -14,6 +14,7 @@
 from unittest import mock
 
 from oslo_utils import uuidutils
+import tenacity
 
 from octavia.common import constants
 from octavia.controller.worker import task_utils as task_utilities
@@ -183,7 +184,13 @@ class TestTaskUtils(base.TestCase):
 
     @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.update')
+    @mock.patch('tenacity.nap.time')
+    # mock LOG so we don't fill the console with log messages from
+    # tenacity.retry
+    @mock.patch('octavia.controller.worker.task_utils.LOG')
     def test_mark_loadbalancer_prov_status_active(self,
+                                                  mock_LOG,
+                                                  mock_time,
                                                   mock_lb_repo_update,
                                                   mock_get_session):
 
@@ -202,14 +209,42 @@ class TestTaskUtils(base.TestCase):
         mock_lb_repo_update.reset_mock()
         mock_get_session.side_effect = Exception('fail')
 
-        self.task_utils.mark_loadbalancer_prov_status_active(
+        self.assertRaises(
+            tenacity.RetryError,
+            self.task_utils.mark_loadbalancer_prov_status_active,
             self.LOADBALANCER_ID)
 
         self.assertFalse(mock_lb_repo_update.called)
 
+        # Exceptions then happy path
+        mock_get_session.reset_mock(side_effect=True)
+        mock_lb_repo_update.reset_mock()
+
+        mock_session = mock_get_session()
+        mock_session_context = mock_session.begin().__enter__()
+        mock_get_session.side_effect = [
+            Exception('fail'),
+            Exception('fail'),
+            Exception('fail'),
+            mock_session]
+
+        self.task_utils.mark_loadbalancer_prov_status_active(
+            self.LOADBALANCER_ID)
+
+        mock_lb_repo_update.assert_called_once_with(
+            mock_session_context,
+            id=self.LOADBALANCER_ID,
+            provisioning_status=constants.ACTIVE)
+
     @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.LoadBalancerRepository.update')
+    @mock.patch('tenacity.nap.time')
+    # mock LOG so we don't fill the console with log messages from
+    # tenacity.retry
+    @mock.patch('octavia.controller.worker.task_utils.LOG')
     def test_mark_loadbalancer_prov_status_error(self,
+                                                 mock_LOG,
+                                                 mock_time,
                                                  mock_lb_repo_update,
                                                  mock_get_session):
 
@@ -228,10 +263,31 @@ class TestTaskUtils(base.TestCase):
         mock_lb_repo_update.reset_mock()
         mock_get_session.side_effect = Exception('fail')
 
+        self.assertRaises(tenacity.RetryError,
+                          self.task_utils.mark_loadbalancer_prov_status_error,
+                          self.LOADBALANCER_ID)
+
+        self.assertFalse(mock_lb_repo_update.called)
+
+        # Exceptions then happy path
+        mock_get_session.reset_mock(side_effect=True)
+        mock_lb_repo_update.reset_mock()
+
+        mock_session = mock_get_session()
+        mock_session_context = mock_session.begin().__enter__()
+        mock_get_session.side_effect = [
+            Exception('fail'),
+            Exception('fail'),
+            Exception('fail'),
+            mock_session]
+
         self.task_utils.mark_loadbalancer_prov_status_error(
             self.LOADBALANCER_ID)
 
-        self.assertFalse(mock_lb_repo_update.called)
+        mock_lb_repo_update.assert_called_once_with(
+            mock_session_context,
+            id=self.LOADBALANCER_ID,
+            provisioning_status=constants.ERROR)
 
     @mock.patch('octavia.db.api.session')
     @mock.patch('octavia.db.repositories.MemberRepository.update')

octavia/tests/unit/controller/worker/v2/flows/test_amphora_flows.py

@@ -286,6 +286,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.AMPHORA, amp_flow.provides)
         self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.BASE_PORT, amp_flow.provides)
         self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@@ -296,7 +297,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.VIP_SG_ID, amp_flow.provides)
 
         self.assertEqual(8, len(amp_flow.requires))
-        self.assertEqual(13, len(amp_flow.provides))
+        self.assertEqual(14, len(amp_flow.provides))
 
     def test_get_failover_flow_standalone(self, mock_get_net_driver):
         failed_amphora = data_models.Amphora(
@@ -320,6 +321,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.AMPHORA, amp_flow.provides)
         self.assertIn(constants.AMPHORA_ID, amp_flow.provides)
         self.assertIn(constants.AMPHORAE, amp_flow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, amp_flow.provides)
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, amp_flow.provides)
         self.assertIn(constants.BASE_PORT, amp_flow.provides)
         self.assertIn(constants.COMPUTE_ID, amp_flow.provides)
@@ -330,7 +332,7 @@ class TestAmphoraFlows(base.TestCase):
         self.assertIn(constants.VIP_SG_ID, amp_flow.provides)
 
         self.assertEqual(8, len(amp_flow.requires))
-        self.assertEqual(12, len(amp_flow.provides))
+        self.assertEqual(13, len(amp_flow.provides))
 
     def test_get_failover_flow_bogus_role(self, mock_get_net_driver):
         failed_amphora = data_models.Amphora(id=uuidutils.generate_uuid(),
@@ -366,14 +368,33 @@ class TestAmphoraFlows(base.TestCase):
 
         self.assertIsInstance(vrrp_subflow, flow.Flow)
 
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, vrrp_subflow.provides)
+        self.assertIn(constants.AMP_VRRP_INT, vrrp_subflow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, vrrp_subflow.provides)
+
+        self.assertIn(constants.LOADBALANCER_ID, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORAE, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORA_ID, vrrp_subflow.requires)
+
+        self.assertEqual(3, len(vrrp_subflow.provides))
+        self.assertEqual(3, len(vrrp_subflow.requires))
+
+    def test_get_vrrp_subflow_dont_get_status(self, mock_get_net_driver):
+        vrrp_subflow = self.AmpFlow.get_vrrp_subflow('123',
+                                                     get_amphorae_status=False)
+
+        self.assertIsInstance(vrrp_subflow, flow.Flow)
+
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, vrrp_subflow.provides)
         self.assertIn(constants.AMP_VRRP_INT, vrrp_subflow.provides)
 
         self.assertIn(constants.LOADBALANCER_ID, vrrp_subflow.requires)
         self.assertIn(constants.AMPHORAE, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORA_ID, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, vrrp_subflow.requires)
 
         self.assertEqual(2, len(vrrp_subflow.provides))
-        self.assertEqual(2, len(vrrp_subflow.requires))
+        self.assertEqual(4, len(vrrp_subflow.requires))
 
     def test_get_vrrp_subflow_dont_create_vrrp_group(
             self, mock_get_net_driver):
@@ -384,12 +405,14 @@ class TestAmphoraFlows(base.TestCase):
 
         self.assertIn(constants.AMPHORAE_NETWORK_CONFIG, vrrp_subflow.provides)
         self.assertIn(constants.AMP_VRRP_INT, vrrp_subflow.provides)
+        self.assertIn(constants.AMPHORAE_STATUS, vrrp_subflow.provides)
 
         self.assertIn(constants.LOADBALANCER_ID, vrrp_subflow.requires)
         self.assertIn(constants.AMPHORAE, vrrp_subflow.requires)
+        self.assertIn(constants.AMPHORA_ID, vrrp_subflow.requires)
 
-        self.assertEqual(2, len(vrrp_subflow.provides))
-        self.assertEqual(2, len(vrrp_subflow.requires))
+        self.assertEqual(3, len(vrrp_subflow.provides))
+        self.assertEqual(3, len(vrrp_subflow.requires))
 
     def test_update_amphora_config_flow(self, mock_get_net_driver):
 

octavia/tests/unit/controller/worker/v2/flows/test_listener_flows.py

@@ -34,45 +34,77 @@ class TestListenerFlows(base.TestCase):
 
     def test_get_create_listener_flow(self, mock_get_net_driver):
 
-        listener_flow = self.ListenerFlow.get_create_listener_flow()
+        flavor_dict = {
+            constants.SRIOV_VIP: True,
+            constants.LOADBALANCER_TOPOLOGY: constants.TOPOLOGY_SINGLE}
+        listener_flow = self.ListenerFlow.get_create_listener_flow(
+            flavor_dict=flavor_dict)
 
         self.assertIsInstance(listener_flow, flow.Flow)
 
         self.assertIn(constants.LISTENERS, listener_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
-        self.assertEqual(2, len(listener_flow.requires))
-        self.assertEqual(0, len(listener_flow.provides))
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
+                      listener_flow.provides)
+        self.assertIn(constants.AMPHORAE, listener_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
 
-    def test_get_delete_listener_flow(self, mock_get_net_driver):
+        self.assertEqual(3, len(listener_flow.requires))
+        self.assertEqual(3, len(listener_flow.provides))
 
-        listener_flow = self.ListenerFlow.get_delete_listener_flow()
+    def test_get_delete_listener_flow(self, mock_get_net_driver):
+        flavor_dict = {
+            constants.SRIOV_VIP: True,
+            constants.LOADBALANCER_TOPOLOGY: constants.TOPOLOGY_SINGLE}
+        listener_flow = self.ListenerFlow.get_delete_listener_flow(
+            flavor_dict=flavor_dict)
 
         self.assertIsInstance(listener_flow, flow.Flow)
 
         self.assertIn(constants.LISTENER, listener_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
         self.assertIn(constants.PROJECT_ID, listener_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
-        self.assertEqual(3, len(listener_flow.requires))
-        self.assertEqual(0, len(listener_flow.provides))
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
+                      listener_flow.provides)
+        self.assertIn(constants.AMPHORAE, listener_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
+
+        self.assertEqual(4, len(listener_flow.requires))
+        self.assertEqual(3, len(listener_flow.provides))
 
     def test_get_delete_listener_internal_flow(self, mock_get_net_driver):
+        flavor_dict = {
+            constants.SRIOV_VIP: True,
+            constants.LOADBALANCER_TOPOLOGY: constants.TOPOLOGY_SINGLE}
         fake_listener = {constants.LISTENER_ID: uuidutils.generate_uuid()}
         listener_flow = self.ListenerFlow.get_delete_listener_internal_flow(
-            fake_listener)
+            fake_listener, flavor_dict=flavor_dict)
 
         self.assertIsInstance(listener_flow, flow.Flow)
 
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
         self.assertIn(constants.PROJECT_ID, listener_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
+
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
+                      listener_flow.provides)
+        self.assertIn(constants.AMPHORAE, listener_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
 
-        self.assertEqual(2, len(listener_flow.requires))
-        self.assertEqual(0, len(listener_flow.provides))
+        self.assertEqual(3, len(listener_flow.requires))
+        self.assertEqual(3, len(listener_flow.provides))
 
     def test_get_update_listener_flow(self, mock_get_net_driver):
+        flavor_dict = {
+            constants.SRIOV_VIP: True,
+            constants.LOADBALANCER_TOPOLOGY: constants.TOPOLOGY_SINGLE}
 
-        listener_flow = self.ListenerFlow.get_update_listener_flow()
+        listener_flow = self.ListenerFlow.get_update_listener_flow(
+            flavor_dict=flavor_dict)
 
         self.assertIsInstance(listener_flow, flow.Flow)
 
@@ -80,15 +112,31 @@ class TestListenerFlows(base.TestCase):
         self.assertIn(constants.UPDATE_DICT, listener_flow.requires)
         self.assertIn(constants.LISTENERS, listener_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listener_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, listener_flow.requires)
 
-        self.assertEqual(4, len(listener_flow.requires))
-        self.assertEqual(0, len(listener_flow.provides))
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
+                      listener_flow.provides)
+        self.assertIn(constants.AMPHORAE, listener_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES, listener_flow.provides)
+
+        self.assertEqual(5, len(listener_flow.requires))
+        self.assertEqual(3, len(listener_flow.provides))
 
     def test_get_create_all_listeners_flow(self, mock_get_net_driver):
-        listeners_flow = self.ListenerFlow.get_create_all_listeners_flow()
+        flavor_dict = {
+            constants.SRIOV_VIP: True,
+            constants.LOADBALANCER_TOPOLOGY: constants.TOPOLOGY_ACTIVE_STANDBY}
+        listeners_flow = self.ListenerFlow.get_create_all_listeners_flow(
+            flavor_dict=flavor_dict)
         self.assertIsInstance(listeners_flow, flow.Flow)
         self.assertIn(constants.LOADBALANCER, listeners_flow.requires)
         self.assertIn(constants.LOADBALANCER_ID, listeners_flow.requires)
+        self.assertIn(constants.AMPHORAE_STATUS, listeners_flow.requires)
         self.assertIn(constants.LOADBALANCER, listeners_flow.provides)
-        self.assertEqual(2, len(listeners_flow.requires))
-        self.assertEqual(2, len(listeners_flow.provides))
+        self.assertIn(constants.AMPHORAE_NETWORK_CONFIG,
+                      listeners_flow.provides)
+        self.assertIn(constants.AMPHORAE, listeners_flow.provides)
+        self.assertIn(constants.AMPHORA_FIREWALL_RULES,
+                      listeners_flow.provides)
+        self.assertEqual(3, len(listeners_flow.requires))
+        self.assertEqual(5, len(listeners_flow.provides))