catalystwan 0.41.0.dev0__tar.gz → 0.41.0.dev1__tar.gz

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: catalystwan
-Version: 0.41.0.dev0
+Version: 0.41.0.dev1
 Summary: Cisco Catalyst WAN SDK for Python
 Author: kagorski
 Author-email: kagorski@cisco.com

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/catalystwan/api/builders/feature_profiles/service.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import logging
 from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
 from uuid import UUID, uuid4
 
 from pydantic import Field
@@ -30,6 +30,7 @@ from catalystwan.models.configuration.feature_profile.sdwan.service import (
     LanVpnParcel,
 )
 from catalystwan.models.configuration.feature_profile.sdwan.service.multicast import MulticastParcel
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import AnyTrackerParcel, Tracker, TrackerGroup
 
 if TYPE_CHECKING:
     from catalystwan.session import ManagerSession
@@ -61,9 +62,12 @@ class ServiceFeatureProfileBuilder:
         self._endpoints = ServiceFeatureProfile(session)
         self._independent_items: List[IndependedParcels] = []
         self._independent_items_vpns: Dict[UUID, LanVpnParcel] = {}
-        self._dependent_items_on_vpns: Dict[UUID, List[DependedVpnSubparcels]] = defaultdict(list)
+        self._dependent_items_on_vpns: Dict[UUID, List[Tuple[UUID, DependedVpnSubparcels]]] = defaultdict(list)
         self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
         self._interfaces_with_attached_dhcp_server: Dict[str, LanVpnDhcpServerParcel] = {}
+        self._trackers: List[Tuple[Set[UUID], AnyTrackerParcel]] = []
+        self._tracker_groups: List[Tuple[Set[UUID], TrackerGroup, List[Tracker]]] = []
+        self._interface_tag_to_existing_tracker: Dict[UUID, Tuple[UUID, str]] = {}
 
     def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
         """
@@ -119,7 +123,7 @@ class ServiceFeatureProfileBuilder:
         logger.debug(f"Adding routing parcel {parcel.parcel_name} to VPN {vpn_tag}")
         self._dependent_routing_items_on_vpns[vpn_tag].append(parcel)
 
-    def add_parcel_vpn_subparcel(self, vpn_tag: UUID, parcel: DependedVpnSubparcels) -> None:
+    def add_parcel_vpn_subparcel(self, vpn_tag: UUID, parcel: DependedVpnSubparcels) -> UUID:
         """
         Adds an subparcel parcel dependent on a VPN to the builder.
 
@@ -130,8 +134,11 @@ class ServiceFeatureProfileBuilder:
         Returns:
             None
         """
-        logger.debug(f"Adding subparcel parcel {parcel.parcel_name} to VPN {vpn_tag}")
-        self._dependent_items_on_vpns[vpn_tag].append(parcel)
+
+        subparcel_tag = uuid4()
+        logger.debug(f"Adding vpn sub-parcel {parcel.parcel_name} with tag {subparcel_tag}")
+        self._dependent_items_on_vpns[vpn_tag].append((subparcel_tag, parcel))
+        return subparcel_tag
 
     def add_parcel_dhcp_server(self, interface_parcel_name: str, parcel: LanVpnDhcpServerParcel) -> None:
         """
@@ -147,6 +154,22 @@ class ServiceFeatureProfileBuilder:
         logger.debug(f"Adding DHCP server parcel {parcel.parcel_name} to interface {interface_parcel_name}")
         self._interfaces_with_attached_dhcp_server[interface_parcel_name] = parcel
 
+    def add_tracker(self, associate_tags: Set[UUID], parcel: AnyTrackerParcel) -> None:
+        """
+        Adds a tracker parcel to the feature profile.
+
+        Args:
+            associate_tags (Set[UUID]): The UUIDs of the interfaces to which the tracker should be added.
+            parcel (AnyTrackerParcel): The tracker parcel to add.
+
+        Returns:
+            None
+        """
+        self._trackers.append((associate_tags, parcel))
+
+    def add_tracker_group(self, associate_tags: Set[UUID], group: TrackerGroup, trackers: List[Tracker]) -> None:
+        self._tracker_groups.append((associate_tags, group, trackers))
+
     def build(self) -> FeatureProfileBuildReport:
         """
         Builds the feature profile by creating parcels for independent items,
@@ -159,6 +182,28 @@ class ServiceFeatureProfileBuilder:
         self.build_report = FeatureProfileBuildReport(profile_uuid=profile_uuid, profile_name=self._profile.name)
         for parcel in self._independent_items:
             self._create_parcel(profile_uuid, parcel)
+
+        for tracker_group_tags, tracker_group, trackers in self._tracker_groups:
+            trackers_uuids: List[UUID] = []
+            for tracker_ in trackers:
+                tracker_uuid = self._create_parcel(profile_uuid, tracker_)
+                if tracker_uuid:
+                    trackers_uuids.append(tracker_uuid)
+
+            for tracker_uuid in trackers_uuids:
+                tracker_group.add_ref(tracker_uuid)
+
+            tracker_group_uuid = self._create_parcel(profile_uuid, tracker_group)
+            if tracker_group_uuid:
+                for tag in tracker_group_tags:
+                    self._interface_tag_to_existing_tracker[tag] = tracker_group_uuid, tracker_group._get_parcel_type()
+
+        for tracker_tags, tracker in self._trackers:
+            tracker_uuid = self._create_parcel(profile_uuid, tracker)
+            if tracker_uuid:
+                for tag in tracker_tags:
+                    self._interface_tag_to_existing_tracker[tag] = (tracker_uuid, tracker._get_parcel_type())
+
         for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
             vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
 
@@ -176,35 +221,41 @@ class ServiceFeatureProfileBuilder:
                         payload=ParcelAssociationPayload(parcel_id=routing_uuid),
                     )
 
-            for sub_parcel in self._dependent_items_on_vpns[vpn_tag]:
+            for subparcel_tag, sub_parcel in self._dependent_items_on_vpns[vpn_tag]:
                 if vpn_uuid is None:
                     handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, sub_parcel)
                 else:
                     parcel_uuid = self._create_parcel(profile_uuid, sub_parcel, vpn_uuid)
                     dhcp_server = self._interfaces_with_attached_dhcp_server.get(sub_parcel.parcel_name)
-
-                    if dhcp_server is None:
-                        # The interface does not have a DHCP server attached
-                        continue
-
-                    if parcel_uuid is None:
+                    if parcel_uuid is None and dhcp_server:
                         # The parent could not be created
                         handle_build_report_for_failed_subparcel(self.build_report, sub_parcel, dhcp_server)
                         continue
 
-                    dhcp_server_uuid = self._create_parcel(profile_uuid, dhcp_server)
-
-                    if dhcp_server_uuid is None:
-                        # The DHCP server could not be created
-                        continue
-
-                    self._endpoints.associate_dhcp_server_with_vpn_interface(
-                        profile_uuid=profile_uuid,
-                        vpn_uuid=vpn_uuid,
-                        interface_parcel_type=sub_parcel._get_parcel_type().replace("lan/vpn/", ""),
-                        interface_uuid=parcel_uuid,
-                        payload=ParcelAssociationPayload(parcel_id=dhcp_server_uuid),
-                    )
+                    if dhcp_server:
+                        dhcp_server_uuid = self._create_parcel(profile_uuid, dhcp_server)
+                        if dhcp_server_uuid is not None:
+                            # The DHCP server could not be created
+                            self._endpoints.associate_dhcp_server_with_vpn_interface(
+                                profile_uuid=profile_uuid,
+                                vpn_uuid=vpn_uuid,
+                                interface_parcel_type=sub_parcel._get_parcel_type().replace("lan/vpn/", ""),
+                                interface_uuid=parcel_uuid,
+                                payload=ParcelAssociationPayload(parcel_id=dhcp_server_uuid),
+                            )
+
+                    # Associate tracker with VPN interface if it exists
+                    if subparcel_tag in self._interface_tag_to_existing_tracker and parcel_uuid:
+                        tracker_uuid, tracker_type = self._interface_tag_to_existing_tracker[subparcel_tag]
+                        sub_parcel_type = sub_parcel._get_parcel_type().replace("lan/vpn/", "")
+                        self._endpoints.associate_tracker_with_vpn_interface(
+                            profile_uuid,
+                            vpn_uuid,
+                            sub_parcel_type,
+                            parcel_uuid,
+                            tracker_type,
+                            ParcelAssociationPayload(parcel_id=tracker_uuid),
+                        )
 
         return self.build_report
 

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/catalystwan/api/builders/feature_profiles/transport.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import logging
 from collections import defaultdict
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Union
 from uuid import UUID, uuid4
 
 from catalystwan.api.builders.feature_profiles.report import (
@@ -16,6 +16,7 @@ from catalystwan.endpoints.configuration.feature_profile.sdwan.transport import
 from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload
 from catalystwan.models.configuration.feature_profile.parcel import ParcelAssociationPayload
 from catalystwan.models.configuration.feature_profile.sdwan.routing import AnyRoutingParcel
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
 from catalystwan.models.configuration.feature_profile.sdwan.transport import (
     AnyTransportParcel,
     AnyTransportSuperParcel,
@@ -53,11 +54,14 @@ class TransportAndManagementProfileBuilder:
         self._independent_items: List[AnyTransportSuperParcel] = []
         self._independent_items_vpns: Dict[UUID, AnyTransportVpnParcel] = {}
         self._independent_items_cellular_controllers: Dict[UUID, CellularControllerParcel] = {}
-        self._dependent_items_on_vpns: Dict[UUID, List[AnyTransportVpnSubParcel]] = defaultdict(list)
+        self._dependent_items_on_vpns: Dict[UUID, List[Tuple[UUID, AnyTransportVpnSubParcel]]] = defaultdict(list)
         self._dependent_routing_items_on_vpns: Dict[UUID, List[AnyRoutingParcel]] = defaultdict(list)
         self._dependent_items_on_cellular_controllers: Dict[
             UUID, List[Union[CellularProfileParcel, GpsParcel]]
         ] = defaultdict(list)
+        self._trackers: List[Tuple[Set[UUID], Tracker]] = []
+        self._tracker_groups: List[Tuple[Set[UUID], TrackerGroup, List[Tracker]]] = []
+        self._interface_tag_to_existing_tracker: Dict[UUID, Tuple[UUID, str]] = {}
 
     def add_profile_name_and_description(self, feature_profile: FeatureProfileCreationPayload) -> None:
         """
@@ -142,7 +146,7 @@ class TransportAndManagementProfileBuilder:
         """
         self._dependent_items_on_cellular_controllers[cellular_controller_tag].append(parcel)
 
-    def add_vpn_subparcel(self, vpn_tag: UUID, parcel: AnyTransportVpnSubParcel) -> None:
+    def add_vpn_subparcel(self, vpn_tag: UUID, parcel: AnyTransportVpnSubParcel) -> UUID:
         """
         Adds a parcel to the feature profile.
 
@@ -152,7 +156,26 @@ class TransportAndManagementProfileBuilder:
         Returns:
             None
         """
-        self._dependent_items_on_vpns[vpn_tag].append(parcel)
+        subparcel_tag = uuid4()
+        logger.debug(f"Adding vpn sub-parcel {parcel.parcel_name} with tag {vpn_tag}")
+        self._dependent_items_on_vpns[vpn_tag].append((subparcel_tag, parcel))
+        return subparcel_tag
+
+    def add_tracker(self, associate_tags: Set[UUID], parcel: Tracker) -> None:
+        """
+        Adds a tracker parcel to the feature profile.
+
+        Args:
+            associate_tags (Set[UUID]): The UUIDs of the interfaces to which the tracker should be added.
+            parcel (AnyTrackerParcel): The tracker parcel to add.
+
+        Returns:
+            None
+        """
+        self._trackers.append((associate_tags, parcel))
+
+    def add_tracker_group(self, associate_tags: Set[UUID], group: TrackerGroup, trackers: List[Tracker]) -> None:
+        self._tracker_groups.append((associate_tags, group, trackers))
 
     def build(self) -> FeatureProfileBuildReport:
         """
@@ -167,13 +190,47 @@ class TransportAndManagementProfileBuilder:
         for parcel in self._independent_items:
             self._create_parcel(profile_uuid, parcel)
 
+        for tracker_group_tags, tracker_group, trackers in self._tracker_groups:
+            trackers_uuids: List[UUID] = []
+            for tracker in trackers:
+                tracker_uuid = self._create_parcel(profile_uuid, tracker)
+                if tracker_uuid:
+                    trackers_uuids.append(tracker_uuid)
+
+            for tracker_uuid in trackers_uuids:
+                tracker_group.add_ref(tracker_uuid)
+
+            tracker_group_uuid = self._create_parcel(profile_uuid, tracker_group)
+            if tracker_group_uuid:
+                for tag in tracker_group_tags:
+                    self._interface_tag_to_existing_tracker[tag] = tracker_group_uuid, tracker_group._get_parcel_type()
+
+        for tracker_tags, tracker in self._trackers:
+            tracker_uuid = self._create_parcel(profile_uuid, tracker)
+            if tracker_uuid:
+                for tag in tracker_tags:
+                    self._interface_tag_to_existing_tracker[tag] = tracker_uuid, tracker._get_parcel_type()
+
         for vpn_tag, vpn_parcel in self._independent_items_vpns.items():
             vpn_uuid = self._create_parcel(profile_uuid, vpn_parcel)
-            for vpn_subparcel in self._dependent_items_on_vpns[vpn_tag]:
+            for vpn_subparcel_tag, vpn_subparcel in self._dependent_items_on_vpns[vpn_tag]:
                 if vpn_uuid is None:
                     handle_build_report_for_failed_subparcel(self.build_report, vpn_parcel, vpn_subparcel)
                 else:
-                    self._create_parcel(profile_uuid, vpn_subparcel, vpn_uuid)
+                    vpn_subparcel_uuid = self._create_parcel(profile_uuid, vpn_subparcel, vpn_uuid)
+
+                    # Associate tracker with VPN interface if it exists
+                    if vpn_subparcel_tag in self._interface_tag_to_existing_tracker and vpn_subparcel_uuid:
+                        tracker_uuid, tracker_type = self._interface_tag_to_existing_tracker[vpn_subparcel_tag]
+                        vpn_subparcel_type = vpn_subparcel._get_parcel_type().replace("wan/vpn/", "")
+                        self._endpoints.associate_tracker_with_vpn_interface(
+                            profile_uuid,
+                            vpn_uuid,
+                            vpn_subparcel_type,
+                            vpn_subparcel_uuid,
+                            tracker_type,
+                            ParcelAssociationPayload(parcel_id=tracker_uuid),
+                        )
 
             for routing_parcel in self._dependent_routing_items_on_vpns[vpn_tag]:
                 if vpn_uuid is None:

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/catalystwan/api/template_api.py

@@ -380,6 +380,9 @@ class TemplatesAPI:
         if isinstance(template, DeviceTemplate):
             return self._edit_device_template(template)
 
+        if isinstance(template, CLITemplate):
+            return self._edit_cli_template(template, template_info)
+
         raise NotImplementedError()
 
     def _edit_device_template(self, template: DeviceTemplate):
@@ -398,6 +401,11 @@ class TemplatesAPI:
         response = self.session.put(f"/dataservice/template/feature/{data.id}", json=payload)
         return response
 
+    def _edit_cli_template(self, template: CLITemplate, data: TemplateInformation) -> ManagerResponse:
+        response = self.session.put(f"/dataservice/template/device/{data.id}", json=template.generate_payload())
+
+        return response
+
     @overload
     def create(self, template: FeatureTemplate, debug=False) -> str:
         ...

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/catalystwan/endpoints/configuration/feature_profile/sdwan/service.py

@@ -94,6 +94,23 @@ class ServiceFeatureProfile(APIEndpoints):
     ) -> ParcelCreationResponse:
         ...
 
+    # Tracker, TrackerGroup, IPv6Tracker, TrackerGroupIPv6
+    @versions(supported_versions=(">=20.9"), raises=False)
+    @post(
+        "/v1/feature-profile/sdwan/service/{profile_uuid}/lan/vpn/"
+        "{vpn_uuid}/{interface_parcel_type}/{interface_uuid}/{tracker_type}"
+    )
+    def associate_tracker_with_vpn_interface(
+        self,
+        profile_uuid: UUID,
+        vpn_uuid: UUID,
+        interface_parcel_type: str,
+        interface_uuid: UUID,
+        tracker_type: str,
+        payload: ParcelAssociationPayload,
+    ) -> ParcelCreationResponse:
+        ...
+
     @versions(supported_versions=(">=20.9"), raises=False)
     @post("/v1/feature-profile/sdwan/service/{profile_id}/lan/vpn/{vpn_id}/{parcel_type}")
     def associate_with_vpn(

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/catalystwan/endpoints/configuration/feature_profile/sdwan/transport.py

@@ -212,3 +212,20 @@ class TransportFeatureProfile(APIEndpoints):
         self, profile_id: UUID, vpn_id: UUID, parcel_type: str, payload: ParcelAssociationPayload
     ) -> ParcelCreationResponse:
         ...
+
+    # Tracker, TrackerGroup, IPv6Tracker, TrackerGroupIPv6
+    @versions(supported_versions=(">=20.9"), raises=False)
+    @post(
+        "/v1/feature-profile/sdwan/transport/{profile_uuid}/wan/vpn/"
+        "{vpn_uuid}/{interface_parcel_type}/{interface_uuid}/{tracker_type}"
+    )
+    def associate_tracker_with_vpn_interface(
+        self,
+        profile_uuid: UUID,
+        vpn_uuid: UUID,
+        interface_parcel_type: str,
+        interface_uuid: UUID,
+        tracker_type: str,
+        payload: ParcelAssociationPayload,
+    ) -> ParcelCreationResponse:
+        ...

catalystwan-0.41.0.dev1/catalystwan/integration_tests/feature_profile/sdwan/test_tracker.py

@@ -0,0 +1,127 @@
+# Copyright 2025 Cisco Systems, Inc. and its affiliates
+from catalystwan.api.configuration_groups.parcel import Global
+from catalystwan.api.feature_profile_api import ServiceFeatureProfileAPI, TransportFeatureProfileAPI
+from catalystwan.integration_tests.base import TestCaseBase, create_name_with_run_id
+from catalystwan.models.configuration.feature_profile.common import RefIdItem
+from catalystwan.models.configuration.feature_profile.sdwan.trackers import Tracker, TrackerGroup
+from catalystwan.models.configuration.feature_profile.sdwan.trackers.tracker_group import TrackerRefs
+
+
+class TestTransportFeatureProfileTracker(TestCaseBase):
+    api: TransportFeatureProfileAPI
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.api = cls.session.api.sdwan_feature_profiles.transport
+        cls.profile_uuid = cls.api.create_profile(create_name_with_run_id("TestTransportModels"), "Description").id
+
+    def test_create_tracker(self):
+        tracker = Tracker(
+            parcel_name="TestTracker",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+
+        response = self.api.create_parcel(self.profile_uuid, tracker)
+
+        assert response
+
+    def test_create_tracker_group(self):
+        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"),
+        )
+
+        tracker1_uuid = self.api.create_parcel(self.profile_uuid, tracker1).id
+        tracker2_uuid = self.api.create_parcel(self.profile_uuid, tracker2).id
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[
+                TrackerRefs(tracker_ref=RefIdItem(ref_id=Global[str](value=str(tracker1_uuid)))),
+                TrackerRefs(tracker_ref=RefIdItem(ref_id=Global[str](value=str(tracker2_uuid)))),
+            ],
+        )
+
+        response = self.api.create_parcel(self.profile_uuid, tracker_group)
+
+        assert response
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.api.delete_profile(cls.profile_uuid)
+        super().tearDownClass()
+
+
+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_create_tracker(self):
+        tracker = Tracker(
+            parcel_name="TestTracker",
+            parcel_description="Test Tracker Description",
+            tracker_name=Global[str](value="TestTracker"),
+            interval=Global[int](value=100),
+            endpoint_api_url=Global[str](value="https://example.com/api"),
+        )
+
+        response = self.api.create_parcel(self.profile_uuid, tracker)
+
+        assert response
+
+    def test_create_tracker_group(self):
+        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"),
+        )
+
+        tracker1_uuid = self.api.create_parcel(self.profile_uuid, tracker1).id
+        tracker2_uuid = self.api.create_parcel(self.profile_uuid, tracker2).id
+        tracker_group = TrackerGroup(
+            parcel_name="TestTrackerGroup",
+            parcel_description="Test Tracker Group Description",
+            tracker_refs=[
+                TrackerRefs(tracker_ref=RefIdItem(ref_id=Global[str](value=str(tracker1_uuid)))),
+                TrackerRefs(tracker_ref=RefIdItem(ref_id=Global[str](value=str(tracker2_uuid)))),
+            ],
+        )
+
+        response = self.api.create_parcel(self.profile_uuid, tracker_group)
+
+        assert response
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.api.delete_profile(cls.profile_uuid)
+        super().tearDownClass()

{catalystwan-0.41.0.dev0 → catalystwan-0.41.0.dev1}/catalystwan/integration_tests/profile_builder/test_pb_service.py

@@ -12,6 +12,7 @@ from catalystwan.models.configuration.feature_profile.sdwan.service.dhcp_server
 )
 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):
@@ -71,6 +72,74 @@ class TestServiceFeatureProfileBuilder(TestCaseBase):
         # 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], parcel=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 tearDown(self) -> None:
         target_profile = self.api.get_profiles().filter(profile_name=self.fp_name).single_or_default()
         if target_profile: