catalystwan 0.40.2.dev1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

catalystwan/tests/test_alarms_api.py

@@ -1,251 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-import logging
-from unittest import TestCase
-from unittest.mock import patch
-
-from catalystwan.api.alarms_api import AlarmsAPI, AlarmVerification
-from catalystwan.dataclasses import AlarmData
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.alarm_status import Severity
-from catalystwan.utils.creation_tools import create_dataclass, flatten_dict
-
-
-class TestAlarmsAPI(TestCase):
-    def setUp(self) -> None:
-        self.alarms_data = {
-            "data": [
-                {
-                    "type": "site_up",
-                    "component": "OMP",
-                    "severity": "Critical",
-                    "active": False,
-                    "acknowledged": False,
-                    "consumed_events": [
-                        {
-                            "eventname": "omp-peer-state-change",
-                            "peer-new-state": "handshake-in-gr",
-                            "eventId": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
-                            "builtBy": "EventDataCollector",
-                            "component": "OMP",
-                            "severity-level": "major ",
-                            "vmanage-system-ip": "1.1.1.1",
-                            "entry_time": 1671028426000,
-                            "system-ip": "1.1.1.1",
-                            "host-name": "vm1",
-                            "peer": "1.1.1.1",
-                        }
-                    ],
-                    "site_id": "1",
-                    "devices": [{"system-ip": "1.1.1.1"}],
-                },
-                {
-                    "type": "site_up",
-                    "component": "OMP",
-                    "severity": "Major",
-                    "active": False,
-                    "acknowledged": False,
-                    "consumed_events": [
-                        {
-                            "eventname": "omp-peer-state-change",
-                            "peer-new-state": "handshake-in-gr",
-                            "eventId": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaab",
-                            "builtBy": "EventDataCollector",
-                            "component": "OMP",
-                            "severity-level": "major ",
-                            "vmanage-system-ip": "1.1.1.2",
-                            "entry_time": 1671028426000,
-                            "system-ip": "1.1.1.2",
-                            "host-name": "vm2",
-                            "peer": "1.1.1.2",
-                        }
-                    ],
-                    "site_id": "2",
-                    "devices": [{"system-ip": "1.1.1.2"}],
-                },
-                {
-                    "type": "site_up",
-                    "component": "OMP",
-                    "severity": "Medium",
-                    "active": False,
-                    "acknowledged": False,
-                    "consumed_events": [
-                        {
-                            "eventname": "omp-peer-state-change",
-                            "peer-new-state": "handshake-in-gr",
-                            "eventId": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaac",
-                            "builtBy": "EventDataCollector",
-                            "component": "OMP",
-                            "severity-level": "major ",
-                            "vmanage-system-ip": "1.1.1.3",
-                            "entry_time": 1671028426000,
-                            "system-ip": "1.1.1.3",
-                            "host-name": "vm3",
-                            "peer": "1.1.1.3",
-                        }
-                    ],
-                    "site_id": "3",
-                    "devices": [{"system-ip": "1.1.1.3"}],
-                },
-                {
-                    "type": "site_up",
-                    "component": "OMP",
-                    "severity": "Minor",
-                    "active": False,
-                    "acknowledged": False,
-                    "consumed_events": [
-                        {
-                            "eventname": "omp-peer-state-change",
-                            "peer-new-state": "handshake-in-gr",
-                            "eventId": "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaad",
-                            "builtBy": "EventDataCollector",
-                            "component": "OMP",
-                            "severity-level": "major ",
-                            "vmanage-system-ip": "1.1.1.4",
-                            "entry_time": 1671028426000,
-                            "system-ip": "1.1.1.4",
-                            "host-name": "vm4",
-                            "peer": "1.1.1.4",
-                        }
-                    ],
-                    "site_id": "4",
-                    "devices": [{"system-ip": "1.1.1.4"}],
-                },
-            ]
-        }
-        self.alarms = self.alarms_data["data"]
-        self.critical_alarms_data = {"data": [self.alarms[0]]}
-        self.major_alarms_data = {"data": [self.alarms[1]]}
-        self.medium_alarms_data = {"data": [self.alarms[2]]}
-        self.minor_alarms_data = {"data": [self.alarms[3]]}
-        self.alarms_dataseq = DataSequence(
-            AlarmData, [create_dataclass(AlarmData, flatten_dict(alarm)) for alarm in self.alarms]
-        )
-        self.critical_alarms_dataseq = DataSequence(
-            AlarmData, [create_dataclass(AlarmData, flatten_dict(self.alarms[0]))]
-        )
-        self.major_alarms_dataseq = DataSequence(AlarmData, [create_dataclass(AlarmData, flatten_dict(self.alarms[1]))])
-        self.medium_alarms_dataseq = DataSequence(
-            AlarmData, [create_dataclass(AlarmData, flatten_dict(self.alarms[2]))]
-        )
-        self.minor_alarms_dataseq = DataSequence(AlarmData, [create_dataclass(AlarmData, flatten_dict(self.alarms[3]))])
-        self.maxDiff = None
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).get()
-        # Assert
-        self.assertEqual(answer, self.alarms_dataseq)
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_critical_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).get().filter(severity=Severity.CRITICAL)
-        # Assert
-        self.assertEqual(answer, self.critical_alarms_dataseq)
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_major_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).get().filter(severity=Severity.MAJOR)
-        # Assert
-        self.assertEqual(answer, self.major_alarms_dataseq)
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_medium_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).get().filter(severity=Severity.MEDIUM)
-        # Assert
-        self.assertEqual(answer, self.medium_alarms_dataseq)
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_minor_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).get().filter(severity=Severity.MINOR)
-        # Assert
-        self.assertEqual(answer, self.minor_alarms_dataseq)
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_not_viewed_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).get().filter(viewed=False)
-        # Assert
-        self.assertEqual(answer, self.alarms_dataseq)
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_check_alarms(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.alarms_data
-        # Act
-        answer = AlarmsAPI(mock_session).check_alarms(self.minor_alarms_data["data"])
-        # Assert
-        self.assertEqual(answer, {"found": set(self.minor_alarms_dataseq), "not-found": set()})
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_check_alarms_not_found(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.dataseq.return_value = self.major_alarms_dataseq
-        # Act
-        answer = AlarmsAPI(mock_session).check_alarms(self.minor_alarms_data["data"], 2, 1)
-        # Assert
-        self.assertEqual(answer, {"found": set(), "not-found": set(self.minor_alarms_dataseq)})
-
-    # # # test AlarmVerification class
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_verify(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.dataseq.return_value = self.major_alarms_dataseq
-        alarms_getter = AlarmsAPI(mock_session).get
-        logger = logging.getLogger("test")
-        # Act
-        answer = AlarmVerification(logger, alarms_getter)
-        answer.verify(set(self.minor_alarms_dataseq), 2, 1)
-        # Assert
-        self.assertEqual(answer.found, set())
-        self.assertEqual(answer.not_found, set(self.minor_alarms_dataseq))
-
-    @patch("catalystwan.response.ManagerResponse")
-    @patch("catalystwan.session.ManagerSession")
-    def test_verify_not_found(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.dataseq.return_value = self.critical_alarms_dataseq
-        alarms_getter = AlarmsAPI(mock_session).get
-        logger = logging.getLogger("test")
-        # Act
-        answer = AlarmVerification(logger, alarms_getter)
-        answer.verify(set(self.minor_alarms_dataseq), 2, 1)
-        # Assert
-        self.assertEqual(answer.found, set())
-        self.assertEqual(answer.not_found, set(self.minor_alarms_dataseq))

catalystwan/tests/test_cli_template.py

@@ -1,218 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import patch
-from urllib.error import HTTPError
-
-from ciscoconfparse import CiscoConfParse  # type: ignore
-
-from catalystwan.api.templates.cli_template import CLITemplate
-from catalystwan.dataclasses import Device
-from catalystwan.exceptions import TemplateTypeError
-
-
-class TestCLITemplate(unittest.TestCase):
-    def setUp(self):
-        self.config = """
-        system\n
-        host-name               host5\n
-        system-ip               192.168.1.25\n
-        site-id                 2\n
-        admin-tech-on-failure\n
-        no route-consistency-check\n
-        no vrrp-advt-with-phymac\n
-        sp-organization-name    "organization"\n
-        organization-name       "organization"\n
-        vbond vbond\n
-        aaa\n
-        auth-order      local radius tacacs\n
-        usergroup basic\n
-        task system read\n
-        task interface read\n
-        !\n
-        usergroup netadmin\n
-        """
-        self.template = CiscoConfParse(self.config.splitlines())
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_load_success(self, mock_session):
-        # Arrange
-        mock_session.get_json.return_value = {"configType": "file", "templateConfiguration": self.config}
-        # Act
-        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)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_load_raise(self, mock_session):
-        # Arrange
-        mock_session.get_json.return_value = {
-            "templateName": "test",
-            "configType": "template",
-            "templateConfiguration": self.config,
-        }
-        # Act
-        temp = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
-
-        def answer():
-            return temp.load(session=mock_session, id="temp_id")
-
-        # Assert
-        self.assertRaises(TemplateTypeError, answer)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_load_running_success(self, mock_session):
-        # Arrange
-        mock_session.get_json.return_value = {"configType": "file", "config": self.config}
-        device = Device(
-            personality="vedge",
-            uuid="mock_uuid",
-            id="mock_ip",
-            hostname="mock_host",
-            reachability="reachable",
-            local_system_ip="mock_ip",
-            status="normal",
-            memUsage=1.0,
-            connected_vManages=["192.168.0.1"],
-            model="vedge-cloud",
-        )
-        # Act
-        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)
-
-    def test_generate_payload(self):
-        # Arrange
-        template = CLITemplate(
-            template_name="test", template_description="test", device_model="vedge-cloud", config=self.template
-        )
-        # Act
-        answer = template.generate_payload()
-        # Assert
-        templateConfiguration = (
-            "        system\n"
-            "        host-name               host5\n"
-            "        system-ip               192.168.1.25\n"
-            "        site-id                 2\n"
-            "        admin-tech-on-failure\n"
-            "        no route-consistency-check\n"
-            "        no vrrp-advt-with-phymac\n"
-            '        sp-organization-name    "organization"\n'
-            '        organization-name       "organization"\n'
-            "        vbond vbond\n"
-            "        aaa\n"
-            "        auth-order      local radius tacacs\n"
-            "        usergroup basic\n"
-            "        task system read\n"
-            "        task interface read\n"
-            "        !\n"
-            "        usergroup netadmin"
-        )
-        proper_answer = {
-            "templateName": "test",
-            "templateDescription": "test",
-            "deviceType": "vedge-cloud",
-            "templateConfiguration": templateConfiguration,
-            "factoryDefault": False,
-            "configType": "file",
-        }
-        self.assertEqual(answer, proper_answer)
-
-    def test_generate_payload_cedge(self):
-        # Arrange
-        template = CLITemplate(
-            template_name="test",
-            template_description="test",
-            device_model="vedge-C8000V",
-            config=self.template,
-        )
-        # Act
-        answer = template.generate_payload()
-        # Assert
-        templateConfiguration = (
-            "        system\n"
-            "        host-name               host5\n"
-            "        system-ip               192.168.1.25\n"
-            "        site-id                 2\n"
-            "        admin-tech-on-failure\n"
-            "        no route-consistency-check\n"
-            "        no vrrp-advt-with-phymac\n"
-            '        sp-organization-name    "organization"\n'
-            '        organization-name       "organization"\n'
-            "        vbond vbond\n"
-            "        aaa\n"
-            "        auth-order      local radius tacacs\n"
-            "        usergroup basic\n"
-            "        task system read\n"
-            "        task interface read\n"
-            "        !\n"
-            "        usergroup netadmin"
-        )
-        proper_answer = {
-            "templateName": "test",
-            "templateDescription": "test",
-            "deviceType": "vedge-C8000V",
-            "templateConfiguration": templateConfiguration,
-            "factoryDefault": False,
-            "configType": "file",
-            "cliType": "device",
-            "draftMode": False,
-        }
-        self.assertEqual(answer, proper_answer)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_update_suceess(self, mock_session):
-        # Arrange
-        mock_session.put.return_value = {"data": {"attachedDevices": []}}
-        templateConfiguration = (
-            "        system\n"
-            "        host-name               host6\n"
-            "        system-ip               192.168.1.26\n"
-        )
-        config = CiscoConfParse(templateConfiguration.splitlines())
-        # Act
-        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)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_update_template_failure(self, mock_session):
-        # Arrange
-
-        mock_session.put.side_effect = HTTPError("url", 400, "error_400", "msg", 1)
-
-        templateConfiguration = (
-            "        system\n"
-            "        host-name               host6\n"
-            "        system-ip               192.168.1.26\n"
-        )
-        config = CiscoConfParse(templateConfiguration.splitlines())
-        template = CLITemplate(template_name="test", template_description="test", device_model="vedge-cloud")
-
-        # Act
-        with self.assertRaises(HTTPError):
-            template.update(session=mock_session, id="temp_id", config=config)
-
-    def test_compare_template(self):
-        # Arrange
-        templateConfiguration1 = (
-            "        system\n"
-            "        host-name               host6\n"
-            "        system-ip               192.168.1.26\n"
-        )
-        config1 = CiscoConfParse(templateConfiguration1.splitlines())
-        templateConfiguration2 = (
-            "        system\n"
-            "        host-name               host6\n"
-            "        system-ip               192.168.1.26\n"
-        )
-        config2 = CiscoConfParse(templateConfiguration2.splitlines())
-        # Act
-        result = CLITemplate(
-            template_name="test", template_description="test", device_model="vedge-cloud"
-        ).compare_template(config1, config2)
-        # Assert
-        self.assertEqual(result, "")

catalystwan/tests/test_creation_tools.py

@@ -1,155 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-# type: ignore
-import datetime
-import json
-import unittest
-from typing import Optional
-
-from attrs import define, field
-from parameterized import parameterized
-
-from catalystwan.dataclasses import TLOC, DataclassBase, Device, PacketSetup, TacacsServer, TenantTacacsServer
-from catalystwan.utils.creation_tools import FIELD_NAME, asdict, convert_attributes, create_dataclass
-from catalystwan.utils.personality import Personality
-from catalystwan.utils.reachability import Reachability
-
-
-@define
-class _TestObjectD:
-    d: int
-
-
-@define
-class _TestObjectC:
-    c: int
-    dd: Optional[_TestObjectD] = None
-
-
-@define
-class _TestObjectB:
-    rnd: int = field(metadata={FIELD_NAME: "RANDOM"})
-
-
-@define
-class _TestObjectA:
-    a: int = field(metadata={FIELD_NAME: "A"})
-    b: _TestObjectB = field(metadata={FIELD_NAME: "BBB"})
-    c: Optional[_TestObjectC] = None
-
-
-class TestCreationTools(unittest.TestCase):
-    @parameterized.expand(
-        [
-            (TLOC(1, 1), {"color": 1, "encapsulation": 1}),
-            (PacketSetup(1, 2), {"sessionId": 1, "isNewSession": 2}),
-            (
-                Device(1, "vbond", *range(2), "reachable", 1),
-                {
-                    "deviceId": 0,
-                    "host-name": 1,
-                    "local-system-ip": 1,
-                    "memState": None,
-                    "cpuState": None,
-                    "cpuLoad": None,
-                    "connectedVManages": [],
-                    "device-model": None,
-                    "board-serial": None,
-                    "vedgeCertificateState": None,
-                    "chasisNumber": None,
-                    "uuid": 1,
-                    "personality": Personality.VBOND,
-                    "reachability": Reachability.REACHABLE,
-                    "status": None,
-                    "memUsage": None,
-                    "state_description": None,
-                    "site-id": None,
-                    "site-name": None,
-                },
-            ),
-            (_TestObjectA(1, _TestObjectB(2)), {"BBB": {"RANDOM": 2}, "A": 1, "c": None}),
-            (
-                _TestObjectA(1, _TestObjectB(2), _TestObjectC(1)),
-                {"BBB": {"RANDOM": 2}, "A": 1, "c": {"c": 1, "dd": None}},
-            ),
-            (
-                _TestObjectA(1, _TestObjectB(2), _TestObjectC(1, _TestObjectD(111))),
-                {"BBB": {"RANDOM": 2}, "A": 1, "c": {"c": 1, "dd": {"d": 111}}},
-            ),
-            (
-                TenantTacacsServer(1, "2", [TacacsServer(*range(7)), TacacsServer(*range(2, 9))]),
-                {
-                    "timeout": 1,
-                    "authentication": "2",
-                    "server": [
-                        {
-                            "address": 0,
-                            "authPort": 1,
-                            "vpn": 2,
-                            "vpnIpSubnet": 3,
-                            "key": 4,
-                            "secretKey": 5,
-                            "priority": 6,
-                        },
-                        {
-                            "address": 2,
-                            "authPort": 3,
-                            "vpn": 4,
-                            "vpnIpSubnet": 5,
-                            "key": 6,
-                            "secretKey": 7,
-                            "priority": 8,
-                        },
-                    ],
-                },
-            ),
-        ]
-    )
-    def test_asdict(self, obj, serialized_obj):
-        # Arrange, Act
-        output = asdict(obj)
-        print(output)
-        # Assert
-        self.assertEqual(output, serialized_obj)
-
-    @parameterized.expand(
-        [
-            (TLOC(1, 1), '{"color": 1, "encapsulation": 1}'),
-            (PacketSetup(1, 2), '{"sessionId": 1, "isNewSession": 2}'),
-            (
-                Device(1, "vbond", *range(2), "reachable", 1, site_id="100", site_name="SITE_100"),
-                '{"deviceId": 0, "host-name": 1, "local-system-ip": 1, "memState": null, "cpuState": null, '
-                '"cpuLoad": null, "connectedVManages": [], "device-model": null, "board-serial": null, '
-                '"vedgeCertificateState": null, "chasisNumber": null, "site-id": "100", "site-name": "SITE_100", '
-                '"uuid": 1, "personality": "vbond", "reachability": "reachable", "status": null, "memUsage": null, '
-                '"state_description": null}',
-            ),
-        ]
-    )
-    def test_asdict_json(self, obj, serialized_obj):
-        # Arrange, Act
-        output = json.dumps(asdict(obj))
-        # Assert
-        print(output)
-        self.assertEqual(output, serialized_obj)
-
-    def test_convert_attributes(self):
-        # Arrange
-        @define(field_transformer=convert_attributes)
-        class ConvertibleData(DataclassBase):
-            date_time_1: datetime.datetime = field(metadata={FIELD_NAME: "fromUnixEpochTimestamp"})
-            date_time_2: datetime.datetime = field(metadata={FIELD_NAME: "fromString"})
-
-        conv_data_dict = {
-            "fromUnixEpochTimestamp": 1689324694991,
-            "fromString": "2023-07-14T07:11:09+00:00",
-        }
-        # Act
-        conv_data = create_dataclass(ConvertibleData, conv_data_dict)
-        # Assert
-        assert isinstance(conv_data.date_time_1, datetime.datetime)
-        assert isinstance(conv_data.date_time_2, datetime.datetime)
-
-
-if __name__ == "__main__":
-    unittest.main()