catalystwan 0.40.1.dev6__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

catalystwan/tests/test_version.py

@@ -1,99 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-
-from packaging.version import Version  # type: ignore
-from parameterized import parameterized  # type: ignore
-
-from catalystwan.version import NullVersion, parse_api_version, parse_vmanage_version
-
-
-class TestNullVersion(unittest.TestCase):
-    def test_null_version_properties(self):
-        # Arrange, Act
-        version = NullVersion()
-
-        # Assert
-        self.assertEqual(version.micro, 0)
-        self.assertEqual(version.minor, 0)
-        self.assertEqual(version.major, 0)
-        self.assertEqual(version.base_version, "0")
-        self.assertEqual(version.public, "NullVersion")
-        self.assertEqual(version.local, None)
-        self.assertEqual(version.dev, None)
-        self.assertEqual(version.post, None)
-        self.assertEqual(version.pre, None)
-        self.assertEqual(version.release, (0,))
-        self.assertEqual(version.epoch, 0)
-
-        self.assertFalse(version.is_devrelease)
-        self.assertFalse(version.is_postrelease)
-        self.assertFalse(version.is_prerelease)
-
-    def test_str(self):
-        # Arrange, Act
-        version = NullVersion()
-
-        # Assert
-        self.assertEqual(version.__str__(), "NullVersion")
-
-    @parameterized.expand(
-        [
-            (Version("0"),),
-            (Version("1.0.0"),),
-            (Version("1.0.0-111"),),
-            (Version("20.12"),),
-        ]
-    )
-    def test_compare(self, version: Version):
-        # Arrange, Act
-        null_version = NullVersion()
-
-        # Assert
-        self.assertTrue(version > null_version)
-
-
-class TestVersion(unittest.TestCase):
-    @parameterized.expand(
-        [
-            ("1.0.0", Version("1.0.0")),
-            ("0", Version("0")),
-            ("20.12.0-914-xy", Version("20.12")),
-            ("random_string", NullVersion()),
-        ]
-    )
-    def test_parse_api_version(self, version: str, result: Version):
-        # Arrange, Act
-        parsed_version = parse_api_version(version)
-
-        # Assert
-        self.assertEqual(parsed_version, result)
-
-    @parameterized.expand(
-        [
-            ("1.0.0", Version("1.0.0")),
-            ("0", Version("0")),
-            ("20.12.0-914-xy", Version("20.12.0-914")),
-            ("abc-20.1.9", Version("20.1.9")),
-            ("smart-li-20.13.999-3077", Version("20.13.999-3077")),
-            ("random_string", NullVersion()),
-        ]
-    )
-    def test_parse_vmanage_version(self, version: str, result: Version):
-        # Arrange, Act
-        parsed_version = parse_vmanage_version(version)
-
-        # Assert
-        self.assertEqual(parsed_version, result)
-
-    def test_parse_api_version_object(self):
-        # Arrange, Act
-        parsed_version = parse_api_version("Not a Version!")
-
-        # Assert
-        self.assertTrue(isinstance(parsed_version, NullVersion))
-        self.assertFalse(isinstance(Version("20.11"), NullVersion))
-
-
-if __name__ == "__main__":
-    unittest.main()

catalystwan/tests/test_version_utils.py

@@ -1,240 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import MagicMock, Mock, patch
-
-from catalystwan.api.versions_utils import DeviceSoftwareRepository, DeviceVersions, RepositoryAPI
-from catalystwan.endpoints.configuration.software_actions import SoftwareImageDetails
-from catalystwan.endpoints.configuration_device_actions import InstalledDeviceData, PartitionDevice
-from catalystwan.endpoints.configuration_device_inventory import DeviceDetailsResponse
-from catalystwan.typed_list import DataSequence
-
-
-class TestRepositoryAPI(unittest.TestCase):
-    def setUp(self):
-        self.device = DeviceDetailsResponse(
-            personality="vedge",
-            uuid="mock_uuid",
-            device_ip="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",
-        )
-        self.DeviceSoftwareRepository_obj = {
-            "mock_uuid": DeviceSoftwareRepository(
-                installed_versions=["ver1", "ver2", "curr_ver"],
-                availableVersions=["ver1", "ver2"],
-                version="curr_ver",
-                defaultVersion="def_ver",
-                uuid="mock_uuid",
-            )
-        }
-        mock_session = Mock()
-        self.mock_repository_object = RepositoryAPI(mock_session)
-
-    @patch("catalystwan.session.Session")
-    def test_get_image_version_if_image_available(self, mock_session):
-        versions_response = DataSequence(
-            SoftwareImageDetails,
-            [SoftwareImageDetails(**{"availableFiles": "vmanage-20.9.1-x86_64.tar.gz", "versionName": "20.9.1"})],
-        )
-        self.mock_repository_object.get_all_software_images = MagicMock(return_value=versions_response)
-        image_version = "20.9.1"
-        answer = self.mock_repository_object.get_image_version("vmanage-20.9.1-x86_64.tar.gz")
-
-        self.assertEqual(answer, image_version, "not same version")
-
-    @patch("catalystwan.session.Session")
-    def test_get_image_version_if_image_unavailable(self, mock_session):
-        api_mock_response = [{"availableFiles": "vmanage-20.9.2-x86_64.tar.gz", "versionName": "20.9.1"}]
-        mock_session.get_data.return_value = api_mock_response
-        image_version = None
-        answer = RepositoryAPI(mock_session).get_image_version("vmanage-20.9.1-x86_64.tar.gz")
-
-        self.assertEqual(answer, image_version, "not same version")
-
-    def test_get_remote_image(self):
-        versions_response = DataSequence(
-            SoftwareImageDetails,
-            [
-                SoftwareImageDetails(
-                    **{
-                        "availableFiles": "vmanage-20.9.1-x86_64.tar.gz",
-                        "versionType": "remote-server-test",
-                        "remoteServerId": "123456789-abcdabcd",
-                        "versionId": "abcd-1234",
-                    }
-                )
-            ],
-        )
-        self.mock_repository_object.get_all_software_images = MagicMock(return_value=versions_response)
-        answer = self.mock_repository_object.get_remote_image("vmanage-20.9.1-x86_64.tar.gz", "remote-server-test")
-
-        self.assertEqual(answer.version_id, "abcd-1234", "not same version")
-
-    def test_get_remote_image_non_existing(self):
-        versions_response = DataSequence(
-            SoftwareImageDetails,
-            [
-                SoftwareImageDetails(
-                    **{
-                        "availableFiles": "vmanage-20.9.1-x86_64.tar.gz",
-                        "versionType": "remote-server-test",
-                        "remoteServerId": "123456789-abcdabcd",
-                        "versionId": "abcd-1234",
-                    }
-                )
-            ],
-        )
-        self.mock_repository_object.get_all_software_images = MagicMock(return_value=versions_response)
-        answer = self.mock_repository_object.get_remote_image("vmanage-20.10.1-x86_64.tar.gz", "remote-server-test")
-
-        self.assertEqual(answer, None, "not same version")
-
-    def test_get_remote_image_no_version_id(self):
-        versions_response = DataSequence(
-            SoftwareImageDetails,
-            [
-                SoftwareImageDetails(
-                    **{
-                        "availableFiles": "vmanage-20.9.1-x86_64.tar.gz",
-                        "versionType": "remote-server-test",
-                        "remoteServerId": "123456789-abcdabcd",
-                        "versionId": None,
-                    }
-                )
-            ],
-        )
-        self.mock_repository_object.get_all_software_images = MagicMock(return_value=versions_response)
-
-        with self.assertRaises(ValueError):
-            self.mock_repository_object.get_remote_image("vmanage-20.9.1-x86_64.tar.gz", "remote-server-test")
-
-    def test_get_version_when_same_available_file_present_for_remote_version(self):
-        versions_response = DataSequence(
-            SoftwareImageDetails,
-            [
-                SoftwareImageDetails(
-                    **{
-                        "availableFiles": "vmanage-20.9.1-x86_64.tar.gz",
-                        "versionType": "remote-server-test",
-                        "remoteServerId": "123456789-abcdabcd",
-                        "versionId": "abcd-1234",
-                    }
-                ),
-                SoftwareImageDetails(**{"availableFiles": "vmanage-20.9.1-x86_64.tar.gz", "versionName": "20.9.1"}),
-            ],
-        )
-        self.mock_repository_object.get_all_software_images = MagicMock(return_value=versions_response)
-        image_version = "20.9.1"
-        answer = self.mock_repository_object.get_image_version("vmanage-20.9.1-x86_64.tar.gz")
-
-        self.assertEqual(answer, image_version, "not same version")
-
-    def test_get_version_when_remote_available_file_is_matching(self):
-        versions_response = DataSequence(
-            SoftwareImageDetails,
-            [
-                SoftwareImageDetails(
-                    **{
-                        "availableFiles": "vmanage-20.9.1-x86_64.tar.gz",
-                        "versionType": "remote-server-test",
-                        "remoteServerId": "123456789-abcdabcd",
-                        "versionId": "abcd-1234",
-                    }
-                ),
-                SoftwareImageDetails(**{"availableFiles": "vmanage-20.10.1-x86_64.tar.gz", "versionName": "20.9.1"}),
-            ],
-        )
-        self.mock_repository_object.get_all_software_images = MagicMock(return_value=versions_response)
-        answer = self.mock_repository_object.get_image_version("vmanage-20.9.1-x86_64.tar.gz")
-
-        self.assertEqual(answer, None)
-
-    @patch("catalystwan.session.Session")
-    def test_get_devices_versions_repository(self, mock_session):
-        endpoint_mock_response = DataSequence(
-            InstalledDeviceData,
-            [
-                InstalledDeviceData(
-                    **{
-                        "availableVersions": ["ver1", "ver2"],
-                        "version": "curr_ver",
-                        "defaultVersion": "def_ver",
-                        "uuid": "mock_uuid",
-                    }
-                )
-            ],
-        )
-
-        self.mock_repository_object.session.endpoints.configuration_device_actions.get_list_of_installed_devices = (
-            MagicMock(return_value=endpoint_mock_response)
-        )
-
-        answer = self.mock_repository_object.get_devices_versions_repository()
-
-        self.assertEqual(
-            answer["mock_uuid"],
-            self.DeviceSoftwareRepository_obj["mock_uuid"],
-            "DeviceSoftwareRepository object created uncorrectly",
-        )
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_get_device_available(self, mock_get_devices_versions_repository):
-        # Prepare mock data
-        mock_get_devices_versions_repository.return_value = Mock()
-        mock_session = Mock()
-        mock_repository_object = RepositoryAPI(mock_session)
-        mock_device_versions = DeviceVersions(mock_repository_object)
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        answer = mock_device_versions.get_device_available("ver1", [self.device])
-        expected_result = DataSequence(
-            PartitionDevice, [PartitionDevice(device_id="mock_uuid", device_ip="mock_ip", version="ver1")]
-        )
-
-        # Assert
-        self.assertEqual(
-            answer,
-            expected_result,
-            "Version add incorrectly",
-        )
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_get_device_list_if_in_installed(self, mock_get_devices_versions_repository):
-        # Prepare mock data
-        mock_get_devices_versions_repository.return_value = Mock()
-        mock_session = Mock()
-        mock_repository_object = RepositoryAPI(mock_session)
-        mock_device_versions = DeviceVersions(mock_repository_object)
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        answer = mock_device_versions.get_device_list_in_installed("ver1", [self.device])
-        expected_result = DataSequence(
-            PartitionDevice, [PartitionDevice(device_id="mock_uuid", device_ip="mock_ip", version="ver1")]
-        )
-
-        # Assert
-        self.assertEqual(
-            answer,
-            expected_result,
-            "Version add incorrectly",
-        )
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_get_devices_current_version(self, mock_get_devices_versions_repository):
-        # Arrange
-        mock_session = Mock()
-        mock_get_devices_versions_repository.return_value = Mock()
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        mock_repository_object = RepositoryAPI(mock_session)
-        mock_device_versions = DeviceVersions(mock_repository_object)
-        # Act
-        answer = mock_device_versions.get_devices_current_version([self.device])
-        # Answer
-        proper_answer = DataSequence(
-            PartitionDevice, [PartitionDevice(device_id="mock_uuid", device_ip="mock_ip", version="curr_ver")]
-        )
-        self.assertEqual(answer, proper_answer)

catalystwan/tests/test_vmanage_auth.py

@@ -1,149 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from datetime import timedelta
-from typing import Callable, Dict, List, Union
-from unittest import TestCase, mock
-from uuid import uuid4
-
-from requests import Request
-from requests.cookies import RequestsCookieJar
-
-from catalystwan import USER_AGENT
-from catalystwan.exceptions import CatalystwanException
-from catalystwan.vmanage_auth import UnauthorizedAccessError, vManageAuth
-
-
-class MockResponse:
-    def __init__(self, status_code: int, text: str, cookies: Union[dict, RequestsCookieJar]):
-        self._status_code = status_code
-        self._text = text
-        self.cookies = cookies
-        self.request = Request()
-        self.history: List = list()
-        self.reason = "MockResponse"
-        self.elapsed = timedelta(0)
-        self.headers: Dict = dict()
-        self.json: Callable[..., Dict] = lambda: dict()
-
-    @property
-    def status_code(self) -> int:
-        return self._status_code
-
-    @property
-    def text(self) -> str:  # TODO
-        return self._text
-
-
-def mock_request_j_security_check(*args, **kwargs):
-    jsessionid_cookie = RequestsCookieJar()
-    jsessionid_cookie.set("JSESSIONID", "xyz")
-    url_response = {
-        "https://1.1.1.1:1111/j_security_check": {
-            "admin": MockResponse(200, "", jsessionid_cookie),
-            "invalid_username": MockResponse(200, "<html>error</html>", {}),
-        }
-    }
-
-    full_url = kwargs.get("url", "")
-    data = kwargs.get("data", {})
-    if full_url in url_response:
-        return url_response[full_url][data["j_username"]]
-
-    return MockResponse(404, "error", {})
-
-
-def mock_valid_token(*args, **kw):
-    return MockResponse(200, "valid-token", {})
-
-
-def mock_invalid_token_status(*args, **kw):
-    return MockResponse(503, "invalid-token", {})
-
-
-def mock_invalid_token_format(*args, **kw):
-    return MockResponse(200, "<html>error</html>", {})
-
-
-class TestvManageAuth(TestCase):
-    def setUp(self):
-        self.base_url = "https://1.1.1.1:1111"
-        self.password = str(uuid4())
-
-    @mock.patch("catalystwan.vmanage_auth.post", side_effect=mock_request_j_security_check)
-    def test_get_cookie(self, mock_post):
-        # Arrange
-        username = "admin"
-        security_payload = {
-            "j_username": username,
-            "j_password": self.password,
-        }
-        # Act
-        vmanage_auth = vManageAuth(username, self.password)
-        vmanage_auth._base_url = self.base_url
-        vmanage_auth.get_jsessionid()
-
-        # Assert
-        mock_post.assert_called_with(
-            url="https://1.1.1.1:1111/j_security_check",
-            data=security_payload,
-            verify=False,
-            headers={"Content-Type": "application/x-www-form-urlencoded", "User-Agent": USER_AGENT},
-        )
-
-    @mock.patch("catalystwan.vmanage_auth.post", side_effect=mock_request_j_security_check)
-    def test_get_cookie_invalid_username(self, mock_post):
-        # Arrange
-        username = "invalid_username"
-        security_payload = {
-            "j_username": username,
-            "j_password": self.password,
-        }
-        # Act
-        with self.assertRaises(UnauthorizedAccessError):
-            vManageAuth(username, self.password).get_jsessionid()
-
-        # Assert
-        mock_post.assert_called_with(
-            url="/j_security_check",
-            data=security_payload,
-            verify=False,
-            headers={"Content-Type": "application/x-www-form-urlencoded", "User-Agent": USER_AGENT},
-        )
-
-    @mock.patch("catalystwan.vmanage_auth.get", side_effect=mock_valid_token)
-    def test_fetch_token(self, mock_get):
-        # Arrange
-        valid_url = "https://1.1.1.1:1111/dataservice/client/token"
-        cookies = RequestsCookieJar()
-        cookies.set("JSESSIONID", "xyz")
-
-        # Act
-        vmanage_auth = vManageAuth("user", self.password)
-        vmanage_auth._base_url = self.base_url
-        vmanage_auth.cookies = cookies
-        token = vmanage_auth.get_xsrftoken()
-
-        # Assert
-        self.assertEqual(token, "valid-token")
-
-        mock_get.assert_called_with(
-            url=valid_url,
-            verify=False,
-            headers={"Content-Type": "application/json", "User-Agent": USER_AGENT},
-            cookies=cookies,
-        )
-
-    @mock.patch("catalystwan.vmanage_auth.get", side_effect=mock_invalid_token_status)
-    def test_incorrect_xsrf_token_status(self, mock_get):
-        with self.assertRaises(CatalystwanException):
-            vManageAuth("user", self.password).get_xsrftoken()
-
-    @mock.patch("catalystwan.vmanage_auth.get", side_effect=mock_invalid_token_format)
-    def test_incorrect_xsrf_token_format(self, mock_get):
-        with self.assertRaises(CatalystwanException):
-            vManageAuth("user", self.password).get_xsrftoken()
-
-
-if __name__ == "__main__":
-    unittest.main()