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

catalystwan/tests/test_feature_profile_api.py

@@ -0,0 +1,282 @@
+# Copyright 2023 Cisco Systems, Inc. and its affiliates
+import unittest
+from unittest.mock import Mock
+from uuid import uuid4
+
+from parameterized import parameterized  # type: ignore
+
+from catalystwan.api.feature_profile_api import (
+    ServiceFeatureProfileAPI,
+    SystemFeatureProfileAPI,
+    TransportFeatureProfileAPI,
+)
+from catalystwan.endpoints.configuration.feature_profile.sdwan.service import ServiceFeatureProfile
+from catalystwan.endpoints.configuration.feature_profile.sdwan.system import SystemFeatureProfile
+from catalystwan.endpoints.configuration.feature_profile.sdwan.transport import TransportFeatureProfile
+from catalystwan.models.configuration.feature_profile.parcel import ParcelAssociationPayload, ParcelCreationResponse
+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 import (
+    RoutingOspfParcel,
+    RoutingOspfv3IPv4Parcel,
+    RoutingOspfv3IPv6Parcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.service import AppqoeParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service import (
+    InterfaceEthernetParcel as LanInterfaceEthernetParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.service import InterfaceGreParcel as LanInterfaceGreParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service import (
+    InterfaceIpsecParcel as LanInterfaceIpsecParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.service import InterfaceSviParcel as LanInterfaceSviParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service import (
+    LanVpnDhcpServerParcel,
+    LanVpnParcel,
+    SwitchportParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.service.eigrp import EigrpParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service.multicast import MulticastParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service.route_policy import RoutePolicyParcel
+from catalystwan.models.configuration.feature_profile.sdwan.service.wireless_lan import WirelessLanParcel
+from catalystwan.models.configuration.feature_profile.sdwan.system import (
+    AAAParcel,
+    BannerParcel,
+    BasicParcel,
+    BFDParcel,
+    GlobalParcel,
+    LoggingParcel,
+    MRFParcel,
+    NtpParcel,
+    OMPParcel,
+    SecurityParcel,
+    SNMPParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport import (
+    InterfaceDslIPoEParcel,
+    InterfaceDslPPPoAParcel,
+    InterfaceDslPPPoEParcel,
+    InterfaceEthPPPoEParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport import InterfaceGreParcel as WanInterfaceGreParcel
+from catalystwan.models.configuration.feature_profile.sdwan.transport import (
+    InterfaceIpsecParcel as WanInterfaceIpsecParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport import (
+    ManagementVpnParcel,
+    T1E1ControllerParcel,
+    TransportVpnParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_controller import (
+    CellularControllerParcel,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.cellular_profile import CellularProfileParcel
+from catalystwan.models.configuration.feature_profile.sdwan.transport.gps import GpsParcel
+from catalystwan.models.configuration.feature_profile.sdwan.transport.wan.interface.cellular import (
+    InterfaceCellularParcel,
+)
+
+system_endpoint_mapping = {
+    AAAParcel: "aaa",
+    BannerParcel: "banner",
+    BasicParcel: "basic",
+    BFDParcel: "bfd",
+    GlobalParcel: "global",
+    LoggingParcel: "logging",
+    MRFParcel: "mrf",
+    NtpParcel: "ntp",
+    OMPParcel: "omp",
+    SecurityParcel: "security",
+    SNMPParcel: "snmp",
+}
+
+
+class TestSystemFeatureProfileAPI(unittest.TestCase):
+    def setUp(self):
+        self.profile_uuid = uuid4()
+        self.parcel_uuid = uuid4()
+        self.mock_session = Mock()
+        self.mock_endpoint = Mock(spec=SystemFeatureProfile)
+        self.api = SystemFeatureProfileAPI(self.mock_session)
+        self.api.endpoint = self.mock_endpoint
+
+    @parameterized.expand(system_endpoint_mapping.items())
+    def test_delete_method_with_valid_arguments(self, parcel, expected_path):
+        # Act
+        self.api.delete_parcel(self.profile_uuid, parcel, self.parcel_uuid)
+
+        # Assert
+        self.mock_endpoint.delete.assert_called_once_with(self.profile_uuid, expected_path, self.parcel_uuid)
+
+    @parameterized.expand(system_endpoint_mapping.items())
+    def test_get_method_with_valid_arguments(self, parcel, expected_path):
+        # Act
+        self.api.get_parcel(self.profile_uuid, parcel, self.parcel_uuid)
+
+        # Assert
+        self.mock_endpoint.get_by_id.assert_called_once_with(self.profile_uuid, expected_path, self.parcel_uuid)
+
+    @parameterized.expand(system_endpoint_mapping.items())
+    def test_get_all_method_with_valid_arguments(self, parcel, expected_path):
+        # Act
+        self.api.get_parcels(self.profile_uuid, parcel)
+
+        # Assert
+        self.mock_endpoint.get_all.assert_called_once_with(self.profile_uuid, expected_path)
+
+    @parameterized.expand(system_endpoint_mapping.items())
+    def test_create_method_with_valid_arguments(self, parcel, expected_path):
+        # Act
+        self.api.create_parcel(self.profile_uuid, parcel)
+
+        # Assert
+        self.mock_endpoint.create.assert_called_once_with(self.profile_uuid, expected_path, parcel)
+
+    @parameterized.expand(system_endpoint_mapping.items())
+    def test_update_method_with_valid_arguments(self, parcel, expected_path):
+        # Act
+        self.api.update_parcel(self.profile_uuid, parcel, self.parcel_uuid)
+
+        # Assert
+        self.mock_endpoint.update.assert_called_once_with(self.profile_uuid, expected_path, self.parcel_uuid, parcel)
+
+
+service_endpoint_mapping = {
+    LanVpnDhcpServerParcel: "dhcp-server",
+    AppqoeParcel: "appqoe",
+    LanVpnParcel: "lan/vpn",
+    RoutingOspfParcel: "routing/ospf",
+    RoutingOspfv3IPv4Parcel: "routing/ospfv3/ipv4",
+    RoutingOspfv3IPv6Parcel: "routing/ospfv3/ipv6",
+    RoutePolicyParcel: "route-policy",
+    EigrpParcel: "routing/eigrp",
+    Ipv6AclParcel: "ipv6-acl",
+    Ipv4AclParcel: "ipv4-acl",
+    SwitchportParcel: "switchport",
+    MulticastParcel: "routing/multicast",
+    WirelessLanParcel: "wirelesslan",
+}
+
+service_interface_parcels = [
+    ("interface/gre", LanInterfaceGreParcel),
+    ("interface/svi", LanInterfaceSviParcel),
+    ("interface/ethernet", LanInterfaceEthernetParcel),
+    ("interface/ipsec", LanInterfaceIpsecParcel),
+]
+
+service_vpn_sub_parcels = [
+    (
+        "routing/multicast",
+        MulticastParcel(
+            parcel_name="TestMulticastParcel",
+            parcel_description="Test Multicast Parcel",
+        ),
+    )
+]
+
+
+class TestServiceFeatureProfileAPI(unittest.TestCase):
+    def setUp(self):
+        self.profile_uuid = uuid4()
+        self.vpn_uuid = uuid4()
+        self.parcel_uuid = uuid4()
+        self.mock_session = Mock()
+        self.mock_endpoint = Mock(spec=ServiceFeatureProfile)
+        self.api = ServiceFeatureProfileAPI(self.mock_session)
+        self.api.endpoint = self.mock_endpoint
+
+    @parameterized.expand(service_endpoint_mapping.items())
+    def test_post_method_parcel(self, parcel, parcel_type):
+        # Act
+        self.api.create_parcel(self.profile_uuid, parcel)
+
+        # Assert
+        self.mock_endpoint.create_service_parcel.assert_called_once_with(self.profile_uuid, parcel_type, parcel)
+
+    @parameterized.expand(service_interface_parcels)
+    def test_post_method_interface_parcel(self, parcel_type, parcel):
+        # Act
+        self.api.create_parcel(self.profile_uuid, parcel, self.vpn_uuid)
+
+        # Assert
+        self.mock_endpoint.create_lan_vpn_sub_parcel.assert_called_once_with(
+            self.profile_uuid, self.vpn_uuid, parcel_type, parcel
+        )
+
+    @parameterized.expand(service_vpn_sub_parcels)
+    def test_post_method_create_then_assigin_subparcel(self, parcel_type, parcel):
+        # Arrange
+        self.mock_endpoint.create_service_parcel.return_value = ParcelCreationResponse(id=self.parcel_uuid)
+
+        # Act
+        self.api.create_parcel(self.profile_uuid, parcel, self.vpn_uuid)
+
+        # Assert
+        self.mock_endpoint.create_service_parcel.assert_called_once_with(self.profile_uuid, parcel_type, parcel)
+        self.mock_endpoint.associate_parcel_with_vpn.assert_called_once_with(
+            self.profile_uuid,
+            self.vpn_uuid,
+            parcel_type,
+            ParcelAssociationPayload(parcel_id=self.parcel_uuid),
+        )
+
+
+transport_enpoint_mapping = {
+    T1E1ControllerParcel: "t1-e1-controller",
+    GpsParcel: "gps",
+    CellularControllerParcel: "cellular-controller",
+    CellularProfileParcel: "cellular-profile",
+    ManagementVpnParcel: "management/vpn",
+    TransportVpnParcel: "wan/vpn",
+}
+
+transport_interface_parcels = [
+    ("interface/ipsec", WanInterfaceIpsecParcel),
+    ("interface/dsl-ipoe", InterfaceDslIPoEParcel),
+    (
+        "interface/ethpppoe",
+        InterfaceEthPPPoEParcel,
+    ),
+    (
+        "interface/dsl-pppoe",
+        InterfaceDslPPPoEParcel,
+    ),
+    (
+        "interface/dsl-pppoa",
+        InterfaceDslPPPoAParcel,
+    ),
+    ("interface/gre", WanInterfaceGreParcel),
+    ("interface/cellular", InterfaceCellularParcel),
+]
+
+
+class TestTransportFeatureProfileAPI(unittest.TestCase):
+    def setUp(self):
+        self.profile_uuid = uuid4()
+        self.vpn_uuid = uuid4()
+        self.parcel_uuid = uuid4()
+        self.mock_session = Mock()
+        self.mock_endpoint = Mock(spec=TransportFeatureProfile)
+        self.api = TransportFeatureProfileAPI(self.mock_session)
+        self.api.endpoint = self.mock_endpoint
+        parcel_mock = Mock()
+        parcel_mock.payload._get_parcel_type.return_value = "wan/vpn"
+        self.api._get_vpn_parcel = Mock(return_value=parcel_mock)
+
+    @parameterized.expand(transport_enpoint_mapping.items())
+    def test_post_method_parcel(self, parcel, parcel_type):
+        # Act
+        self.api.create_parcel(self.profile_uuid, parcel)
+
+        # Assert
+        self.mock_endpoint.create_transport_parcel.assert_called_once_with(self.profile_uuid, parcel_type, parcel)
+
+    @parameterized.expand(transport_interface_parcels)
+    def test_post_method_interface_parcel(self, parcel_type, parcel):
+        # Act
+        self.api.create_parcel(self.profile_uuid, parcel, self.vpn_uuid)
+
+        # Assert
+        self.mock_endpoint.create_transport_vpn_sub_parcel.assert_called_once_with(
+            self.profile_uuid, self.vpn_uuid, parcel_type, parcel
+        )

catalystwan/tests/test_models_common.py

@@ -0,0 +1,53 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+import unittest
+from typing import Any, Dict, Set
+
+from packaging.version import Version  # type: ignore
+from parameterized import parameterized  # type: ignore
+from pydantic import BaseModel, ConfigDict, Field, SerializationInfo, SerializerFunctionWrapHandler, model_serializer
+from typing_extensions import Annotated
+
+from catalystwan.models.common import VersionedField
+
+A = Annotated[
+    int, VersionedField(versions=">=1", serialization_alias="a-kebab"), Field(default=0, serialization_alias="aCamel")
+]
+
+B = Annotated[
+    float,
+    VersionedField(versions=">=2", serialization_alias="b-kebab"),
+]
+
+
+class VersionedFieldsModel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    a: A
+    b: B = Field(default=0.0, serialization_alias="bCamel")
+    c: Annotated[bool, VersionedField(versions=">=3", serialization_alias="c-kebab")] = False
+
+    @model_serializer(mode="wrap")
+    def dump(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> Dict[str, Any]:
+        return VersionedField.dump(self.model_fields, handler(self), info)
+
+
+class Payload(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    data: VersionedFieldsModel
+
+
+class TestModelsCommonVersionedField(unittest.TestCase):
+    def setUp(self):
+        self.model = Payload(data=VersionedFieldsModel())
+
+    @parameterized.expand(
+        [
+            ("0.9", {"aCamel", "bCamel", "c"}),
+            ("1.0", {"a-kebab", "bCamel", "c"}),
+            ("2.1", {"a-kebab", "b-kebab", "c"}),
+            ("3.0.1", {"a-kebab", "b-kebab", "c-kebab"}),
+        ]
+    )
+    def test_versioned_field_model_serialize(self, version: str, expected_fields: Set[str]):
+        data_dict = self.model.model_dump(by_alias=True, context={"api_version": Version(version)}).get("data")
+        assert expected_fields == data_dict.keys()

catalystwan/tests/test_templates.py

@@ -12,10 +12,9 @@ from catalystwan.api.templates.device_template.device_template import DeviceTemp
 from catalystwan.api.templates.feature_template import FeatureTemplate
 from catalystwan.api.templates.models.cisco_aaa_model import CiscoAAAModel
 from catalystwan.api.templates.payloads.aaa.aaa_model import AAAModel, AuthenticationOrder
-from catalystwan.dataclasses import Device, FeatureTemplateInfo, TemplateInfo
+from catalystwan.dataclasses import Device
+from catalystwan.endpoints.configuration_template_master import DeviceTemplateInformation
 from catalystwan.typed_list import DataSequence
-from catalystwan.utils.creation_tools import create_dataclass
-from catalystwan.utils.device_model import DeviceModel
 from catalystwan.utils.personality import Personality
 from catalystwan.utils.reachability import Reachability
 
@@ -55,8 +54,8 @@ class TestTemplatesAPI(unittest.TestCase):
             },
         ]
         self.templates = DataSequence(
-            TemplateInfo,
-            [create_dataclass(TemplateInfo, template) for template in self.data_template],
+            DeviceTemplateInformation,
+            [DeviceTemplateInformation(**template) for template in self.data_template],
         )
         self.device_info = Device(
             personality=Personality.EDGE,
@@ -70,7 +69,7 @@ class TestTemplatesAPI(unittest.TestCase):
             model="vedge-cloud",
             status="normal",
         )
-        sub_tasks_data = SubTaskData.parse_obj(
+        sub_tasks_data = SubTaskData.model_validate(
             {
                 "status": "Success",
                 "statusId": "success",
@@ -86,12 +85,10 @@ class TestTemplatesAPI(unittest.TestCase):
         )
         self.task = TaskResult(result=True, sub_tasks_data=[sub_tasks_data])
 
-    @patch("catalystwan.response.ManagerResponse")
     @patch("catalystwan.session.ManagerSession")
-    def test_templates_success(self, mock_session, mocked_response):
+    def test_templates_success(self, mock_session):
         # Arrange
-        mock_session.get.return_value = mocked_response
-        mocked_response.dataseq.return_value = self.templates
+        mock_session.endpoints.configuration_general_template.get_feature_template_list.return_value = self.templates
 
         # Act
         answer = TemplatesAPI(mock_session).get(FeatureTemplate)
@@ -99,18 +96,18 @@ class TestTemplatesAPI(unittest.TestCase):
         # Assert
         self.assertEqual(answer, self.templates)
 
-    @patch("catalystwan.response.ManagerResponse")
     @patch("catalystwan.session.ManagerSession")
-    def test_templates_get(self, mock_session, mocked_response):
+    def test_templates_get(self, mock_session):
         # Arrange
-        mock_session.get_data.return_value = mocked_response
-        mocked_response.dataseq.return_value = DataSequence(FeatureTemplateInfo, [])
+        mock_session.endpoints.configuration_general_template.get_feature_template_list.return_value = self.templates
 
         # Act
         TemplatesAPI(mock_session).get(FeatureTemplate)
 
         # Assert
-        mock_session.get.assert_called_once_with(url="/dataservice/template/feature", params={"summary": True})
+        mock_session.endpoints.configuration_general_template.get_feature_template_list.assert_called_once_with(
+            params={"summary": True}
+        )
 
     @parameterized.expand(
         [
@@ -130,14 +127,14 @@ class TestTemplatesAPI(unittest.TestCase):
                 DeviceTemplate(  # type: ignore
                     template_name="test_device_template",
                     template_description="test_device_template_description",
-                    device_type=DeviceModel.VEDGE_2000,
+                    device_type="vedge-2000",
                     general_templates=[],
                 ),
                 "device_template_id",
             ),
             (
                 CLITemplate(  # type: ignore
-                    template_name="test", template_description="test", device_model=DeviceModel.VEDGE
+                    template_name="test", template_description="test", device_model="vedge-100"
                 ),
                 "cli_id",
             ),
@@ -193,13 +190,13 @@ class TestTemplatesAPI(unittest.TestCase):
                     DeviceTemplate(  # type: ignore
                         template_name="test_device_template",
                         template_description="test_device_template_description",
-                        device_type=DeviceModel.VEDGE_2000,
+                        device_type="vedge-2000",
                         general_templates=[],
                     ),
                     CLITemplate(  # type: ignore
                         template_name="test_cli_template",
                         template_description="test_cli_description",
-                        device_model=DeviceModel.VBOND,
+                        device_model="vedge-cloud",
                     ),
                     CiscoAAAModel(  # type: ignore
                         template_name="test_aaa_model",

catalystwan/utils/feature_template/find_template_values.py

@@ -1,9 +1,11 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
-
+import logging
 from typing import Any, Dict, List, Optional, Union
 
 from catalystwan.api.templates.device_variable import DeviceVariable
 
+logger = logging.getLogger(__name__)
+
 
 def find_template_values(
     template_definition: dict,
@@ -41,7 +43,7 @@ def find_template_values(
         template_value = template_definition.get(target_key_for_template_value)
 
         field_key = path[-1]
-        if value == "variableName":
+        if value in ["variableName", "variable"]:
             # For example this is the current dictionary:
             # field_key is "dns-addr"
             # {
@@ -52,7 +54,14 @@ def find_template_values(
             # }
             # vipType is "variableName" so we need to return
             # {"dns-addr": DeviceVariable(name="vpn_dns_primary")}
-            templated_values[field_key] = DeviceVariable(name=template_definition["vipVariableName"])
+            if var_name := template_definition.get("vipVariableName"):
+                new_value = DeviceVariable(name=var_name)
+                if previous_value := templated_values.get(field_key):
+                    logger.error(
+                        f"Overwriting existing value for field: '{field_key}' in templated_values. "
+                        f"Previous value: {previous_value}, new value: {new_value}."
+                    )
+                templated_values[field_key] = new_value
             return templated_values
 
         if template_value is None:
@@ -93,7 +102,11 @@ def get_nested_dict(d: dict, path: List[str], populate: bool = True):
     return current_dict
 
 
-def process_list_value(item: Any, target_key: str = "vipType", target_key_for_template_value: str = "vipValue"):
+def process_list_value(
+    item: Any,
+    target_key: str = "vipType",
+    target_key_for_template_value: str = "vipValue",
+):
     if isinstance(item, dict):
         if target_key in item:
             if item["vipObjectType"] == "list":

catalystwan/utils/model.py

@@ -0,0 +1,45 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from functools import lru_cache
+from inspect import isclass
+from typing import Any, List, Optional, Type, Union
+
+from pydantic import BaseModel
+from typing_extensions import Annotated, get_args, get_origin
+
+
+def resolve_nested_base_model_unions(
+    annotation: Any, models_types: List[Type[BaseModel]] = list()
+) -> List[Type[BaseModel]]:
+    """given something like AnyParcel produces flat list of BaseModel sub-types present in that union
+
+    Args:
+        annotation (Any): Union of BaseModels (could be Annotated and nested)
+        models_types (List[Type[BaseModel]], optional): used internally in recurence
+
+    Raises:
+        TypeError: when contents are not BaseModel (can be Annotated)
+
+    Returns:
+        List[Type[BaseModel]]: flat list of subclasses of BaseModel present in input
+    """
+
+    models_types = list(dict.fromkeys(models_types))
+
+    if isclass(annotation):
+        if issubclass(annotation, BaseModel):
+            return [annotation]
+
+    if get_origin(annotation) in [Annotated, Union]:
+        for arg in get_args(annotation):
+            models_types.extend(resolve_nested_base_model_unions(arg, models_types))
+        return list(dict.fromkeys(models_types))
+
+    return list()
+
+
+@lru_cache
+def get_model_type_field(model: Type[BaseModel]) -> Optional[str]:
+    if type_field := model.model_fields.get("type"):
+        if default_value := type_field.default:
+            return str(default_value)
+    return None

catalystwan/utils/persona.py

@@ -0,0 +1,5 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+
+from typing import Literal
+
+Persona = Literal["COMPUTE_AND_DATA", "COMPUTE", "DATA"]

catalystwan/utils/type_check.py

@@ -0,0 +1,22 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+import uuid
+
+from pydantic import ValidationError
+
+from catalystwan.api.configuration_groups.parcel import Variable
+
+
+def is_str_uuid(value: str) -> bool:
+    try:
+        uuid_ = uuid.UUID(value)
+        return str(uuid_) == value or uuid_.hex == value
+    except ValueError:
+        return False
+
+
+def is_str_variable(value: str) -> bool:
+    try:
+        Variable(value=value)
+        return True
+    except ValidationError:
+        return False