catalystwan 0.41.2__py3-none-any.whl → 0.41.2.dev0__py3-none-any.whl

catalystwan/integration_tests/feature_profile/sdwan/topology/test_topology.py

@@ -0,0 +1,93 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from ipaddress import IPv4Address
+from uuid import UUID
+
+from catalystwan.api.configuration_groups.parcel import as_global
+from catalystwan.api.feature_profile_api import ServiceFeatureProfileAPI, TopologyFeatureProfileAPI
+from catalystwan.integration_tests.base import TestCaseBase, create_name_with_run_id
+from catalystwan.models.configuration.feature_profile.sdwan.service.lan.vpn import LanVpnParcel
+from catalystwan.models.configuration.feature_profile.sdwan.topology.custom_control import CustomControlParcel
+from catalystwan.models.configuration.feature_profile.sdwan.topology.hubspoke import HubSpokeParcel
+from catalystwan.models.configuration.feature_profile.sdwan.topology.mesh import MeshParcel
+
+
+class TestTopologyFeatureProfile(TestCaseBase):
+    topology_api: TopologyFeatureProfileAPI
+    topology_profile_id: UUID
+    service_api: ServiceFeatureProfileAPI
+    service_profile_id: UUID
+    lanvpn_parcel_name: str
+    lanvpn_parcel_id: UUID
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.topology_api = cls.session.api.sdwan_feature_profiles.topology
+        cls.topology_profile_id = cls.topology_api.create_profile(
+            create_name_with_run_id("TestTopologyProfile"), "Description"
+        ).id
+        # preconditions
+        cls.lanvpn_parcel_name = "VPN-1"
+        cls.service_api = cls.session.api.sdwan_feature_profiles.service
+        cls.service_profile_id = cls.service_api.create_profile(
+            create_name_with_run_id("PreconditionServiceProfile"), "Description"
+        ).id
+        lanvpn_parcel = LanVpnParcel(
+            parcel_name=cls.lanvpn_parcel_name,
+            parcel_description="Test Vpn Parcel",
+            vpn_id=as_global(2),
+        )
+        cls.lanvpn_parcel_id = cls.service_api.create_parcel(cls.service_profile_id, lanvpn_parcel).id
+
+    def test_mesh(self):
+        mesh = MeshParcel(parcel_name="MeshParcel-1")
+        mesh.add_target_vpn(self.lanvpn_parcel_name)
+        mesh.add_site("SITE-1")
+        # create
+        mesh_id = self.topology_api.create_parcel(self.topology_profile_id, mesh).id
+        # get
+        self.topology_api.get_parcel(self.topology_profile_id, MeshParcel, mesh_id)
+        # delete
+        self.topology_api.delete_parcel(self.topology_profile_id, MeshParcel, mesh_id)
+
+    def test_hubspoke(self):
+        hubspoke = HubSpokeParcel(parcel_name="HubSpokeParcel-1")
+        spoke = hubspoke.add_spoke(name="Spoke-1", spoke_sites=["SITE-1"])
+        spoke.add_spoke_site("SITE-2")
+        spoke.add_hub_site(["SITE-3"], preference=100891)
+        hubspoke.add_target_vpn(self.lanvpn_parcel_name)
+        hubspoke.add_selected_hub("HUB-1")
+        # create
+        hubspoke_id = self.topology_api.create_parcel(self.topology_profile_id, hubspoke).id
+        # get
+        self.topology_api.get_parcel(self.topology_profile_id, HubSpokeParcel, hubspoke_id)
+        # delete
+        self.topology_api.delete_parcel(self.topology_profile_id, HubSpokeParcel, hubspoke_id)
+
+    def test_custom_control(self):
+        cc = CustomControlParcel(parcel_name="CustomControlParcel-1")
+        cc.set_default_action("accept")
+        cc.assign_target_sites(inbound_sites=["SITE-1"], outbound_sites=[], _dummy_vpns=[self.lanvpn_parcel_name])
+        s = cc.add_sequence("my_sequence", 1, "route", "ipv4", "reject")
+        s.match_carrier("carrier4")
+        s.match_domain_id(555)
+        s.match_group_id(80)
+        s.match_omp_tag(999)
+        s.match_origin("eigrp-summary")
+        s.match_originator(IPv4Address("10.0.0.1"))
+        s.match_path_type("hierarchical-path")
+        s.match_preference(1000)
+        s.match_tloc(IPv4Address("10.0.0.1"), "biz-internet", "ipsec")
+        s.match_vpns([self.lanvpn_parcel_name])
+        # create
+        cc_id = self.topology_api.create_parcel(self.topology_profile_id, cc).id
+        # get
+        self.topology_api.get_parcel(self.topology_profile_id, CustomControlParcel, cc_id)
+        # delete
+        self.topology_api.delete_parcel(self.topology_profile_id, CustomControlParcel, cc_id)
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.topology_api.delete_profile(cls.topology_profile_id)
+        cls.service_api.delete_profile(cls.service_profile_id)
+        cls.session.close()

catalystwan/integration_tests/profile_builder/test_pb_service.py

@@ -0,0 +1,197 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from ipaddress import IPv4Address
+
+from catalystwan.api.configuration_groups.parcel import Global, as_global, as_variable
+from catalystwan.integration_tests.base import TestCaseBase, create_name_with_run_id
+from catalystwan.integration_tests.test_data import bgp_parcel, ospf_parcel, ospfv3ipv4_parcel, ospfv3ipv6_parcel
+from catalystwan.models.common import SubnetMask
+from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
+from catalystwan.models.configuration.feature_profile.sdwan.service.dhcp_server import (
+    AddressPool,
+    LanVpnDhcpServerParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.service.lan.ethernet import InterfaceEthernetParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service.lan.vpn import LanVpnParcel
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
+
+
+class TestServiceFeatureProfileBuilder(TestCaseBase):
+    def setUp(self) -> None:
+        self.fp_name = create_name_with_run_id("FeatureProfileBuilderService")
+        self.fp_description = "Transport feature profile"
+        self.builder = self.session.api.builders.feature_profiles.create_builder("service")
+        self.builder.add_profile_name_and_description(
+            feature_profile=FeatureProfileCreationPayload(name=self.fp_name, description=self.fp_description)
+        )
+        self.api = self.session.api.sdwan_feature_profiles.service
+
+    def test_when_build_profile_with_vpn_and_interface_with_dhcp_expect_success(self):
+        # Arrange
+        service_vpn_parcel = LanVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+            vpn_id=as_global(50),
+        )
+        ethernet_parcel = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        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"),
+            ),
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel)
+        self.builder.add_parcel_dhcp_server(ethernet_parcel.parcel_name, dhcp_server_parcel)
+        # Act
+        report = self.builder.build()
+        # Assert
+        assert len(report.failed_parcels) == 0
+
+    def test_when_build_profile_with_vpn_and_routing_attached_expect_success(self):
+        # Arrange
+        service_vpn_parcel = LanVpnParcel(
+            parcel_name="MinimumSpecifiedServiceVpnParcel",
+            description="Description",
+            vpn_id=as_global(50),
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, ospf_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, ospfv3ipv4_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, ospfv3ipv6_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, bgp_parcel)
+        # Act
+        report = self.builder.build()
+        # Assert
+        assert len(report.failed_parcels) == 0
+
+    def test_when_vpn_interfaces_and_attached_tracker_expect_success(self):
+        service_vpn_parcel = LanVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+            vpn_id=as_global(50),
+        )
+        ethernet_parcel = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        ethernet_tag = self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel)
+        tracker = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        self.builder.add_tracker(associate_tags=[ethernet_tag], tracker=tracker)
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
+    def test_when_vpn_interfaces_and_attached_tracker_group_expect_success(self):
+        service_vpn_parcel = LanVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+            vpn_id=as_global(50),
+        )
+        ethernet_parcel = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        ethernet_tag = self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel)
+        tracker1 = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker2 = Tracker(
+            parcel_name="TestTracker2",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker2"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[],
+        )
+        self.builder.add_tracker_group(
+            associate_tags=[ethernet_tag], group=tracker_group, trackers=[tracker1, tracker2]
+        )
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
+    def test_when_shared_tracker_expect_success(self):
+        service_vpn_parcel = LanVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+            vpn_id=as_global(50),
+        )
+        ethernet_parcel_1 = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel1",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        ethernet_parcel_2 = InterfaceEthernetParcel(
+            parcel_name="TestEthernetParcel2",
+            parcel_description="Test Ethernet Parcel",
+            interface_name=as_global("HundredGigE"),
+            ethernet_description=as_global("Test Ethernet Description"),
+            shutdown=as_variable("{{vpn1_gi3_lan_ip_192.168.X.1/24_}}"),
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        ethernet_tag_1 = self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel_1)
+        ethernet_tag_2 = self.builder.add_parcel_vpn_subparcel(vpn_tag, ethernet_parcel_2)
+        tracker1 = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker2 = Tracker(
+            parcel_name="TestTracker2",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker2"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[],
+        )
+        self.builder.add_tracker_group(
+            associate_tags=[ethernet_tag_1], group=tracker_group, trackers=[tracker1, tracker2]
+        )
+        self.builder.add_tracker(associate_tags=[ethernet_tag_2], tracker=tracker2)
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
+    def tearDown(self) -> None:
+        target_profile = self.api.get_profiles().filter(profile_name=self.fp_name).single_or_default()
+        if target_profile:
+            # In case of a failed test, the profile might not have been created
+            self.api.delete_profile(target_profile.profile_id)

catalystwan/integration_tests/profile_builder/test_pb_transport.py

@@ -0,0 +1,226 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from ipaddress import IPv4Address
+from typing import Literal
+
+from catalystwan.api.configuration_groups.parcel import Global, Variable
+from catalystwan.integration_tests.base import TestCaseBase, create_name_with_run_id
+from catalystwan.integration_tests.test_data import (
+    bgp_parcel,
+    cellular_controller_parcel,
+    cellular_profile_parcel,
+    gps_parcel,
+    ospf_parcel,
+    ospfv3ipv4_parcel,
+    ospfv3ipv6_parcel,
+)
+from catalystwan.models.configuration.feature_profile.common import (
+    AddressWithMask,
+    AdvancedGre,
+    FeatureProfileCreationPayload,
+    SourceLoopback,
+    TunnelSourceType,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
+from catalystwan.models.configuration.feature_profile.sdwan.transport.vpn import TransportVpnParcel
+from catalystwan.models.configuration.feature_profile.sdwan.transport.wan.interface.cellular import (
+    InterfaceCellularParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.wan.interface.gre import Basic, InterfaceGreParcel
+
+
+class TestTransportFeatureProfileBuilder(TestCaseBase):
+    def setUp(self) -> None:
+        self.fp_name = create_name_with_run_id("FeatureProfileBuilderTransport")
+        self.fp_description = "Transport feature profile"
+        self.builder = self.session.api.builders.feature_profiles.create_builder("transport")
+        self.builder.add_profile_name_and_description(
+            feature_profile=FeatureProfileCreationPayload(name=self.fp_name, description=self.fp_description)
+        )
+        self.api = self.session.api.sdwan_feature_profiles.transport
+
+    def test_when_build_profile_with_cellular_controller_and_subelements_expect_success(self):
+        # Arrange
+        parent_tag = self.builder.add_parcel_cellular_controller(cellular_controller_parcel)
+        self.builder.add_cellular_controller_subparcel(parent_tag, cellular_profile_parcel)
+        self.builder.add_cellular_controller_subparcel(parent_tag, gps_parcel)
+        # Act
+        report = self.builder.build()
+        # Assert
+        assert len(report.failed_parcels) == 0
+
+    def test_when_build_profile_with_vpn_and_routing_attached_expect_success(self):
+        # Arrange
+        service_vpn_parcel = TransportVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, ospf_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, ospfv3ipv4_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, ospfv3ipv6_parcel)
+        self.builder.add_parcel_routing_attached(vpn_tag, bgp_parcel)
+        # Act
+        report = self.builder.build()
+        # Assert
+        assert len(report.failed_parcels) == 0
+
+    def test_when_vpn_interfaces_and_attached_tracker_expect_success(self):
+        service_vpn_parcel = TransportVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        gre_parcel = InterfaceGreParcel(
+            parcel_name="InterfaceGreParcel",
+            parcel_description="Description",
+            basic=Basic(
+                address=AddressWithMask(
+                    address=Global[IPv4Address](value=IPv4Address("39.5.0.97")),
+                    mask=Variable(value="{{QPg11165441vY1}}"),
+                ),
+                if_name=Global[str](value="gre23"),
+                tunnel_destination=Global[IPv4Address](value=IPv4Address("3.3.3.3")),
+                clear_dont_fragment=Global[bool](value=True),
+                description=Global[str](value="QsLBBBBBCF"),
+                mtu=Global[int](value=1500),
+                shutdown=Global[bool](value=True),
+                tcp_mss_adjust=Global[int](value=600),
+                tunnel_source_type=TunnelSourceType(
+                    source_loopback=SourceLoopback(
+                        tunnel_route_via=Global[str](value="xSVIxuF"),
+                        tunnel_source_interface=Global[str](value="YnBabgxBUm"),
+                    )
+                ),
+            ),
+            advanced=AdvancedGre(application=Global[Literal["none", "sig"]](value="sig")),
+        )
+        gre_tag = self.builder.add_vpn_subparcel(vpn_tag, gre_parcel)
+        tracker = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        self.builder.add_tracker(associate_tags=[gre_tag], tracker=tracker)
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
+    def test_when_vpn_interfaces_and_attached_tracker_group_expect_success(self):
+        service_vpn_parcel = TransportVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        cellular_parcel = InterfaceCellularParcel(
+            parcel_name="InterfaceCellularParcel",
+            parcel_description="Description",
+            encapsulation=[],
+            interface_description=Global[str](value="CkmMzlz"),
+            interface_name=Global[str](value="xnaohVUa"),
+            nat=Global[bool](value=True),
+            shutdown=Global[bool](value=False),
+            tunnel_interface=Global[bool](value=True),
+        )
+        cellular_tag = self.builder.add_vpn_subparcel(vpn_tag, cellular_parcel)
+        tracker1 = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker2 = Tracker(
+            parcel_name="TestTracker2",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker2"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[],
+        )
+        self.builder.add_tracker_group(
+            associate_tags=[cellular_tag], group=tracker_group, trackers=[tracker1, tracker2]
+        )
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
+    def test_when_shared_tracker_expect_success(self):
+        service_vpn_parcel = TransportVpnParcel(
+            parcel_name="MinimumSpecifiedTransportVpnParcel",
+            description="Description",
+        )
+        vpn_tag = self.builder.add_parcel_vpn(service_vpn_parcel)
+        gre_parcel = InterfaceGreParcel(
+            parcel_name="InterfaceGreParcel",
+            parcel_description="Description",
+            basic=Basic(
+                address=AddressWithMask(
+                    address=Global[IPv4Address](value=IPv4Address("39.5.0.97")),
+                    mask=Variable(value="{{QPg11165441vY1}}"),
+                ),
+                if_name=Global[str](value="gre23"),
+                tunnel_destination=Global[IPv4Address](value=IPv4Address("3.3.3.3")),
+                clear_dont_fragment=Global[bool](value=True),
+                description=Global[str](value="QsLBBBBBCF"),
+                mtu=Global[int](value=1500),
+                shutdown=Global[bool](value=True),
+                tcp_mss_adjust=Global[int](value=600),
+                tunnel_source_type=TunnelSourceType(
+                    source_loopback=SourceLoopback(
+                        tunnel_route_via=Global[str](value="xSVIxuF"),
+                        tunnel_source_interface=Global[str](value="YnBabgxBUm"),
+                    )
+                ),
+            ),
+            advanced=AdvancedGre(application=Global[Literal["none", "sig"]](value="sig")),
+        )
+        gre_tag = self.builder.add_vpn_subparcel(vpn_tag, gre_parcel)
+        cellular_parcel = InterfaceCellularParcel(
+            parcel_name="InterfaceCellularParcel",
+            parcel_description="Description",
+            encapsulation=[],
+            interface_description=Global[str](value="CkmMzlz"),
+            interface_name=Global[str](value="xnaohVUa"),
+            nat=Global[bool](value=True),
+            shutdown=Global[bool](value=False),
+            tunnel_interface=Global[bool](value=True),
+        )
+        cellular_tag = self.builder.add_vpn_subparcel(vpn_tag, cellular_parcel)
+        tracker1 = Tracker(
+            parcel_name="TestTracker1",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker1"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker2 = Tracker(
+            parcel_name="TestTracker2",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker2"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[],
+        )
+        self.builder.add_tracker_group(
+            associate_tags=set([cellular_tag]), group=tracker_group, trackers=[tracker1, tracker2]
+        )
+        self.builder.add_tracker(associate_tags=set([gre_tag]), tracker=tracker1)
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0
+
+    def tearDown(self) -> None:
+        target_profile = self.api.get_profiles().filter(profile_name=self.fp_name).single_or_default()
+        if target_profile:
+            # In case of a failed test, the profile might not have been created
+            self.api.delete_profile(target_profile.profile_id)