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

catalystwan/tests/templates/test_find_template_values.py

@@ -1,4 +1,6 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
+import logging
+
 from catalystwan.api.templates.device_variable import DeviceVariable
 from catalystwan.utils.feature_template.find_template_values import find_template_values
 
@@ -191,3 +193,230 @@ def test_find_template_values():
     result = find_template_values(input_values)
     # Assert
     assert expected_values == result
+
+
+def test_log_error_when_overwriting_existing_variable_value(caplog):
+    input_values = {
+        "if-name": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_name",
+        },
+        "description": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_desc",
+        },
+        "ip": {
+            "value": {
+                "vipObjectType": "object",
+                "vipType": "variableName",
+                "vipValue": "",
+                "vipVariableName": "first_test_value_variable",
+            },
+            "address": {
+                "vipObjectType": "object",
+                "vipType": "variableName",
+                "vipValue": "",
+                "vipVariableName": "inet-if_ipv4_address",
+            },
+        },
+        "tunnel-interface": {
+            "color": {
+                "value": {
+                    "vipObjectType": "object",
+                    "vipType": "variableName",
+                    "vipValue": "",
+                    "vipVariableName": "second_test_value_variable",
+                },
+                "restrict": {
+                    "vipObjectType": "node-only",
+                    "vipType": "ignore",
+                    "vipValue": "false",
+                    "vipVariableName": "vpn_if_tunnel_color_restrict",
+                },
+            },
+        },
+    }
+
+    expected_error_log = (
+        "Overwriting existing value for field: 'value' in templated_values. "
+        "Previous value: name='first_test_value_variable', new value: name='second_test_value_variable'."
+    )
+    # Act
+    result = find_template_values(input_values)
+
+    # Assert
+    error_logs = [log.getMessage() for log in caplog.records if log.levelno == logging.ERROR]
+    assert expected_error_log in error_logs
+    assert isinstance(result.get("value"), DeviceVariable)
+    assert result.get("value").name == "second_test_value_variable"
+
+
+def test_log_error_when_overwriting_existing_top_level_global_value(caplog):
+    input_values = {
+        "if-name": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_name",
+        },
+        "description": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_desc",
+        },
+        "value": {
+            "vipObjectType": "object",
+            "vipType": "constant",
+            "vipValue": "test_value",
+            "vipVariableName": "first_test_value_variable",
+        },
+        "ip": {
+            "address": {
+                "vipObjectType": "object",
+                "vipType": "variableName",
+                "vipValue": "",
+                "vipVariableName": "inet-if_ipv4_address",
+            },
+        },
+        "tunnel-interface": {
+            "color": {
+                "value": {
+                    "vipObjectType": "object",
+                    "vipType": "variableName",
+                    "vipValue": "",
+                    "vipVariableName": "second_test_value_variable",
+                },
+                "restrict": {
+                    "vipObjectType": "node-only",
+                    "vipType": "ignore",
+                    "vipValue": "false",
+                    "vipVariableName": "vpn_if_tunnel_color_restrict",
+                },
+            },
+        },
+    }
+
+    expected_error_log = (
+        "Overwriting existing value for field: 'value' in templated_values. "
+        "Previous value: test_value, new value: name='second_test_value_variable'."
+    )
+    # Act
+    result = find_template_values(input_values)
+
+    # Assert
+    error_logs = [log.getMessage() for log in caplog.records if log.levelno == logging.ERROR]
+
+    assert expected_error_log in error_logs
+    assert isinstance(result.get("value"), DeviceVariable)
+    assert result.get("value").name == "second_test_value_variable"
+
+
+def test_no_log_error_when_setting_value_first_time(caplog):
+    input_values = {
+        "if-name": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_name",
+        },
+        "description": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_desc",
+        },
+        "ip": {
+            "address": {
+                "vipObjectType": "object",
+                "vipType": "variableName",
+                "vipValue": "",
+                "vipVariableName": "inet-if_ipv4_address",
+            },
+        },
+        "tunnel-interface": {
+            "color": {
+                "value": {
+                    "vipObjectType": "object",
+                    "vipType": "variableName",
+                    "vipValue": "",
+                    "vipVariableName": "test_value_variable",
+                },
+                "restrict": {
+                    "vipObjectType": "node-only",
+                    "vipType": "ignore",
+                    "vipValue": "false",
+                    "vipVariableName": "vpn_if_tunnel_color_restrict",
+                },
+            },
+        },
+    }
+
+    # Act
+    result = find_template_values(input_values)
+
+    # Assert
+    error_logs = [log.getMessage() for log in caplog.records if log.levelno == logging.ERROR]
+    assert len(error_logs) == 0
+    assert isinstance(result.get("value"), DeviceVariable)
+    assert result.get("value").name == "test_value_variable"
+
+
+def test_no_log_error_when_global_value_is_nested(caplog):
+    input_values = {
+        "if-name": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_name",
+        },
+        "description": {
+            "vipObjectType": "object",
+            "vipType": "variableName",
+            "vipValue": "",
+            "vipVariableName": "inet-if_desc",
+        },
+        "ip": {
+            "address": {
+                "vipObjectType": "object",
+                "vipType": "variableName",
+                "vipValue": "",
+                "vipVariableName": "inet-if_ipv4_address",
+            },
+            "value": {
+                "vipObjectType": "object",
+                "vipType": "constant",
+                "vipValue": "test_value",
+                "vipVariableName": "first_test_value_variable",
+            },
+        },
+        "tunnel-interface": {
+            "color": {
+                "value": {
+                    "vipObjectType": "object",
+                    "vipType": "variableName",
+                    "vipValue": "",
+                    "vipVariableName": "second_test_value_variable",
+                },
+                "restrict": {
+                    "vipObjectType": "node-only",
+                    "vipType": "ignore",
+                    "vipValue": "false",
+                    "vipVariableName": "vpn_if_tunnel_color_restrict",
+                },
+            },
+        },
+    }
+
+    # Act
+    result = find_template_values(input_values)
+
+    # Assert
+    error_logs = [log.getMessage() for log in caplog.records if log.levelno == logging.ERROR]
+    assert len(error_logs) == 0
+    assert isinstance(result.get("value"), DeviceVariable)
+    assert result.get("value").name == "second_test_value_variable"

catalystwan/tests/templates/test_find_template_values_2.py

@@ -0,0 +1,193 @@
+# Copyright 2024 Cisco Systems, Inc. and its affiliates
+from catalystwan.api.templates.device_variable import DeviceVariable
+from catalystwan.utils.feature_template.find_template_values import find_template_values
+
+
+def test_find_template_values():
+    input_values = {
+        "vpn-id": {"vipObjectType": "object", "vipType": "constant", "vipValue": 0},
+        "name": {
+            "vipObjectType": "object",
+            "vipType": "ignore",
+            "vipVariableName": "vpn_name",
+        },
+        "ecmp-hash-key": {
+            "layer4": {
+                "vipObjectType": "object",
+                "vipType": "ignore",
+                "vipValue": "false",
+                "vipVariableName": "vpn_layer4",
+            }
+        },
+        "nat64-global": {"prefix": {"stateful": {}}},
+        "nat64": {
+            "v4": {
+                "pool": {
+                    "vipType": "ignore",
+                    "vipValue": [],
+                    "vipObjectType": "tree",
+                    "vipPrimaryKey": ["name"],
+                }
+            }
+        },
+        "nat": {
+            "natpool": {
+                "vipType": "ignore",
+                "vipValue": [],
+                "vipObjectType": "tree",
+                "vipPrimaryKey": ["name"],
+            },
+            "port-forward": {
+                "vipType": "ignore",
+                "vipValue": [],
+                "vipObjectType": "tree",
+                "vipPrimaryKey": ["source-port", "translate-port"],
+            },
+            "static": {
+                "vipType": "ignore",
+                "vipValue": [],
+                "vipObjectType": "tree",
+                "vipPrimaryKey": ["source-ip", "translate-ip"],
+            },
+        },
+        "route-import": {
+            "vipType": "ignore",
+            "vipValue": [],
+            "vipObjectType": "tree",
+            "vipPrimaryKey": ["protocol"],
+        },
+        "route-export": {
+            "vipType": "ignore",
+            "vipValue": [],
+            "vipObjectType": "tree",
+            "vipPrimaryKey": ["protocol"],
+        },
+        "dns": {
+            "vipType": "constant",
+            "vipValue": [
+                {
+                    "role": {
+                        "vipType": "constant",
+                        "vipValue": "primary",
+                        "vipObjectType": "object",
+                    },
+                    "dns-addr": {
+                        "vipType": "variableName",
+                        "vipValue": "",
+                        "vipObjectType": "object",
+                        "vipVariableName": "vpn_dns_primary",
+                    },
+                    "priority-order": ["dns-addr", "role"],
+                },
+                {
+                    "role": {
+                        "vipType": "constant",
+                        "vipValue": "secondary",
+                        "vipObjectType": "object",
+                    },
+                    "dns-addr": {
+                        "vipType": "variableName",
+                        "vipValue": "",
+                        "vipObjectType": "object",
+                        "vipVariableName": "vpn_dns_secondary",
+                    },
+                    "priority-order": ["dns-addr", "role"],
+                },
+            ],
+            "vipObjectType": "tree",
+            "vipPrimaryKey": ["dns-addr"],
+        },
+        "host": {
+            "vipType": "ignore",
+            "vipValue": [],
+            "vipObjectType": "tree",
+            "vipPrimaryKey": ["hostname"],
+        },
+        "service": {
+            "vipType": "ignore",
+            "vipValue": [],
+            "vipObjectType": "tree",
+            "vipPrimaryKey": ["svc-type"],
+        },
+        "ip": {
+            "route": {
+                "vipType": "constant",
+                "vipValue": [
+                    {
+                        "prefix": {
+                            "vipObjectType": "object",
+                            "vipType": "constant",
+                            "vipValue": "0.0.0.0/0",
+                            "vipVariableName": "vpn_ipv4_ip_prefix",
+                        },
+                        "next-hop": {
+                            "vipType": "constant",
+                            "vipValue": [
+                                {
+                                    "address": {
+                                        "vipObjectType": "object",
+                                        "vipType": "variableName",
+                                        "vipValue": "",
+                                        "vipVariableName": "vpn_next_hop_ip_address_0",
+                                    },
+                                    "distance": {
+                                        "vipObjectType": "object",
+                                        "vipType": "ignore",
+                                        "vipValue": 1,
+                                        "vipVariableName": "vpn_next_hop_ip_distance_0",
+                                    },
+                                    "priority-order": ["address", "distance"],
+                                }
+                            ],
+                            "vipObjectType": "tree",
+                            "vipPrimaryKey": ["address"],
+                        },
+                        "priority-order": ["prefix", "next-hop", "next-hop-with-track"],
+                    }
+                ],
+                "vipObjectType": "tree",
+                "vipPrimaryKey": ["prefix"],
+            },
+            "gre-route": {},
+            "ipsec-route": {},
+            "service-route": {},
+        },
+        "ipv6": {},
+        "omp": {
+            "advertise": {
+                "vipType": "ignore",
+                "vipValue": [],
+                "vipObjectType": "tree",
+                "vipPrimaryKey": ["protocol"],
+            },
+            "ipv6-advertise": {
+                "vipType": "ignore",
+                "vipValue": [],
+                "vipObjectType": "tree",
+                "vipPrimaryKey": ["protocol"],
+            },
+        },
+    }
+    expected_values = {
+        "vpn-id": 0,
+        "dns": [
+            {"role": "primary", "dns-addr": DeviceVariable(name="vpn_dns_primary")},
+            {"role": "secondary", "dns-addr": DeviceVariable(name="vpn_dns_secondary")},
+        ],
+        "ip": {
+            "route": [
+                {
+                    "prefix": "0.0.0.0/0",
+                    "next-hop": [
+                        {
+                            "address": DeviceVariable(name="vpn_next_hop_ip_address_0"),
+                        }
+                    ],
+                }
+            ],
+        },
+    }
+    # Act
+    result = find_template_values(input_values)
+    # Assert
+    assert expected_values == result

catalystwan/tests/templates/test_serialize_model.py

@@ -35,14 +35,13 @@ class TestFeatureTemplate2(TestCase):
             Path(__file__).resolve().parents[0] / Path("definitions") / Path(f"{template.template_name}.json")
         ) as f:
             definition = json.load(f)
-
         # Act
         feature_template_payload = templates_api.generate_feature_template_payload(
             template=template, schema=schema, debug=False
         )
         # Assert
         # self.assertDictEqual
-        self.maxDiff = 10000
+        self.maxDiff = 2**16
         self.assertDictEqual(
             definition["templateDefinition"],
             feature_template_payload.model_dump(by_alias=True, mode="json")["templateDefinition"],

catalystwan/tests/test_cli_template.py

@@ -9,7 +9,6 @@ from ciscoconfparse import CiscoConfParse  # type: ignore
 from catalystwan.api.templates.cli_template import CLITemplate
 from catalystwan.dataclasses import Device
 from catalystwan.exceptions import TemplateTypeError
-from catalystwan.utils.device_model import DeviceModel
 
 
 class TestCLITemplate(unittest.TestCase):
@@ -40,7 +39,7 @@ class TestCLITemplate(unittest.TestCase):
         # Arrange
         mock_session.get_json.return_value = {"configType": "file", "templateConfiguration": self.config}
         # Act
-        temp = CLITemplate(template_name="test", template_description="test", device_model=DeviceModel.VEDGE)
+        temp = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
         answer = temp.load(session=mock_session, id="temp_id")
         # Assert
         self.assertEqual(answer.ioscfg, self.template.ioscfg)
@@ -54,7 +53,7 @@ class TestCLITemplate(unittest.TestCase):
             "templateConfiguration": self.config,
         }
         # Act
-        temp = CLITemplate(template_name="test", template_description="test", device_model=DeviceModel.VEDGE)
+        temp = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
 
         def answer():
             return temp.load(session=mock_session, id="temp_id")
@@ -79,7 +78,7 @@ class TestCLITemplate(unittest.TestCase):
             model="vedge-cloud",
         )
         # Act
-        temp = CLITemplate(template_name="test", template_description="test", device_model=DeviceModel.VEDGE)
+        temp = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
         answer = temp.load_running(session=mock_session, device=device)
         # Assert
         self.assertEqual(answer.ioscfg, self.template.ioscfg)
@@ -87,7 +86,7 @@ class TestCLITemplate(unittest.TestCase):
     def test_generate_payload(self):
         # Arrange
         template = CLITemplate(
-            template_name="test", template_description="test", device_model=DeviceModel.VEDGE, config=self.template
+            template_name="test", template_description="test", device_model="vedge-cloud", config=self.template
         )
         # Act
         answer = template.generate_payload()
@@ -126,7 +125,7 @@ class TestCLITemplate(unittest.TestCase):
         template = CLITemplate(
             template_name="test",
             template_description="test",
-            device_model=DeviceModel.VEDGE_C8000V,
+            device_model="vedge-C8000V",
             config=self.template,
         )
         # Act
@@ -174,7 +173,7 @@ class TestCLITemplate(unittest.TestCase):
         )
         config = CiscoConfParse(templateConfiguration.splitlines())
         # Act
-        template = CLITemplate(template_name="test", template_description="test", device_model=DeviceModel.VEDGE)
+        template = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
         result = template.update(session=mock_session, id="temp_id", config=config)
         # Assert
         self.assertTrue(result)
@@ -191,7 +190,7 @@ class TestCLITemplate(unittest.TestCase):
             "        system-ip               192.168.1.26\n"
         )
         config = CiscoConfParse(templateConfiguration.splitlines())
-        template = CLITemplate(template_name="test", template_description="test", device_model=DeviceModel.VEDGE)
+        template = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
 
         # Act
         with self.assertRaises(HTTPError):
@@ -213,7 +212,7 @@ class TestCLITemplate(unittest.TestCase):
         config2 = CiscoConfParse(templateConfiguration2.splitlines())
         # Act
         result = CLITemplate(
-            template_name="test", template_description="test", device_model=DeviceModel.VEDGE
+            template_name="test", template_description="test", device_model="vedge-cloud"
         ).compare_template(config1, config2)
         # Assert
         self.assertEqual(result, "")

catalystwan/tests/test_endpoints.py

@@ -6,14 +6,14 @@ import tempfile
 import unittest
 from enum import Enum
 from pathlib import Path
-from typing import Dict, List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union
 from unittest.mock import MagicMock
 from uuid import UUID, uuid4
 
 import pytest  # type: ignore
 from packaging.version import Version  # type: ignore
 from parameterized import parameterized  # type: ignore
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, model_serializer
 from typing_extensions import Annotated
 
 from catalystwan.endpoints import (
@@ -29,6 +29,7 @@ from catalystwan.endpoints import (
 from catalystwan.endpoints import logger as endpoints_logger
 from catalystwan.endpoints import post, put, request, versions, view
 from catalystwan.exceptions import APIEndpointError, APIRequestPayloadTypeError, APIVersionError, APIViewError
+from catalystwan.models.common import VersionedField
 from catalystwan.typed_list import DataSequence
 from catalystwan.utils.session_type import ProviderAsTenantView, ProviderView, TenantView
 
@@ -308,14 +309,6 @@ class TestAPIEndpoints(unittest.TestCase):
                 def get_data(self, payload: List[str]) -> None:  # type: ignore [empty-body]
                     ...
 
-    def test_request_decorator_unsupported_payload_composite_type(self):
-        with self.assertRaises(APIEndpointError):
-
-            class TestAPI(APIEndpoints):
-                @request("POST", "/v1/data")
-                def get_data(self, payload: Dict[str, BaseModelExample]) -> None:  # type: ignore [empty-body]
-                    ...
-
     @parameterized.expand(
         [
             (BaseModelExample, False, TypeSpecifier(True, None, BaseModelExample, None, False, False)),
@@ -351,7 +344,7 @@ class TestAPIEndpoints(unittest.TestCase):
             (None, True, None),
         ]
     )
-    def test_request_decorator_payload_spec(self, payload_type, raises, expected_payload_spec):
+    def test_request_decorator_payload_spec(self, payload_type, raises, expected_payload_spec: Optional[TypeSpecifier]):
         # Arrange
         class TestAPI(APIEndpoints):
             def get_data(self, payload: payload_type) -> None:  # type: ignore [empty-body]
@@ -364,6 +357,11 @@ class TestAPIEndpoints(unittest.TestCase):
                 decorator(TestAPI.get_data)
         else:
             decorator(TestAPI.get_data)
+            if expected_payload_spec is not None and expected_payload_spec.payload_union_model_types is not None:
+                # check both list contains same set and skip member list comparison below
+                assert decorator.payload_spec.payload_model_set == expected_payload_spec.payload_model_set
+                decorator.payload_spec.payload_union_model_types = None
+                expected_payload_spec.payload_union_model_types = None
             assert decorator.payload_spec == expected_payload_spec
 
     def test_request_decorator_not_annotated_params(self):
@@ -874,3 +872,36 @@ class TestAPIEndpoints(unittest.TestCase):
             @request("POST", "/v1/data")
             def create(self, payload: AnyBaseModel) -> None:  # type: ignore [empty-body]
                 ...
+
+    @parameterized.expand(
+        [
+            ("1.3", '{"name":"John"}'),
+            ("1.9", '{"newName":"John"}'),
+        ]
+    )
+    def test_api_version_passed_in_dump_context(self, version, expected_payload_json):
+        # Arrange
+        class Payload(BaseModel):
+            model_config = ConfigDict(populate_by_name=True)
+            name: Annotated[str, VersionedField(versions=">1.6", serialization_alias="newName")]
+
+            @model_serializer(mode="wrap")
+            def serialize(self, handler, info):
+                return VersionedField.dump(self.model_fields, handler(self), info)
+
+        class ExampleAPI(APIEndpoints):
+            @request("POST", "/v1/data")
+            def create(self, payload: Payload) -> None:  # type: ignore [empty-body]
+                ...
+
+        self.session_mock.api_version = Version(version)
+        api = ExampleAPI(self.session_mock)
+        # Act
+        api.create(Payload(name="John"))
+        # Assert
+        self.session_mock.request.assert_called_once_with(
+            "POST",
+            self.base_path + "/v1/data",
+            data=expected_payload_json,
+            headers={"content-type": "application/json"},
+        )