catalystwan 0.40.2.dev1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

catalystwan/integration_tests/feature_profile/sdwan/test_service.py

@@ -1,1078 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from ipaddress import IPv4Address, IPv4Interface, IPv6Address, IPv6Interface
-from typing import Literal
-from uuid import UUID
-
-from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, as_global, as_variable
-from catalystwan.api.feature_profile_api import ServiceFeatureProfileAPI
-from catalystwan.integration_tests.base import TestCaseBase, create_name_with_run_id
-from catalystwan.models.common import (
-    CableLengthLongValue,
-    ClockRate,
-    E1Framing,
-    E1Linecode,
-    LineMode,
-    SubnetMask,
-    T1Framing,
-    T1Linecode,
-)
-from catalystwan.models.configuration.feature_profile.common import (
-    AddressWithMask,
-    ChannelGroup,
-    MultilinkAuthenticationType,
-    MultilinkClockSource,
-    MultilinkControllerTxExList,
-    MultilinkControllerType,
-    MultilinkMethod,
-    MultilinkNimList,
-    MultilinkTxExName,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.acl.ipv4acl import Ipv4AclParcel
-from catalystwan.models.configuration.feature_profile.sdwan.acl.ipv6acl import Ipv6AclParcel
-from catalystwan.models.configuration.feature_profile.sdwan.routing.bgp import AddressFamily as BgpAddressFamily
-from catalystwan.models.configuration.feature_profile.sdwan.routing.bgp import (
-    AddressFamilyItem,
-    FamilyType,
-    Ipv6AddressFamily,
-    Ipv6AggregateAddres,
-    Ipv6NeighborItem,
-    Ipv6NetworkItem,
-    Ipv6RedistributeItem,
-    MaxPrefixConfigRestart,
-    NeighborItem,
-    NetworkItem,
-    RedistributeItem,
-    RoutingBgpParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.routing.ospf import RoutingOspfParcel
-from catalystwan.models.configuration.feature_profile.sdwan.routing.ospfv3 import (
-    Ospfv3InterfaceParametres,
-    Ospfv3IPv4Area,
-    Ospfv3IPv6Area,
-    RoutingOspfv3IPv4Parcel,
-    RoutingOspfv3IPv6Parcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.dhcp_server import (
-    AddressPool,
-    LanVpnDhcpServerParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.eigrp import (
-    AddressFamily,
-    EigrpParcel,
-    SummaryAddress,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.ethernet import InterfaceEthernetParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.gre import BasicGre, InterfaceGreParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.ipsec import InterfaceIpsecParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.multilink import InterfaceMultilinkParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.svi import InterfaceSviParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service.lan.vpn import (
-    IPv4Prefix,
-    LanVpnParcel,
-    OmpAdvertiseIPv4,
-    ProtocolIPv4,
-    RoutePrefix,
-    ServiceRoute,
-    StaticGreRouteIPv4,
-    StaticIpsecRouteIPv4,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.multicast import (
-    AutoRpAttributes,
-    BsrCandidateAttributes,
-    IgmpAttributes,
-    IgmpInterfaceParameters,
-    LocalConfig,
-    MsdpAttributes,
-    MsdpPeer,
-    MsdpPeerAttributes,
-    MulticastBasicAttributes,
-    MulticastParcel,
-    PimAttributes,
-    PimBsrAttributes,
-    PimInterfaceParameters,
-    RPAnnounce,
-    RpDiscoveryScope,
-    SsmAttributes,
-    SsmFlag,
-    StaticJoin,
-    StaticRpAddress,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.route_policy import RoutePolicyParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service.switchport import (
-    ControlDirection,
-    Duplex,
-    HostMode,
-    PortControl,
-    Speed,
-    StaticMacAddress,
-    SwitchportInterface,
-    SwitchportMode,
-    SwitchportParcel,
-)
-from catalystwan.models.configuration.feature_profile.sdwan.service.wireless_lan import (
-    SSID,
-    CountryCode,
-    MeIpConfig,
-    MeStaticIpConfig,
-    QosProfile,
-    RadioType,
-    SecurityConfig,
-    SecurityType,
-    WirelessLanParcel,
-)
-
-
-class TestServiceFeatureProfileModels(TestCaseBase):
-    api: ServiceFeatureProfileAPI
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        super().setUpClass()
-        cls.api = cls.session.api.sdwan_feature_profiles.service
-        cls.profile_uuid = cls.api.create_profile(create_name_with_run_id("TestProfileService"), "Description").id
-
-    def test_update(self):
-        dhcp_server_parcel = LanVpnDhcpServerParcel(
-            parcel_name="DhcpServerDefault_TestUpdate",
-            parcel_description="Dhcp Server Parcel",
-            address_pool=AddressPool(
-                network_address=Global[IPv4Address](value=IPv4Address("10.0.0.2")),
-                subnet_mask=Global[SubnetMask](value="255.255.255.255"),
-            ),
-        )
-        parcel_id = self.api.create_parcel(self.profile_uuid, dhcp_server_parcel).id
-        parcel = self.api.get_parcel(self.profile_uuid, LanVpnDhcpServerParcel, parcel_id)
-        assert isinstance(parcel.payload, LanVpnDhcpServerParcel)
-        assert parcel.payload == dhcp_server_parcel
-
-        dhcp_server_parcel.address_pool.network_address = Global[IPv4Address](value=IPv4Address("10.3.2.1"))
-        dhcp_server_parcel.address_pool.subnet_mask = Global[SubnetMask](value="248.0.0.0")
-        parcel_id = self.api.update_parcel(self.profile_uuid, dhcp_server_parcel, parcel_id).id
-        parcel = self.api.get_parcel(self.profile_uuid, LanVpnDhcpServerParcel, parcel_id)
-        assert isinstance(parcel.payload, LanVpnDhcpServerParcel)
-        assert parcel.payload == dhcp_server_parcel
-
-    def test_when_default_values_dhcp_server_parcel_expect_successful_post(self):
-        # Arrange
-        dhcp_server_parcel = LanVpnDhcpServerParcel(
-            parcel_name="DhcpServerDefault",
-            parcel_description="Dhcp Server Parcel",
-            address_pool=AddressPool(
-                network_address=Global[IPv4Address](value=IPv4Address("10.0.0.2")),
-                subnet_mask=Global[SubnetMask](value="255.255.255.255"),
-            ),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, dhcp_server_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, LanVpnDhcpServerParcel, parcel_id)
-        assert isinstance(parcel.payload, LanVpnDhcpServerParcel)
-        assert parcel.payload == dhcp_server_parcel
-
-    def test_when_default_values_service_vpn_parcel_expect_successful_post(self):
-        # Arrange
-        vpn_parcel = LanVpnParcel(
-            parcel_name="TestVpnParcel",
-            parcel_description="Test Vpn Parcel",
-            vpn_id=Global[int](value=2),
-            ipsec_route=[
-                StaticIpsecRouteIPv4(
-                    prefix=RoutePrefix(ip_address=as_global("1.2.3.4"), subnet_mask=as_global("0.0.0.0")),
-                )
-            ],
-            gre_route=[
-                StaticGreRouteIPv4(
-                    prefix=RoutePrefix(
-                        ip_address=as_global("8.6.5.4"),
-                        subnet_mask=as_global("255.255.255.0"),
-                    )
-                )
-            ],
-            service_route=[
-                ServiceRoute(
-                    prefix=RoutePrefix(
-                        ip_address=as_global("8.6.5.2"),
-                        subnet_mask=as_global("255.255.255.0"),
-                    )
-                )
-            ],
-            omp_advertise_ipv4=[
-                OmpAdvertiseIPv4(
-                    omp_protocol=Global[ProtocolIPv4](value="aggregate"),
-                    prefix_list=[
-                        IPv4Prefix(
-                            prefix=AddressWithMask(
-                                address=as_global("10.3.2.1"),
-                                mask=as_global("255.255.255.0"),
-                            )
-                        )
-                    ],
-                )
-            ],
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, vpn_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, LanVpnParcel, parcel_id)
-        assert isinstance(parcel.payload, LanVpnParcel)
-        assert parcel.payload == vpn_parcel
-
-    def test_when_default_values_ospf_parcel_expect_successful_post(self):
-        # Arrange
-        ospf_parcel = RoutingOspfParcel(
-            parcel_name="TestRoutingOspfParcel",
-            parcel_description="Test Ospf Parcel",
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, ospf_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, RoutingOspfParcel, parcel_id)
-        assert isinstance(parcel.payload, RoutingOspfParcel)
-        assert parcel.payload == ospf_parcel
-
-    def test_when_default_ospfv3_ipv4_expect_successful_post(self):
-        # Arrange
-        ospfv3ipv4_parcel = RoutingOspfv3IPv4Parcel(
-            parcel_name="TestOspfv3ipv4",
-            parcel_description="Test Ospfv3ipv4 Parcel",
-            area=[
-                Ospfv3IPv4Area(
-                    area_number=as_global(5),
-                    interfaces=[Ospfv3InterfaceParametres(name=as_global("GigabitEthernet0/0/0"))],
-                )
-            ],
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, ospfv3ipv4_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, RoutingOspfv3IPv4Parcel, parcel_id)
-        assert isinstance(parcel.payload, RoutingOspfv3IPv4Parcel)
-        assert parcel.payload == ospfv3ipv4_parcel
-
-    def test_when_default_ospfv3_ipv6_expect_successful_post(self):
-        # Arrange
-        ospfv3ipv6_parcel = RoutingOspfv3IPv6Parcel(
-            parcel_name="TestOspfv3ipv6",
-            parcel_description="Test Ospfv3ipv6 Parcel",
-            area=[
-                Ospfv3IPv6Area(
-                    area_number=as_global(7),
-                    interfaces=[Ospfv3InterfaceParametres(name=as_global("GigabitEthernet0/0/0"))],
-                )
-            ],
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, ospfv3ipv6_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, RoutingOspfv3IPv6Parcel, parcel_id)
-        assert isinstance(parcel.payload, RoutingOspfv3IPv6Parcel)
-        assert parcel.payload == ospfv3ipv6_parcel
-
-    def test_when_default_values_eigrp_parcel_expect_successful_post(self):
-        eigrp_parcel = EigrpParcel(
-            parcel_name="TestEigrpParcel",
-            parcel_description="Test Eigrp Parcel",
-            as_number=Global[int](value=1),
-            address_family=AddressFamily(
-                network=[
-                    SummaryAddress(
-                        prefix=AddressWithMask(
-                            address=as_global("10.3.2.1"),
-                            mask=as_global("255.255.255.0"),
-                        )
-                    )
-                ]
-            ),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, eigrp_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, EigrpParcel, parcel_id)
-        assert isinstance(parcel.payload, EigrpParcel)
-        assert parcel.payload == eigrp_parcel
-
-    def test_when_default_values_route_policy_parcel_expect_successful_post(self):
-        # Arrange
-        route_policy_parcel = RoutePolicyParcel(
-            parcel_name="TestRoutePolicyParcel",
-            parcel_description="Test Route Policy Parcel",
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, route_policy_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, RoutePolicyParcel, parcel_id)
-        assert isinstance(parcel.payload, RoutePolicyParcel)
-        assert parcel.payload == route_policy_parcel
-
-    def test_when_default_values_acl_ipv4_expect_successful_post(self):
-        # Arrange
-        acl_ipv4_parcel = Ipv4AclParcel(
-            parcel_name="TestAclIpv4Parcel",
-            parcel_description="Test Acl Ipv4 Parcel",
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, acl_ipv4_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, Ipv4AclParcel, parcel_id)
-        assert isinstance(parcel.payload, Ipv4AclParcel)
-        assert parcel.payload == acl_ipv4_parcel
-
-    def test_when_fully_specified_acl_ipv4_expect_successful_post(self):
-        # Arrange
-        acl_ipv4_parcel = Ipv4AclParcel(
-            parcel_name="TestAclIpv4Parcel-Full",
-            parcel_description="Test Acl Ipv4 Parcel",
-        )
-        # Arrange Sequence 1
-        seq1 = acl_ipv4_parcel.add_sequence("Sequence1", 10, "accept")
-        seq1.match_destination_data_prefix(IPv4Interface("10.0.0.0/16"))
-        seq1.match_dscp([50, 55])
-        seq1.match_icmp_msg(["dod-host-prohibited", "extended-echo", "dod-net-prohibited"])
-        seq1.match_packet_length((1000, 8000))
-        seq1.match_protocol([1])
-        seq1.match_source_data_prefix(IPv4Interface("11.0.0.0/16"))
-        # Arrange Sequence 2
-        seq2 = acl_ipv4_parcel.add_sequence("Sequence2", 20, "drop")
-        seq2.match_destination_data_prefix_variable("varDestPrefix2")
-        seq2.match_source_data_prefix_variable("varSrcPrefix2")
-        seq2.match_destination_ports([233])
-        seq2.match_source_ports([1, 3, (10, 100), (50, 200), 600])
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, acl_ipv4_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, Ipv4AclParcel, parcel_id)
-        assert isinstance(parcel.payload, Ipv4AclParcel)
-        assert parcel.payload == acl_ipv4_parcel
-
-    def test_when_default_values_acl_ipv6_expect_successful_post(self):
-        # Arrange
-        acl_ipv6_parcel = Ipv6AclParcel(
-            parcel_name="TestAclIpv6Parcel",
-            parcel_description="Test Acl Ipv6 Parcel",
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, acl_ipv6_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, Ipv6AclParcel, parcel_id)
-        assert isinstance(parcel.payload, Ipv6AclParcel)
-        assert parcel.payload == acl_ipv6_parcel
-
-    def test_when_fully_specified_acl_ipv6_expect_successful_post(self):
-        # Arrange
-        acl_ipv6_parcel = Ipv6AclParcel(
-            parcel_name="TestAclIpv6Parcel-Full",
-            parcel_description="Test Acl Ipv6 Parcel",
-        )
-        # Arrange Sequence 1
-        seq1 = acl_ipv6_parcel.add_sequence("Sequence1", 10, "accept")
-        seq1.match_destination_data_prefix(IPv6Interface("2001:db8:abcd:0012::/64"))
-        seq1.match_icmp_msg(["cp-solicitation", "ind-advertisement"])
-        seq1.match_packet_length((1000, 8000))
-        seq1.match_source_data_prefix(IPv6Interface("2001:db8:1111:0012::/64"))
-        seq1.match_traffic_class([3])
-        # Arrange Sequence 2
-        seq2 = acl_ipv6_parcel.add_sequence("Sequence2", 20, "drop")
-        seq2.match_destination_ports([233])
-        seq2.match_source_ports([1, 3, (10, 100), (50, 200), 600])
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, acl_ipv6_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, Ipv6AclParcel, parcel_id)
-        assert isinstance(parcel.payload, Ipv6AclParcel)
-        assert parcel.payload == acl_ipv6_parcel
-
-    def test_when_fully_specified_routing_bgp_expect_successful_post(self):
-        # Arrange
-        bgp_parcel = RoutingBgpParcel(
-            parcel_name="TestRoutingBgpParcel",
-            parcel_description="Description",
-            as_num=Global[int](value=50),
-            router_id=Global[IPv4Address](value=IPv4Address("192.0.0.4")),
-            propagate_aspath=Global[bool](value=True),
-            propagate_community=Global[bool](value=True),
-            external=Global[int](value=255),
-            internal=Global[int](value=255),
-            local=Global[int](value=195),
-            keepalive=Global[int](value=200),
-            holdtime=Global[int](value=246),
-            always_compare=Global[bool](value=True),
-            deterministic=Global[bool](value=True),
-            missing_as_worst=Global[bool](value=True),
-            compare_router_id=Global[bool](value=False),
-            multipath_relax=Global[bool](value=True),
-            neighbor=[
-                NeighborItem(
-                    address=Global[IPv4Address](value=IPv4Address("192.175.48.31")),
-                    description=Global[str](value="sJQwaemlk"),
-                    shutdown=Global[bool](value=True),
-                    remote_as=Global[int](value=330),
-                    local_as=Global[int](value=409),
-                    keepalive=Global[int](value=500),
-                    holdtime=Global[int](value=204),
-                    if_name=Variable(value="{{lbgp_1_ipv4_conf_1_updateSrcIntf}}"),
-                    next_hop_self=Global[bool](value=True),
-                    send_community=Global[bool](value=True),
-                    send_ext_community=Global[bool](value=False),
-                    ebgp_multihop=Global[int](value=147),
-                    password=None,
-                    send_label=Global[bool](value=True),
-                    as_override=Global[bool](value=False),
-                    as_number=Variable(value="{{lbgp_1_ipv4_conf_1_asNumber}}"),
-                    address_family=[
-                        AddressFamilyItem(
-                            family_type=Global[FamilyType](value="ipv4-unicast"),
-                            max_prefix_config=MaxPrefixConfigRestart(
-                                policy_type=Global[Literal["restart"]](value="restart"),
-                                prefix_num=Global[int](value=11),
-                                threshold=Global[int](value=10),
-                                restart_interval=Global[int](value=10),
-                            ),
-                        ),
-                    ],
-                ),
-            ],
-            ipv6_neighbor=[
-                Ipv6NeighborItem(
-                    address=Global[IPv6Address](value=IPv6Address("f555:b620:61fc:798a:ece3:4364:58c3:8656")),
-                    description=Global[str](value="VOBWPfHlS"),
-                    shutdown=Global[bool](value=True),
-                    remote_as=Global[int](value=20),
-                    local_as=Global[int](value=479),
-                    keepalive=Global[int](value=165),
-                    holdtime=Global[int](value=147),
-                    if_name=Variable(value="{{lbgp_1_ipv6_conf_1_updateSrcIntf}}"),
-                    next_hop_self=Global[bool](value=True),
-                    send_community=Global[bool](value=True),
-                    send_ext_community=Global[bool](value=False),
-                    ebgp_multihop=Global[int](value=21),
-                    password=None,
-                    as_override=Global[bool](value=True),
-                    as_number=Global[int](value=10),
-                    address_family=[
-                        AddressFamilyItem(
-                            family_type=Global[FamilyType](value="ipv6-unicast"),
-                            max_prefix_config=MaxPrefixConfigRestart(
-                                policy_type=Global[Literal["restart"]](value="restart"),
-                                prefix_num=Global[int](value=11),
-                                threshold=Global[int](value=10),
-                                restart_interval=Global[int](value=10),
-                            ),
-                        ),
-                    ],
-                )
-            ],
-            address_family=BgpAddressFamily(
-                name=Default[None](value=None),
-                network=[
-                    NetworkItem(
-                        prefix=AddressWithMask(address=Variable(value="{{cYQ4ud15}}"), mask=Variable(value="{{LdKTD}}"))
-                    )
-                ],
-                paths=Global[int](value=32),
-                originate=Global[bool](value=True),
-                filter=Global[bool](value=True),
-                redistribute=[
-                    RedistributeItem(
-                        protocol=Global[Literal["static", "connected", "ospf", "ospfv3", "nat", "omp"]](value="ospf"),
-                    )
-                ],
-            ),
-            ipv6_address_family=Ipv6AddressFamily(
-                ipv6_aggregate_address=[
-                    Ipv6AggregateAddres(
-                        prefix=Global[IPv6Interface](value=IPv6Interface("0::/16")),
-                        as_set=Global[bool](value=True),
-                        summary_only=Global[bool](value=False),
-                    )
-                ],
-                ipv6_network=[
-                    Ipv6NetworkItem(prefix=Global[IPv6Interface](value=IPv6Interface("2002::/16"))),
-                ],
-                paths=Global[int](value=2),
-                originate=Global[bool](value=True),
-                name=Default[None](value=None),
-                filter=Global[bool](value=True),
-                redistribute=[
-                    Ipv6RedistributeItem(
-                        protocol=Global[Literal["static", "connected", "ospf", "omp"]](value="connected"),
-                        route_policy=Default[None](value=None),
-                    )
-                ],
-            ),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, bgp_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, RoutingBgpParcel, parcel_id)
-        assert isinstance(parcel.payload, RoutingBgpParcel)
-        assert parcel.payload == bgp_parcel
-
-    def test_when_correct_values_switchport_parcel_expect_successful_post(self):
-        # Arrange
-        switchport_default_values_parcel = SwitchportParcel(
-            parcel_name="TestSwitchportParcelDefaultValues",
-            parcel_description="Test Switchport Parcel",
-        )
-        switchport_fully_specified_parcel = SwitchportParcel(
-            parcel_name="TestSwitchportParcelFullySpecified",
-            parcel_description="Test Switchport Parcel",
-            age_time=Global[int](value=100),
-            static_mac_address=[
-                StaticMacAddress(
-                    mac_address=as_global("00:00:00:00:00:00"),
-                    vlan=Global[int](value=1),
-                    interface_name=as_global("GigabitEthernet0/0/0"),
-                )
-            ],
-            interface=[
-                SwitchportInterface(
-                    interface_name=as_global("GigabitEthernet0/0/0"),
-                    mode=Global[SwitchportMode](value="access"),
-                    shutdown=Global[bool](value=True),
-                    speed=Global[Speed](value="10"),
-                    duplex=Global[Duplex](value="full"),
-                    switchport_access_vlan=Global[int](value=1),
-                    switchport_trunk_allowed_vlans=Global[str](value="1-10"),
-                    switchport_trunk_native_vlan=Global[int](value=1),
-                    voice_vlan=Global[int](value=1),
-                    host_mode=Global[HostMode](value="single-host"),
-                    port_control=Global[PortControl](value="auto"),
-                    control_direction=Global[ControlDirection](value="both"),
-                    pae_enable=Global[bool](value=True),
-                    guest_vlan=Global[int](value=1),
-                    critical_vlan=Global[int](value=1),
-                    enable_voice=Global[bool](value=True),
-                )
-            ],
-        )
-        switchport_parcels = [switchport_default_values_parcel, switchport_fully_specified_parcel]
-        # Act
-        for switchport_parcel in switchport_parcels:
-            with self.subTest(switchport_parcel=switchport_parcel.parcel_name):
-                parcel_id = self.api.create_parcel(self.profile_uuid, switchport_parcel).id
-                # Assert
-                parcel = self.api.get_parcel(self.profile_uuid, SwitchportParcel, parcel_id)
-                assert isinstance(parcel.payload, SwitchportParcel)
-                assert parcel.payload == switchport_parcel
-
-                # Cleanup
-                self.api.delete_parcel(self.profile_uuid, SwitchportParcel, parcel_id)
-
-    def test_when_default_values_multicast_expect_successful_post(self):
-        # Arrange
-        multicast_parcel = MulticastParcel(
-            parcel_name="TestMulticastParcel",
-            parcel_description="Test Multicast Parcel",
-            basic=MulticastBasicAttributes(),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, multicast_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, MulticastParcel, parcel_id)
-        assert isinstance(parcel.payload, MulticastParcel)
-        assert parcel.payload == multicast_parcel
-
-    def test_when_fully_specified_values_multicast_expect_successful_post(self):
-        # Arrange
-        multicast_parcel = MulticastParcel(
-            parcel_name="TestMulticastParcel_FullySpecified",
-            parcel_description="Test Multicast Parcel",
-            basic=MulticastBasicAttributes(
-                spt_only=as_global(True),
-                local_config=LocalConfig(
-                    local=as_global(True),
-                    threshold=as_global(10),
-                ),
-            ),
-            igmp=IgmpAttributes(
-                interface=[
-                    IgmpInterfaceParameters(
-                        interface_name=as_global("GigabitEthernet0/0/0"),
-                        version=as_global(2),
-                        join_group=[
-                            StaticJoin(
-                                group_address=Global[IPv4Address](value=IPv4Address("239.255.255.255")),
-                            )
-                        ],
-                    )
-                ]
-            ),
-            pim=PimAttributes(
-                ssm=SsmAttributes(ssm_range_config=SsmFlag(enable_ssm_flag=as_global(True), range=as_global("20"))),
-                interface=[
-                    PimInterfaceParameters(
-                        interface_name=as_global("GigabitEthernet0/0/0"),
-                        query_interval=as_global(10),
-                        join_prune_interval=as_global(10),
-                    )
-                ],
-                rp_address=[
-                    StaticRpAddress(
-                        address=Global[IPv4Address](value=IPv4Address("40.2.3.1")),
-                        access_list=as_global("TestAccessList"),
-                        override=as_global(True),
-                    )
-                ],
-                auto_rp=AutoRpAttributes(
-                    enable_auto_rp_flag=as_global(False),
-                    send_rp_announce_list=[
-                        RPAnnounce(interface_name=as_global("GigabitEthernet0/0/0"), scope=as_global(3))
-                    ],
-                    send_rp_discovery=[
-                        RPAnnounce(interface_name=as_global("GigabitEthernet0/0/0"), scope=as_global(3))
-                    ],
-                ),
-                pim_bsr=PimBsrAttributes(
-                    rp_candidate=[
-                        RpDiscoveryScope(
-                            interface_name=as_global("GigabitEthernet0/0/0"),
-                            group_list=as_global("TestGroupList"),
-                            interval=as_global(10),
-                            priority=as_global(10),
-                        )
-                    ],
-                    bsr_candidate=[
-                        BsrCandidateAttributes(
-                            interface_name=as_global("GigabitEthernet0/0/0"),
-                            mask=as_global(10),
-                            priority=as_global(10),
-                            accept_rp_candidate=as_global("True"),
-                        )
-                    ],
-                ),
-            ),
-            msdp=MsdpAttributes(
-                msdp_list=[
-                    MsdpPeer(
-                        mesh_group=as_global("TestMeshGroup"),
-                        peer=[
-                            MsdpPeerAttributes(
-                                peer_ip=Global[IPv4Address](value=IPv4Address("5.5.5.5")),
-                                connect_source_intf=as_global("GigabitEthernet0/0/0"),
-                                remote_as=as_global(10),
-                                password=None,
-                                keepalive_holdtime=as_global(20),
-                                keepalive_interval=as_global(10),
-                                sa_limit=as_global(10),
-                            )
-                        ],
-                    )
-                ]
-            ),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, multicast_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, MulticastParcel, parcel_id)
-        assert isinstance(parcel.payload, MulticastParcel)
-        assert parcel.payload == multicast_parcel
-
-    def test_when_fully_specified_values_wireless_lan_expect_successful_post(self):
-        # Arrange
-        wireless_lan_parcel = WirelessLanParcel(
-            parcel_name="TestWirelessLanParcel",
-            parcel_description="Test Wireless Lan Parcel",
-            enable_2_4G=as_global(True),
-            enable_5G=as_global(True),
-            country=as_global("US", CountryCode),
-            username=as_global("admin"),
-            password=as_variable("{{wireless_lan_password}}"),
-            ssid=[
-                SSID(
-                    name=as_global("TestSSID"),
-                    admin_state=as_global(True),
-                    vlan_id=as_global(1),
-                    broadcast_ssid=as_global(True),
-                    radio_type=as_global("all", RadioType),
-                    qos_profile=as_global("platinum", QosProfile),
-                    security_config=SecurityConfig(
-                        security_type=as_global("enterprise", SecurityType),
-                        radius_server_ip=as_global(IPv4Address("1.1.1.1")),
-                        radius_server_port=as_global(1884),
-                        radius_server_secret=as_global("23452345245"),
-                    ),
-                )
-            ],
-            me_ip_config=MeIpConfig(
-                me_dynamic_ip_enabled=as_global(False),
-                me_static_ip_config=MeStaticIpConfig(
-                    me_ipv4_address=as_global(IPv4Address("10.2.3.2")),
-                    netmask=as_global("255.255.255.0", SubnetMask),
-                    default_gateway=as_global(IPv4Address("10.0.0.1")),
-                ),
-            ),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, wireless_lan_parcel).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, WirelessLanParcel, parcel_id)
-        assert isinstance(parcel.payload, WirelessLanParcel)
-        assert parcel.payload == wireless_lan_parcel
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.api.delete_profile(cls.profile_uuid)
-        super().tearDownClass()
-
-
-class TestServiceFeatureProfileVPNSubparcelModels(TestCaseBase):
-    vpn_parcel_uuid: UUID
-
-    @classmethod
-    def setUpClass(cls) -> None:
-        super().setUpClass()
-        cls.api = cls.session.api.sdwan_feature_profiles.service
-        cls.profile_uuid = cls.api.create_profile(create_name_with_run_id("TestProfileServiceVpn"), "Description").id
-        cls.vpn_parcel_uuid = cls.api.create_parcel(
-            cls.profile_uuid,
-            LanVpnParcel(
-                parcel_name="TestVpnParcel", parcel_description="Test Vpn Parcel", vpn_id=Global[int](value=2)
-            ),
-        ).id
-
-    def test_update_interface(self):
-        # Arrange
-        svi_parcel = InterfaceSviParcel(
-            parcel_name="TestSviParcel_ToUpdate",
-            parcel_description="Test Svi Parcel",
-            interface_name=as_global("Vlan1"),
-            svi_description=as_global("Test Svi Description"),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, svi_parcel, self.vpn_parcel_uuid).id
-        parcel = self.api.get_parcel(self.profile_uuid, InterfaceSviParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid)
-        assert isinstance(parcel.payload, InterfaceSviParcel)
-        assert parcel.payload == svi_parcel
-        # Assert
-        svi_parcel.svi_description = as_global("Updated Svi Description")
-        parcel_id = self.api.update_parcel(
-            self.profile_uuid, InterfaceSviParcel, parcel_id, svi_parcel, vpn_uuid=self.vpn_parcel_uuid
-        ).id
-        parcel = self.api.get_parcel(self.profile_uuid, InterfaceSviParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid)
-        assert isinstance(parcel.payload, InterfaceSviParcel)
-        assert parcel.payload == svi_parcel
-
-        # Cleanup
-        self.api.delete_parcel(self.profile_uuid, InterfaceSviParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid)
-
-    def test_when_default_values_gre_parcel_expect_successful_post(self):
-        # Arrange
-        gre_parcel = InterfaceGreParcel(
-            parcel_name="TestGreParcel",
-            parcel_description="Test Gre Parcel",
-            basic=BasicGre(
-                if_name=as_global("gre1"),
-                address=AddressWithMask(
-                    address=as_global("1.1.1.1"),
-                    mask=as_global("255.255.255.0"),
-                ),
-                tunnel_destination=as_global(IPv4Address("4.4.4.4")),
-            ),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, gre_parcel, self.vpn_parcel_uuid).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, InterfaceGreParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid)
-        assert isinstance(parcel.payload, InterfaceGreParcel)
-        assert parcel.payload == gre_parcel
-
-    def test_when_default_values_svi_parcel_expect_successful_post(self):
-        # Arrange
-        svi_parcel = InterfaceSviParcel(
-            parcel_name="TestSviParcel",
-            parcel_description="Test Svi Parcel",
-            interface_name=as_global("Vlan1"),
-            svi_description=as_global("Test Svi Description"),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, svi_parcel, self.vpn_parcel_uuid).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, InterfaceSviParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid)
-        assert isinstance(parcel.payload, InterfaceSviParcel)
-        assert parcel.payload == svi_parcel
-
-    def test_when_default_values_ethernet_parcel_expect_successful_post(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcel",
-            parcel_description="Test Ethernet Parcel",
-            interface_name=as_global("HundredGigE"),
-            ethernet_description=as_global("Test Ethernet Description"),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_set_dynamic_interface_ip_address_for_ethernet_parcel(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcelSets",
-            interface_name=as_global("HundredGigE"),
-        )
-        ethernet_parcel.set_dynamic_interface_ip_address(as_global(123))
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_set_dynamic_interface_ip_address_as_variable_for_ethernet_parcel(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcelVariable",
-            interface_name=as_global("HundredGigE"),
-        )
-        ethernet_parcel.set_dynamic_interface_ip_address(as_variable("address"))
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_set_primary_static_interface_ip_address_for_ethernet_parcel(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcelPrimaryStaticOne",
-            interface_name=as_global("HundredGigE"),
-        )
-        ethernet_parcel.set_static_primary_interface_ip_address(as_global("1.1.1.1"))
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_set_primary_static_interface_ip_address_as_variable_for_ethernet_parcel(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcelPrimaryStaticVariable",
-            interface_name=as_global("HundredGigE"),
-        )
-        ethernet_parcel.set_static_primary_interface_ip_address(as_variable("address"))
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_set_primary_static_with_mask_interface_ip_address_for_ethernet_parcel(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcelPrimaryStaticMask",
-            interface_name=as_global("HundredGigE"),
-        )
-        ethernet_parcel.set_static_primary_interface_ip_address(as_global("1.1.1.1"))
-        ethernet_parcel.add_static_secondary_interface_ip_address(as_global("3.3.3.3"), as_global("255.255.255.128"))
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_set_primary_static_with_mask_interface_ip_address_as_varialbles_for_ethernet_parcel(self):
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            parcel_name="TestEthernetParcelPrimaryStaticMaskVariable",
-            interface_name=as_global("HundredGigE"),
-        )
-        ethernet_parcel.set_static_primary_interface_ip_address(as_variable("static_ip_address"))
-        ethernet_parcel.add_static_secondary_interface_ip_address(
-            as_variable("second_ip_address"), as_variable("second_mask")
-        )
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    def test_when_default_values_ipsec_parcel_expect_successful_post(self):
-        # Arrange
-        ipsec_parcel = InterfaceIpsecParcel(
-            parcel_name="TestIpsecParcel",
-            parcel_description="Test Ipsec Parcel",
-            interface_name=as_global("ipsec2"),
-            ipsec_description=as_global("Test Ipsec Description"),
-            pre_shared_secret=as_global("123"),
-            ike_local_id=as_global("123"),
-            ike_remote_id=as_global("123"),
-            application=as_variable("{{ipsec_application}}"),
-            tunnel_source_interface=as_variable("{{ipsec_ipsecSourceInterface}}"),
-            address=AddressWithMask(address=as_global("10.0.0.1"), mask=as_global("255.255.255.0")),
-            tunnel_destination=AddressWithMask(address=as_global("10.0.0.5"), mask=as_global("255.255.255.0")),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, ipsec_parcel, self.vpn_parcel_uuid).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, InterfaceIpsecParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid)
-        assert isinstance(parcel.payload, InterfaceIpsecParcel)
-        assert parcel.payload == ipsec_parcel
-
-    def test_when_routing_parcel_and_vpn_uuid_present_expect_create_then_assign_to_vpn(self):
-        # Arrange
-        multicast_parcel = MulticastParcel(
-            parcel_name="TestMulticastParcel",
-            parcel_description="Test Multicast Parcel",
-            basic=MulticastBasicAttributes(),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, multicast_parcel, self.vpn_parcel_uuid).id
-        # Assert
-        parcel = self.api.get_parcel(self.profile_uuid, MulticastParcel, parcel_id)
-        assert isinstance(parcel.payload, MulticastParcel)
-        assert parcel.payload == multicast_parcel
-
-    def test_when_fully_specified_multilink_interface_parcel_expect_successful_post(self):
-        nim_list = [
-            MultilinkNimList(
-                if_name=Global[str](value="Serial1"),
-                bandwidth=Global[int](value=10),
-                clock_rate=Global[ClockRate](value="1200"),
-                description=Global[str](value="desc"),
-            ),
-            MultilinkNimList(
-                if_name=Global[str](value="Serial2"),
-                bandwidth=Global[int](value=12),
-                clock_rate=Global[ClockRate](value="115200"),
-                description=None,
-            ),
-        ]
-        controller_tx_ex_list = [
-            MultilinkControllerTxExList(
-                channel_group=[
-                    ChannelGroup(
-                        number=Global[int](value=12),
-                        timeslots=Global[str](value="12"),
-                    )
-                ],
-                number=Global[str](value="1/1/1"),
-                clock_source=Global[MultilinkClockSource](value="internal"),
-                description=Global[str](value="desc"),
-                e1_framing=Global[E1Framing](value="crc4"),
-                e1_linecode=Global[E1Linecode](value="ami"),
-                line_mode=Global[LineMode](value="primary"),
-                long=None,
-                name=Global[MultilinkTxExName](value="E1"),
-                short=None,
-                t1_framing=None,
-                t1_linecode=None,
-            ),
-            MultilinkControllerTxExList(
-                channel_group=[
-                    ChannelGroup(
-                        number=Global[int](value=13),
-                        timeslots=Global[str](value="13"),
-                    )
-                ],
-                number=Global[str](value="2/2/2"),
-                clock_source=Global[MultilinkClockSource](value="loop-timed"),
-                description=Global[str](value="desc"),
-                e1_framing=None,
-                e1_linecode=None,
-                line_mode=Global[LineMode](value="secondary"),
-                long=Global[CableLengthLongValue](value="-15db"),
-                name=Global[MultilinkTxExName](value="T1"),
-                short=None,
-                t1_framing=Global[T1Framing](value="esf"),
-                t1_linecode=Global[T1Linecode](value="ami"),
-            ),
-        ]
-
-        multilink_parcel = InterfaceMultilinkParcel(
-            parcel_name="Test",
-            parcel_description="Description",
-            group_number=Global[int](value=299),
-            if_name=Global[str](value="Multilink1"),
-            method=Global[Literal[MultilinkMethod]](value="CHAP"),
-            address_ipv4=Global[IPv4Address](value=IPv4Address("192.175.48.4")),
-            address_ipv6=Global[IPv6Interface](value=IPv6Interface("::3e46/100")),
-            authentication_type=Default[Literal[MultilinkAuthenticationType]](value="unidirectional"),
-            bandwidth_upstream=Global[int](value=21),
-            clear_dont_fragment_sdwan_tunnel=Global[bool](value=True),
-            control_connections=Global[bool](value=False),
-            controller_tx_ex_list=controller_tx_ex_list,
-            controller_type=Global[Literal[MultilinkControllerType]](value="T1/E1"),
-            delay_value=Global[int](value=99),
-            disable=Global[bool](value=True),
-            hostname=Global[str](value="oitSeZBfw"),
-            interleave=Global[bool](value=False),
-            ip_directed_broadcast=Global[bool](value=True),
-            ipv4_acl_egress=None,
-            ipv4_acl_ingress=None,
-            ipv6_acl_egress=None,
-            ipv6_acl_ingress=None,
-            mask_ipv4=Global[SubnetMask](value="255.255.255.254"),
-            mtu=Global[int](value=5266),
-            nim_list=nim_list,
-            password=Global[str](value="hyBBiuDgO"),
-            ppp_auth_password=Global[str](value="aCBBBxnzsw"),
-            shaping_rate=Global[int](value=294),
-            shutdown=Global[bool](value=False),
-            tcp_mss_adjust=Global[int](value=1267),
-            tloc_extension=Global[str](value="ATM"),
-            username_string=Global[str](value="ONBBAAB"),
-        )
-
-        parcel_id = self.api.create_parcel(self.profile_uuid, multilink_parcel, self.vpn_parcel_uuid).id
-
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceMultilinkParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceMultilinkParcel)
-        assert parcel.payload == multilink_parcel
-
-    def test_when_default_values_ethernet_interface_expect_successful_post(self):
-        # For 20.13 when we send "advanced.intfruMtu" as Default 1500
-        # endpoint returns 400
-        # catalystwan.exceptions.ManagerHTTPError:
-        # message='Invalid Payload'
-        # details="Invalid Payload: doesn't support user settable interface mtu for sub interface"
-        # code='PPARC0012'
-
-        # Arrange
-        ethernet_parcel = InterfaceEthernetParcel(
-            name="vedge-C8000V_interface_*GigabitEthernet3.2*_FT_84.xml",
-            description="interface_Description",
-            interface_name=as_global("GigabitEthernet3.2"),
-        )
-        # Act
-        parcel_id = self.api.create_parcel(self.profile_uuid, ethernet_parcel, self.vpn_parcel_uuid).id
-        # Assert
-        parcel = self.api.get_parcel(
-            self.profile_uuid, InterfaceEthernetParcel, parcel_id, vpn_uuid=self.vpn_parcel_uuid
-        )
-        assert isinstance(parcel.payload, InterfaceEthernetParcel)
-        assert parcel.payload == ethernet_parcel
-
-    @classmethod
-    def tearDownClass(cls) -> None:
-        cls.api.delete_profile(cls.profile_uuid)
-        super().tearDownClass()