Merge "[Fullstack] Remove unnecessary tests" into stable/zed

Author: Zuul

neutron/tests/fullstack/agents/ovs_agent.py

@@ -22,25 +22,9 @@
 from neutron.agent.common import polling
 from neutron.agent.l2.extensions import qos as qos_extension
 from neutron.common import config
-from neutron.services.trunk.drivers.openvswitch.agent \
-    import driver as trunk_driver
 from neutron.tests.common.agents import ovs_agent
 
 
-def monkeypatch_init_handler():
-    original_handler = trunk_driver.init_handler
-
-    def new_init_handler(resource, event, trigger, payload=None):
-        # NOTE(slaweq): make this setup conditional based on server-side
-        # capabilities for fullstack tests we can assume that server-side
-        # and agent-side conf are in sync
-        if "trunk" not in cfg.CONF.service_plugins:
-            return
-        original_handler(resource, event, trigger, payload)
-
-    trunk_driver.init_handler = new_init_handler
-
-
 def monkeypatch_qos():
     mock.patch.object(ovs_lib.OVSBridge, 'clear_bandwidth_qos').start()
     if "qos" in cfg.CONF.service_plugins:
@@ -63,7 +47,6 @@ def main():
     # ovs-vswitchd processes for each test will be isolated in separate
     # namespace
     config.register_common_config_options()
-    monkeypatch_init_handler()
     monkeypatch_qos()
     monkeypatch_event_filtering()
     ovs_agent.main()

neutron/tests/fullstack/test_connectivity.py

@@ -83,22 +83,6 @@ def _test_connectivity(self):
         vms.ping_all()
 
 
-class TestOvsConnectivitySameNetwork(BaseConnectivitySameNetworkTest):
-
-    l2_agent_type = constants.AGENT_TYPE_OVS
-    scenarios = [
-        ('VXLAN', {'network_type': 'vxlan',
-                   'l2_pop': False}),
-        ('GRE-l2pop-arp_responder', {'network_type': 'gre',
-                                     'l2_pop': True,
-                                     'arp_responder': True}),
-        ('VLANs', {'network_type': 'vlan',
-                   'l2_pop': False})]
-
-    def test_connectivity(self):
-        self._test_connectivity()
-
-
 class TestOvsConnectivitySameNetworkOnOvsBridgeControllerStop(
         BaseConnectivitySameNetworkTest):
 

neutron/tests/fullstack/test_dhcp_agent.py

@@ -91,15 +91,6 @@ class TestDhcpAgentNoHA(BaseDhcpAgentTest):
     number_of_hosts = 1
     agent_down_time = 60
 
-    def test_dhcp_assignment(self):
-        # First check if network was scheduled to one DHCP agent
-        dhcp_agents = self.client.list_dhcp_agent_hosting_networks(
-            self.network['id'])
-        self.assertEqual(1, len(dhcp_agents['agents']))
-
-        # And check if IP and gateway config is fine on FakeMachine
-        self.vm.block_until_dhcp_config_done()
-
     def test_mtu_update(self):
         # The test case needs access to devices in nested namespaces. ip_lib
         # doesn't support it, and it's probably unsafe to touch the library for

neutron/tests/fullstack/test_l3_agent.py

@@ -16,7 +16,6 @@
 import os
 import time
 
-import netaddr
 from neutron_lib import constants
 from neutronclient.common import exceptions
 from oslo_utils import uuidutils
@@ -323,18 +322,6 @@ def setUp(self):
             host_descriptions)
         super(TestLegacyL3Agent, self).setUp(env)
 
-    def test_namespace_exists(self):
-        tenant_id = uuidutils.generate_uuid()
-
-        router = self.safe_client.create_router(tenant_id)
-        network = self.safe_client.create_network(tenant_id)
-        subnet = self.safe_client.create_subnet(
-            tenant_id, network['id'], '20.0.0.0/24', gateway_ip='20.0.0.1')
-        self.safe_client.add_router_interface(router['id'], subnet['id'])
-
-        namespace = self._get_namespace(router['id'])
-        self.assert_namespace_exists(namespace)
-
     def test_mtu_update(self):
         tenant_id = uuidutils.generate_uuid()
 
@@ -361,92 +348,6 @@ def test_mtu_update(self):
         network = self.safe_client.update_network(network['id'], mtu=mtu)
         common_utils.wait_until_true(lambda: ri_dev.link.mtu == mtu)
 
-    def test_east_west_traffic(self):
-        tenant_id = uuidutils.generate_uuid()
-        router = self.safe_client.create_router(tenant_id)
-
-        vm1 = self._create_net_subnet_and_vm(
-            tenant_id, ['20.0.0.0/24', '2001:db8:aaaa::/64'],
-            self.environment.hosts[0], router)
-        vm2 = self._create_net_subnet_and_vm(
-            tenant_id, ['21.0.0.0/24', '2001:db8:bbbb::/64'],
-            self.environment.hosts[1], router)
-
-        vm1.block_until_ping(vm2.ip)
-        # Verify ping6 from vm2 to vm1 IPv6 Address
-        vm2.block_until_ping(vm1.ipv6)
-
-    def test_north_south_traffic(self):
-        # This function creates an external network which is connected to
-        # central_bridge and spawns an external_vm on it.
-        # The external_vm is configured with the gateway_ip (both v4 & v6
-        # addresses) of external subnet. Later, it creates a tenant router,
-        # a tenant network and two tenant subnets (v4 and v6). The tenant
-        # router is associated with tenant network and external network to
-        # provide north-south connectivity to the VMs.
-        # We validate the following in this testcase.
-        # 1. SNAT support: using ping from tenant VM to external_vm
-        # 2. Floating IP support: using ping from external_vm to VM floating ip
-        # 3. IPv6 ext connectivity: using ping6 from tenant vm to external_vm.
-        tenant_id = uuidutils.generate_uuid()
-        ext_net, ext_sub = self._create_external_network_and_subnet(tenant_id)
-        external_vm = self._create_external_vm(ext_net, ext_sub)
-        # Create an IPv6 subnet in the external network
-        v6network = self.useFixture(
-            ip_network.ExclusiveIPNetwork(
-                "2001:db8:1234::1", "2001:db8:1234::10", "64")).network
-        # NOTE(ykarel): gateway_ip is explicitly added as iputils package
-        # requires fix for https://github.com/iputils/iputils/issues/371
-        # is not available in CentOS 9-Stream
-        ext_v6sub = self.safe_client.create_subnet(
-            tenant_id, ext_net['id'], v6network, gateway_ip='2001:db8:1234::1')
-
-        router = self.safe_client.create_router(tenant_id,
-                                                external_network=ext_net['id'])
-
-        # Configure the gateway_ip of external v6subnet on the external_vm.
-        external_vm.ipv6_cidr = common_utils.ip_to_cidr(
-            ext_v6sub['gateway_ip'], 64)
-
-        # Configure an IPv6 downstream route to the v6Address of router gw port
-        for fixed_ip in router['external_gateway_info']['external_fixed_ips']:
-            if netaddr.IPNetwork(fixed_ip['ip_address']).version == 6:
-                external_vm.set_default_gateway(fixed_ip['ip_address'])
-
-        vm = self._create_net_subnet_and_vm(
-            tenant_id, ['20.0.0.0/24', '2001:db8:aaaa::/64'],
-            self.environment.hosts[1], router)
-
-        # ping external vm to test snat
-        vm.block_until_ping(external_vm.ip)
-
-        fip = self.safe_client.create_floatingip(
-            tenant_id, ext_net['id'], vm.ip, vm.neutron_port['id'])
-
-        # ping floating ip from external vm
-        external_vm.block_until_ping(fip['floating_ip_address'])
-
-        # Verify VM is able to reach the router interface.
-        vm.block_until_ping(vm.gateway_ipv6)
-        # Verify north-south connectivity using ping6 to external_vm.
-        vm.block_until_ping(external_vm.ipv6)
-
-        # Now let's remove and create again phys bridge and check connectivity
-        # once again
-        br_phys = self.environment.hosts[0].br_phys
-        br_phys.destroy()
-        br_phys.create()
-        self.environment.hosts[0].connect_to_central_network_via_vlans(
-            br_phys)
-
-        # ping floating ip from external vm
-        external_vm.block_until_ping(fip['floating_ip_address'])
-
-        # Verify VM is able to reach the router interface.
-        vm.block_until_ping(vm.gateway_ipv6)
-        # Verify north-south connectivity using ping6 to external_vm.
-        vm.block_until_ping(external_vm.ipv6)
-
     def test_gateway_ip_changed(self):
         self._test_gateway_ip_changed()
 

neutron/tests/fullstack/test_qos.py

@@ -29,7 +29,6 @@
 from neutron.tests.unit import testlib_api
 
 from neutron.agent.common import ovs_lib
-from neutron.services.qos.drivers.openvswitch import driver as ovs_drv
 
 
 load_tests = testlib_api.module_load_tests
@@ -201,47 +200,6 @@ def _restart_agent_and_check_rules_applied(self, policy_id, vm,
         for direction in list(all_directions):
             self._wait_for_bw_rule_applied(vm, None, None, direction)
 
-    def test_bw_limit_qos_policy_rule_lifecycle(self):
-        new_limit = BANDWIDTH_LIMIT + 100
-
-        # Create port with qos policy attached
-        vm, qos_policy = self._prepare_vm_with_qos_policy(
-            [functools.partial(
-                self._add_bw_limit_rule,
-                BANDWIDTH_LIMIT, BANDWIDTH_BURST, self.direction)])
-        bw_rule = qos_policy['rules'][0]
-
-        self._wait_for_bw_rule_applied(
-            vm, BANDWIDTH_LIMIT, BANDWIDTH_BURST, self.direction)
-        qos_policy_id = qos_policy['id']
-
-        self.client.delete_bandwidth_limit_rule(bw_rule['id'], qos_policy_id)
-        self._wait_for_bw_rule_removed(vm, self.direction)
-
-        # Create new rule with no given burst value, in such case ovs and lb
-        # agent should apply burst value as
-        # bandwidth_limit * qos_consts.DEFAULT_BURST_RATE
-        new_expected_burst = self._get_expected_burst_value(new_limit,
-                                                            self.direction)
-        new_rule = self.safe_client.create_bandwidth_limit_rule(
-            self.tenant_id, qos_policy_id, new_limit, direction=self.direction)
-        self._wait_for_bw_rule_applied(
-            vm, new_limit, new_expected_burst, self.direction)
-
-        # Update qos policy rule id
-        self.client.update_bandwidth_limit_rule(
-            new_rule['id'], qos_policy_id,
-            body={'bandwidth_limit_rule': {'max_kbps': BANDWIDTH_LIMIT,
-                                           'max_burst_kbps': BANDWIDTH_BURST}})
-        self._wait_for_bw_rule_applied(
-            vm, BANDWIDTH_LIMIT, BANDWIDTH_BURST, self.direction)
-
-        # Remove qos policy from port
-        self.client.update_port(
-            vm.neutron_port['id'],
-            body={'port': {'qos_policy_id': None}})
-        self._wait_for_bw_rule_removed(vm, self.direction)
-
     def test_bw_limit_direction_change(self):
         # Create port with qos policy attached, with rule self.direction
         vm, qos_policy = self._prepare_vm_with_qos_policy(
@@ -584,27 +542,6 @@ class TestPacketRateLimitQoSOvs(_TestPacketRateLimitQoS,
     ]
 
 
-class TestQoSWithL2Population(base.BaseFullStackTestCase):
-    scenarios = [
-        (constants.AGENT_TYPE_OVS,
-         {'mech_drivers': 'openvswitch',
-          'supported_rules': ovs_drv.SUPPORTED_RULES}),
-    ]
-
-    def setUp(self):
-        host_desc = []  # No need to register agents for this test case
-        env_desc = environment.EnvironmentDescription(
-            qos=True, l2_pop=True, mech_drivers=self.mech_drivers)
-        env = environment.Environment(env_desc, host_desc)
-        super(TestQoSWithL2Population, self).setUp(env)
-
-    def test_supported_qos_rule_types(self):
-        res = self.client.list_qos_rule_types()
-        rule_types = {t['type'] for t in res['rule_types']}
-        expected_rules = set(self.supported_rules)
-        self.assertEqual(expected_rules, rule_types)
-
-
 class TestQoSPolicyIsDefault(base.BaseFullStackTestCase):
 
     NAME = 'fs_policy'

neutron/tests/fullstack/test_securitygroup.py

@@ -669,21 +669,6 @@ def setUp(self):
                                       host_descriptions)
         super(SecurityGroupRulesTest, self).setUp(env)
 
-    def test_security_group_rule_quota(self):
-        project_id = uuidutils.generate_uuid()
-        quota = self.client.show_quota_details(project_id)
-        sg_rules_used = quota['quota']['security_group_rule']['used']
-        self.assertEqual(0, sg_rules_used)
-
-        self.safe_client.create_security_group(project_id)
-        quota = self.client.show_quota_details(project_id)
-        sg_rules_used = quota['quota']['security_group_rule']['used']
-        self.safe_client.update_quota(project_id, 'security_group_rule',
-                                      sg_rules_used)
-
-        self.assertRaises(nc_exc.OverQuotaClient,
-                          self.safe_client.create_security_group, project_id)
-
     def test_normalized_cidr_in_rule(self):
         project_id = uuidutils.generate_uuid()
         sg = self.safe_client.create_security_group(project_id)

neutron/tests/fullstack/test_subnet.py

@@ -61,27 +61,6 @@ def _create_subnet(self, project_id, network_id, cidr=None,
     def _show_subnet(self, subnet_id):
         return self.client.show_subnet(subnet_id)
 
-    def test_create_subnet_ipv4(self):
-        cidr = self.useFixture(
-            ip_network.ExclusiveIPNetwork(
-                '240.0.0.0', '240.255.255.255', '24')).network
-        subnet = self._create_subnet(self._project_id, self._network['id'],
-                                     cidr)
-        subnet = self._show_subnet(subnet['id'])
-        self.assertEqual(subnet['subnet']['gateway_ip'],
-                         str(netaddr.IPNetwork(cidr).network + 1))
-
-    def test_create_subnet_ipv6_slaac(self):
-        cidr = self.useFixture(
-            ip_network.ExclusiveIPNetwork(
-                '2001:db8::', '2001:db8::ffff', '64')).network
-        subnet = self._create_subnet(self._project_id, self._network['id'],
-                                     cidr, ipv6_address_mode='slaac',
-                                     ipv6_ra_mode='slaac')
-        subnet = self._show_subnet(subnet['id'])
-        self.assertEqual(subnet['subnet']['gateway_ip'],
-                         str(netaddr.IPNetwork(cidr).network))
-
     def test_create_subnet_ipv6_prefix_delegation(self):
         subnet = self._create_subnet(self._project_id, self._network['id'],
                                      None, ipv6_address_mode='slaac',