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

catalystwan/integration_tests/profile_builder/test_pb_uc_voice.py

@@ -0,0 +1,277 @@
+# Copyright 2025 Cisco Systems, Inc. and its affiliates
+from uuid import uuid4
+
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, as_global, as_variable
+from catalystwan.integration_tests.base import TestCaseBase
+from catalystwan.models.configuration.feature_profile.common import FeatureProfileCreationPayload, RefIdItem
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice import (
+    AnalogInterfaceParcel,
+    MediaProfileParcel,
+    SrstParcel,
+    TranslationProfileParcel,
+    TranslationRuleParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.analog_interface import (
+    Association as AnalogAssociation,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.analog_interface import ModuleType, SlotId
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.call_routing import (
+    Association as CallRoutingAssociation,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.call_routing import CallRoutingParcel
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.digital_interface import (
+    Association as DigitalInterfaceAssociation,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.digital_interface import (
+    BasicSettings,
+    CableLengthType,
+    CableLengthValue,
+    DigitalInterfaceParcel,
+    Framing,
+    LineCode,
+    ModuleLocation,
+    SwitchType,
+    VoiceInterfaceTemplates,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.srst import Association as SrstAssociation
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.srst import Pool
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.translation_rule import Action, RuleSettings
+from catalystwan.models.configuration.feature_profile.sdwan.uc_voice.trunk_group import TrunkGroupParcel
+from catalystwan.tests.builders.uc_voice import as_default
+
+
+class TestUcVoiceFeatureProfileBuilder(TestCaseBase):
+    def setUp(self) -> None:
+        self.feature_profile_name = f"FeatureProfileBuilderUcVoice_{str(uuid4())[:5]}"
+        self.feature_profile_description = "UC Voice feature profile"
+
+        self.builder = self.session.api.builders.feature_profiles.create_builder("uc-voice")
+        self.builder.add_profile_name_and_description(
+            feature_profile=FeatureProfileCreationPayload(
+                name=self.feature_profile_name, description=self.feature_profile_description
+            )
+        )
+
+        self.api = self.session.api.sdwan_feature_profiles.uc_voice
+
+        self.translation_profile = TranslationProfileParcel(
+            parcel_name="TranslationProfile",
+            parcel_description="TranslationProfileDescription",
+            translation_profile_settings=[],
+        )
+
+        self.translation_profile2 = TranslationProfileParcel(
+            parcel_name="TranslationProfile2",
+            parcel_description="TranslationProfileDescription",
+            translation_profile_settings=[],
+        )
+
+        self.translation_rule_calling = TranslationRuleParcel(
+            parcel_name="TranslationRuleCalling",
+            parcel_description="Description",
+            rule_name=Global[int](value=2),
+            rule_settings=[
+                RuleSettings(
+                    action=Global[Action](value="replace"),
+                    match=Global[str](value="/123/"),
+                    replacement_pattern=Global[str](value="/444/"),
+                    rule_num=Global[int](value=2),
+                )
+            ],
+        )
+
+        self.translation_rule_called = TranslationRuleParcel(
+            parcel_name="TranslationRuleCalled",
+            parcel_description="Description",
+            rule_name=Global[int](value=4),
+            rule_settings=[
+                RuleSettings(
+                    action=Global[Action](value="replace"),
+                    match=Global[str](value="/321/"),
+                    replacement_pattern=Global[str](value="/4445/"),
+                    rule_num=Global[int](value=4),
+                )
+            ],
+        )
+
+        self.media_profile = MediaProfileParcel(
+            parcel_name="MediaProfile",
+            parcel_description="MediaProfileDescription",
+            codec=as_global(["g711ulaw"]),
+            dtmf=Variable(value="{{test_1}}"),
+            media_profile_number=Variable(value="{{test_2}}"),
+        )
+
+        self.trunk_group = TrunkGroupParcel(
+            parcel_name="TrunkGroup",
+            parcel_description="TrunkGroupDescription",
+            hunt_scheme_method=as_default(None),
+            max_calls_in=as_default(None),
+            max_calls_out=as_default(None),
+            max_retries=as_default(None),
+            hunt_scheme_channel=as_default(None),
+            hunt_scheme_direction=as_default(None),
+        )
+
+    def test_build_profile_with_translation_profile_and_rules(self):
+        self.builder.add_translation_profile(
+            self.translation_profile, self.translation_rule_calling, self.translation_rule_called
+        )
+
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0, "Failed to build feature profile with translation profile and rules."
+
+    def test_build_profile_with_translation_profile_and_same_rules_references(self):
+        self.builder.add_translation_profile(
+            self.translation_profile, self.translation_rule_calling, self.translation_rule_called
+        )
+
+        self.builder.add_translation_profile(
+            self.translation_profile2, self.translation_rule_calling, self.translation_rule_called
+        )
+
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0, "Failed to build feature profile with translation profile and rules."
+
+    def test_build_profile_with_trunk_group(self):
+        self.builder.add_associable_parcel(self.trunk_group)
+
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0, "Failed to build feature profile with trunk group parcel."
+
+    def test_build_profile_with_digital_interface_translation_profile_and_trunk_group(self):
+        digital_interface = DigitalInterfaceParcel(
+            parcel_name="DigitalInterfaceParcel",
+            parcel_description="DigitalInterfaceParcel",
+            shutdown=[],
+            isdn_timer=[],
+            interface=[],
+            line_params=[],
+            outgoing_ie=[],
+            dsp_hairpin=as_default(False),
+            module_location=as_global("0/1", ModuleLocation),
+            voice_interface_templates=as_global("1 Port T1", VoiceInterfaceTemplates),
+            basic_settings=[
+                BasicSettings(
+                    delay_connect_timer=as_default(20),
+                    framing=as_default("esf", Framing),
+                    line_code=as_default("b8zs", LineCode),
+                    network_side=as_default(False),
+                    port_range=as_global("0-0"),
+                    switch_type=as_default("primary-ni", SwitchType),
+                    cable_length=as_default("0", CableLengthValue),
+                    cable_length_type=as_default("long", CableLengthType),
+                    timeslots=as_global("1-24"),
+                )
+            ],
+            association=[
+                DigitalInterfaceAssociation(
+                    port_range=as_global("0-0"),
+                    translation_profile=RefIdItem(ref_id=as_global(self.translation_profile.parcel_name)),
+                    trunk_group=RefIdItem(ref_id=as_global(self.trunk_group.parcel_name)),
+                    translation_profile_direction=as_default(None),
+                    trunk_group_priority=as_default(None),
+                )
+            ],
+        )
+
+        self.builder.add_associable_parcel(self.trunk_group)
+        self.builder.add_translation_profile(
+            self.translation_profile, self.translation_rule_calling, self.translation_rule_called
+        )
+        self.builder.add_parcel_with_associations(digital_interface)
+
+        report = self.builder.build()
+
+        assert (
+            len(report.failed_parcels) == 0
+        ), "Failed to build feature profile with digital interface, trunk group, and translation profile associations."
+
+    def test_build_profile_with_analog_interface_and_translation_profile_and_rules_associations(self):
+        analog_interface = AnalogInterfaceParcel(
+            parcel_name="AnalogInterface",
+            parcel_description="",
+            enable=as_default(True),
+            slot_id=as_global("0/1", SlotId),
+            module_type=as_global("72 Port FXS", ModuleType),
+            association=[
+                AnalogAssociation(
+                    port_range=as_variable("{{test}}"),
+                    translation_profile=RefIdItem(ref_id=as_global("TranslationProfile")),
+                    trunk_group=RefIdItem(ref_id=as_default(None)),
+                    trunk_group_priority=as_default(None),
+                    translation_rule_direction=as_default(None),
+                )
+            ],
+        )
+
+        self.builder.add_translation_profile(
+            self.translation_profile, self.translation_rule_calling, self.translation_rule_called
+        )
+        self.builder.add_parcel_with_associations(analog_interface)
+
+        report = self.builder.build()
+
+        assert (
+            len(report.failed_parcels) == 0
+        ), "Failed to build feature profile with analog interface and translation profile associations."
+
+    def test_build_profile_with_srts_and_media_profile_associations(self):
+        srst = SrstParcel(
+            parcel_name="Srst",
+            parcel_description="SrstDescription",
+            max_dn=Global[int](value=3),
+            max_phones=Global[int](value=3),
+            pool=[
+                Pool(
+                    ipv4_oripv6prefix=Variable(value="{{test_4}}"),
+                    pool_tag=as_global(1),
+                )
+            ],
+            association=[
+                SrstAssociation(
+                    media_profile=RefIdItem(ref_id=as_global(self.media_profile.parcel_name)),
+                )
+            ],
+        )
+
+        self.builder.add_associable_parcel(self.media_profile)
+        self.builder.add_parcel_with_associations(srst)
+
+        report = self.builder.build()
+
+        assert (
+            len(report.failed_parcels) == 0
+        ), "Failed to build feature profile with SRST and media profile associations."
+
+    def test_build_profile_with_call_routing(self):
+        call_routing = CallRoutingParcel(
+            parcel_name="CallRoutingParcel",
+            parcel_description="CallRoutingDescription",
+            dial_peer_tag_prefix=Default[None](value=None),
+            port_module_location=RefIdItem(ref_id=Default[None](value=None)),
+            voice=[],
+            modem_pass_through=[],
+            fax_protocol=[],
+            association=[
+                CallRoutingAssociation(
+                    dial_peer_range=as_global("1"),
+                    media_profile=RefIdItem(ref_id=as_global(self.media_profile.parcel_name)),
+                    translation_profile=RefIdItem(ref_id=as_global(self.translation_profile.parcel_name)),
+                    trunk_group=RefIdItem(ref_id=as_global(self.trunk_group.parcel_name)),
+                )
+            ],
+        )
+        self.builder.add_parcel_with_associations(call_routing)
+
+        report = self.builder.build()
+
+        assert len(report.failed_parcels) == 0, "Failed to build feature profile with Call Routing parcel."
+
+    def tearDown(self) -> None:
+        profile = self.api.get_profiles().filter(profile_name=self.feature_profile_name).single_or_default()
+        if profile:
+            self.api.delete_profile(profile.profile_id)

catalystwan/integration_tests/test_data/__init__.py

@@ -0,0 +1,117 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+from ipaddress import IPv4Address
+from typing import List, Literal
+
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, as_global
+from catalystwan.models.configuration.feature_profile.sdwan.routing.bgp import 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.transport.cellular_controller import (
+    CellularControllerParcel,
+    ControllerConfig,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_profile import (
+    Authentication,
+    CellularProfileParcel,
+    NeedAuthentication,
+    ProfileConfig,
+    ProfileInfo,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.gps import GpsParcel
+
+cellular_controller_parcel = CellularControllerParcel(
+    parcel_name="CellularControllerParcel",
+    parcel_description="Description",
+    controller_config=ControllerConfig(
+        id=as_global("0/2/0"),
+        slot=as_global(1),
+        max_retry=as_global(3),
+        failover_timer=as_global(4),
+        auto_sim=as_global(True),
+    ),
+)
+
+cellular_profile_parcel = CellularProfileParcel(
+    parcel_name="CellularProfileParcel",
+    parcel_description="Description",
+    profile_config=ProfileConfig(
+        id=Global[int](value=2),
+        profile_info=ProfileInfo(
+            apn=Global[str](value="KvqJrCD"),
+            authentication=Authentication(
+                need_authentication=NeedAuthentication(
+                    password=Variable(value="{{HfBBBHZlFH}}"),
+                    type=Global[Literal["chap", "pap", "pap_chap"]](value="chap"),
+                    username=Global[str](value="BABBBBBBV"),
+                )
+            ),
+            no_overwrite=Global[bool](value=False),
+            pdn_type=Global[Literal["ipv4", "ipv4v6", "ipv6"]](value="ipv4"),
+        ),
+    ),
+    config_type=Default[Literal["non-eSim"]](value="non-eSim"),
+)
+
+gps_parcel = GpsParcel(
+    parcel_name="GpsParcel",
+    parcel_description="Description",
+    destination_address=Global[IPv4Address](value=IPv4Address("66.22.1.2")),
+    destination_port=Global[int](value=266),
+    enable=Global[bool](value=True),
+    mode=Global[Literal["ms-based", "standalone"]](value="standalone"),
+    nmea=Global[bool](value=True),
+    source_address=Global[IPv4Address](value=IPv4Address("76.22.3.9")),
+)
+
+
+ospf_parcel = RoutingOspfParcel(
+    parcel_name="TestRoutingOspfParcel",
+    parcel_description="Test Ospf Parcel",
+)
+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"))],
+        )
+    ],
+)
+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"))],
+        )
+    ],
+)
+
+bgp_parcel = RoutingBgpParcel(
+    parcel_name="TestRoutingBgpParcel",
+    parcel_description="Test Bgp Parcel",
+    as_num=as_global(30),
+)
+
+
+__all__ = [
+    "cellular_controller_parcel",
+    "cellular_profile_parcel",
+    "gps_parcel",
+    "ospf_parcel",
+    "ospfv3ipv4_parcel",
+    "ospfv3ipv6_parcel",
+    "bgp_parcel",
+]
+
+
+def __dir__() -> "List[str]":
+    return list(__all__)

catalystwan/integration_tests/test_find_template_values.py

@@ -1,27 +1,19 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
 import json
-import os
-import unittest
-from typing import Any, List, cast
+from typing import Any, List
 
-from catalystwan.session import create_manager_session
+from catalystwan.integration_tests.base import TestCaseBase
 from catalystwan.utils.feature_template.find_template_values import find_template_values
 
 
-class TestFindTemplateValues(unittest.TestCase):
-    def setUp(self) -> None:
-        self.session = create_manager_session(
-            url=cast(str, os.environ.get("TEST_VMANAGE_URL")),
-            port=cast(int, int(os.environ.get("TEST_VMANAGE_PORT"))),  # type: ignore
-            username=cast(str, os.environ.get("TEST_VMANAGE_USERNAME")),
-            password=cast(str, os.environ.get("TEST_VMANAGE_PASSWORD")),
-        )
-        self.templates = self.session.api.templates._get_feature_templates(summary=False)
-
+class TestFindTemplateValues(TestCaseBase):
     def test_find_template_value(self):
+        # Arrange
+        self.templates = self.session.api.templates._get_feature_templates(summary=False)
+        # Act, Assert
         for template in self.templates:
-            definition = json.loads(template.template_definiton)
+            definition = json.loads(template.template_definition)
             with self.subTest(template_name=template.name):
                 parsed_values = find_template_values(definition)
                 self.assertFalse(
@@ -44,6 +36,3 @@ class TestFindTemplateValues(unittest.TestCase):
                         if self.is_key_present(v, keys):
                             return True
         return False
-
-    def tearDown(self) -> None:
-        self.session.close()

catalystwan/integration_tests/test_network_hierarchy.py

@@ -0,0 +1,82 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+import unittest
+from typing import Optional
+from uuid import UUID
+
+from catalystwan.integration_tests.base import IS_API_20_12, TestCaseBase
+from catalystwan.models.configuration.network_hierarchy.cflowd import CflowdParcel
+
+
+@unittest.skipIf(IS_API_20_12, "cflowd is not supported in 20.12")
+class TestCflowd(TestCaseBase):
+    parcel_id: Optional[UUID] = None
+    global_node_id: UUID
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        nodes = cls.session.endpoints.network_hierarchy.list_nodes()
+        for node in nodes:
+            if node.data.label == "GLOBAL":
+                cls.global_node_id = UUID(node.id)
+                return
+        raise ValueError("Global node not found")
+
+    def test_create_cflowd(self):
+        # Arrange
+        protocol = "ipv4"
+        active_timeout = 1000
+        inactive_timeout = 3000
+        refresh_time = 5000
+        sampling_interval = 6000
+        collect_tos = False
+        collect_dscp_output = True
+        vpn_id = 50
+        address = "10.0.2.3"
+        port = 9900
+        export_spread = True
+        bfd_metrics_export = True
+        export_interval = 1000
+        cflowd = CflowdParcel()
+        cflowd.add_collector(
+            address=address,
+            bfd_metrics_export=bfd_metrics_export,
+            export_interval=export_interval,
+            export_spread=export_spread,
+            udp_port=port,
+            vpn_id=vpn_id,
+        )
+        cflowd.set_customized_ipv4_record_fields(collect_tos=collect_tos, collect_dscp_output=collect_dscp_output)
+        cflowd.set_flow(
+            active_timeout=active_timeout,
+            inactive_timeout=inactive_timeout,
+            refresh_time=refresh_time,
+            sampling_interval=sampling_interval,
+        )
+        cflowd.set_protocol(protocol)
+        # Act
+        self.parcel_id = self.session.endpoints.network_hierarchy.create_cflowd(self.global_node_id, cflowd).id
+        parcel = (
+            self.session.endpoints.network_hierarchy.get_cflowd(self.global_node_id)
+            .find(parcel_id=self.parcel_id)
+            .payload
+        )
+        # Assert
+        assert parcel.protocol.value == protocol
+        assert parcel.flow_active_timeout.value == active_timeout
+        assert parcel.flow_inactive_timeout.value == inactive_timeout
+        assert parcel.flow_refresh_time.value == refresh_time
+        assert parcel.flow_sampling_interval.value == sampling_interval
+        assert parcel.customized_ipv4_record_fields.collect_dscp_output.value == collect_dscp_output
+        assert parcel.customized_ipv4_record_fields.collect_tos.value == collect_tos
+        assert parcel.collectors[0].vpn_id.value == vpn_id
+        assert parcel.collectors[0].address.value == address
+        assert parcel.collectors[0].udp_port.value == port
+        assert parcel.collectors[0].bfd_metrics_export.value == bfd_metrics_export
+        assert parcel.collectors[0].export_interval.value == export_interval
+        assert parcel.collectors[0].export_spread.value == export_spread
+
+    def tearDown(self) -> None:
+        if self.parcel_id:
+            self.session.endpoints.network_hierarchy.delete_cflowd(self.global_node_id, self.parcel_id)
+        super().tearDown()

catalystwan/integration_tests/test_settings.py

@@ -0,0 +1,30 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from typing import Optional
+
+from catalystwan.integration_tests.base import TestCaseBase
+from catalystwan.models.settings import ThreatGridApi
+
+
+class TestThreadGridApi(TestCaseBase):
+    created_thread: Optional[ThreatGridApi] = None
+
+    def test_thread_grid_api(self):
+        # Arrange
+        thread = ThreatGridApi()
+        thread.set_region_api_key("eur", "1234567890")
+        thread.set_region_api_key("nam", "0987654321")
+        # Act
+        created_thread = self.session.endpoints.configuration_settings.edit_threat_grid_api_key(thread)
+        dump = created_thread.model_dump_json(by_alias=True, exclude_none=True)
+        self.created_thread = ThreatGridApi.model_validate_json(dump)
+        # Assert
+        assert self.created_thread is not None
+        assert self.created_thread.data[0].entries[0].region == "nam"
+        assert self.created_thread.data[0].entries[0].apikey == "0987654321"
+        assert self.created_thread.data[0].entries[1].region == "eur"
+        assert self.created_thread.data[0].entries[1].apikey == "1234567890"
+
+    def tearDown(self) -> None:
+        if self.created_thread:
+            self.session.endpoints.configuration_settings.edit_threat_grid_api_key(ThreatGridApi())
+        return super().tearDown()