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

catalystwan/tests/test_omp_api.py

@@ -1,438 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import patch
-
-from catalystwan.api.omp_api import OmpAPI
-from catalystwan.dataclasses import (
-    OmpAdvertisedRouteData,
-    OmpAdvertisedTlocData,
-    OmpPeerData,
-    OmpReceivedRouteData,
-    OmpReceivedTlocData,
-    OmpServiceData,
-    OmpSummaryData,
-)
-from catalystwan.utils.creation_tools import create_dataclass
-
-
-class TestOmpAPI(unittest.TestCase):
-    @patch("catalystwan.session.Session")
-    def test_omp_peers(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.omp_peer
-        # Act
-        answer = OmpAPI(mock_session).get_omp_peers(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.omp_peer_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_omp_peers_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_omp_peers(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    @patch("catalystwan.session.Session")
-    def test_advertised_routes(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.advertised_routes
-        # Act
-        answer = OmpAPI(mock_session).get_advertised_routes(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.advertised_routes_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_advertised_routes_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_advertised_routes(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    @patch("catalystwan.session.Session")
-    def test_received_routes(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.received_routes
-        # Act
-        answer = OmpAPI(mock_session).get_received_routes(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.received_routes_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_received_routes_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_received_routes(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    @patch("catalystwan.session.Session")
-    def test_advertised_tlocs(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.advertised_tlocs
-        # Act
-        answer = OmpAPI(mock_session).get_advertised_tlocs(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.advertised_tlocs_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_advertised_tlocs_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_advertised_tlocs(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    @patch("catalystwan.session.Session")
-    def test_received_tlocs(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.received_tlocs
-        # Act
-        answer = OmpAPI(mock_session).get_received_tlocs(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.received_tlocs_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_received_tlocs_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_received_tlocs(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    @patch("catalystwan.session.Session")
-    def test_services(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.services
-        # Act
-        answer = OmpAPI(mock_session).get_services(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.services_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_services_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_services(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    @patch("catalystwan.session.Session")
-    def test_omp_summary(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.omp_summary
-        # Act
-        answer = OmpAPI(mock_session).get_omp_summary(self.device_id)
-        # Assert
-        self.assertEqual(answer, self.omp_summary_dataclass)
-
-    @patch("catalystwan.session.Session")
-    def test_omp_summary_empty(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = []
-        # Act
-        answer = OmpAPI(mock_session).get_omp_summary(self.device_id)
-        # Assert
-        self.assertEqual(answer, [])
-
-    def setUp(self) -> None:
-        self.device_id = "1.1.1.1"
-        self.omp_peer = [
-            {
-                "domain-id": 1,
-                "vdevice-name": "169.254.10.10",
-                "refresh": "supported",
-                "site-id": 129,
-                "type": "vsmart",
-                "vdevice-host-name": "vm3",
-                "up-time-date": 1643135160000,
-                "vdevice-dataKey": "169.254.10.10-172.16.253.129-vsmart",
-                "peer": "172.16.253.129",
-                "up-time": "0:12:57:30",
-                "legit": "yes",
-                "lastupdated": 1643181828115,
-                "state": "up",
-            },
-            {
-                "domain-id": 1,
-                "vdevice-name": "169.254.10.10",
-                "refresh": "supported",
-                "site-id": 130,
-                "type": "vsmart",
-                "vdevice-host-name": "vm3",
-                "up-time-date": 1643135160000,
-                "vdevice-dataKey": "169.254.10.10-172.16.255.130-vsmart",
-                "peer": "172.16.255.130",
-                "up-time": "0:12:57:30",
-                "legit": "yes",
-                "lastupdated": 1643181828115,
-                "state": "up",
-            },
-        ]
-        self.omp_peer_dataclass = [create_dataclass(OmpPeerData, item) for item in self.omp_peer]
-        self.advertised_routes = [
-            {
-                "overlay-id": "1",
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "prefix": "100.100.3.0/24",
-                "ip": "172.16.254.2",
-                "label": "1069",
-                "encap": "ipsec",
-                "site-id": "3",
-                "originator": "172.16.254.2",
-                "vpn-id": "10",
-                "vdevice-host-name": "vm3",
-                "path-id": "65",
-                "protocol": "connected",
-                "vdevice-dataKey": "169.254.10.10-10",
-                "metric": "0",
-                "lastupdated": 1643179668956,
-                "to-peer": "172.16.253.129",
-            },
-            {
-                "overlay-id": "1",
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "prefix": "100.100.3.0/24",
-                "ip": "172.16.254.2",
-                "label": "1069",
-                "encap": "ipsec",
-                "site-id": "3",
-                "originator": "172.16.254.2",
-                "vpn-id": "10",
-                "vdevice-host-name": "vm3",
-                "path-id": "65",
-                "protocol": "connected",
-                "vdevice-dataKey": "169.254.10.10-10",
-                "metric": "0",
-                "lastupdated": 1643179668956,
-                "to-peer": "172.16.255.130",
-            },
-        ]
-        self.advertised_routes_dataclass = [
-            create_dataclass(OmpAdvertisedRouteData, item) for item in self.advertised_routes
-        ]
-        self.received_routes = [
-            {
-                "overlay-id": "1",
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "prefix": "10.0.5.0/24",
-                "ip": "172.16.254.4",
-                "from-peer": "172.16.253.129",
-                "label": "1047",
-                "encap": "ipsec",
-                "site-id": "5",
-                "originator": "172.16.254.4",
-                "vpn-id": "10",
-                "vdevice-host-name": "vm3",
-                "path-id": "42",
-                "protocol": "connected",
-                "vdevice-dataKey": "169.254.10.10-10",
-                "metric": "0",
-                "lastupdated": 1643182041519,
-                "attribute-type": "installed",
-                "status": "C I R",
-            },
-            {
-                "overlay-id": "1",
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "prefix": "100.100.3.0/24",
-                "ip": "172.16.254.2",
-                "from-peer": "0.0.0.0",
-                "label": "1069",
-                "encap": "ipsec",
-                "site-id": "3",
-                "originator": "172.16.254.2",
-                "vpn-id": "10",
-                "vdevice-host-name": "vm3",
-                "path-id": "65",
-                "protocol": "connected",
-                "vdevice-dataKey": "169.254.10.10-10",
-                "metric": "0",
-                "lastupdated": 1643182041520,
-                "attribute-type": "installed",
-                "status": "C Red R",
-            },
-        ]
-        self.received_routes_dataclass = [create_dataclass(OmpReceivedRouteData, item) for item in self.received_routes]
-        self.advertised_tlocs = [
-            {
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "ip": "172.16.254.2",
-                "tloc-auth-type": "sha1-hmac ah-sha1-hmac",
-                "preference": "0",
-                "weight": "1",
-                "encap": "ipsec",
-                "site-id": "3",
-                "originator": "172.16.254.2",
-                "vdevice-host-name": "vm3",
-                "tloc-public-ip": "10.101.3.3",
-                "tloc-public-port": "12406",
-                "tloc-private-ip": "10.101.3.3",
-                "vdevice-dataKey": "169.254.10.10-ipv4-172.16.254.2",
-                "tloc-private-port": "12406",
-                "tloc-spi": "286",
-                "lastupdated": 1643179953349,
-                "tloc-encrypt-type": "aes256",
-                "tloc-proto": "0",
-                "address-family": "ipv4",
-                "to-peer": "172.16.253.129",
-            },
-            {
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "ip": "172.16.254.2",
-                "tloc-auth-type": "sha1-hmac ah-sha1-hmac",
-                "preference": "0",
-                "weight": "1",
-                "encap": "ipsec",
-                "site-id": "3",
-                "originator": "172.16.254.2",
-                "vdevice-host-name": "vm3",
-                "tloc-public-ip": "10.101.3.3",
-                "tloc-public-port": "12406",
-                "tloc-private-ip": "10.101.3.3",
-                "vdevice-dataKey": "169.254.10.10-ipv4-172.16.254.2",
-                "tloc-private-port": "12406",
-                "tloc-spi": "286",
-                "lastupdated": 1643179953351,
-                "tloc-encrypt-type": "aes256",
-                "tloc-proto": "0",
-                "address-family": "ipv4",
-                "to-peer": "172.16.255.130",
-            },
-        ]
-        self.advertised_tlocs_dataclass = [
-            create_dataclass(OmpAdvertisedTlocData, item) for item in self.advertised_tlocs
-        ]
-        self.received_tlocs = [
-            {
-                "bfd-status": "up",
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "ip": "172.16.254.1",
-                "tloc-auth-type": "sha1-hmac ah-sha1-hmac",
-                "preference": "0",
-                "from-peer": "172.16.253.129",
-                "weight": "1",
-                "encap": "ipsec",
-                "site-id": "2",
-                "originator": "172.16.254.1",
-                "vdevice-host-name": "vm3",
-                "tloc-public-ip": "10.101.2.2",
-                "tloc-public-port": "12386",
-                "tloc-private-ip": "10.101.2.2",
-                "vdevice-dataKey": "169.254.10.10-ipv4-172.16.254.1",
-                "tloc-private-port": "12386",
-                "tloc-spi": "263",
-                "lastupdated": 1643185163270,
-                "tloc-encrypt-type": "aes256",
-                "tloc-proto": "0",
-                "address-family": "ipv4",
-            },
-            {
-                "bfd-status": "up",
-                "color": "default",
-                "vdevice-name": "169.254.10.10",
-                "ip": "172.16.254.4",
-                "tloc-auth-type": "sha1-hmac ah-sha1-hmac",
-                "preference": "0",
-                "from-peer": "172.16.255.130",
-                "weight": "1",
-                "encap": "ipsec",
-                "site-id": "5",
-                "originator": "172.16.254.4",
-                "vdevice-host-name": "vm3",
-                "tloc-public-ip": "10.102.5.5",
-                "tloc-public-port": "12406",
-                "tloc-private-ip": "10.102.5.5",
-                "vdevice-dataKey": "169.254.10.10-ipv4-172.16.254.4",
-                "tloc-private-port": "12406",
-                "tloc-spi": "288",
-                "lastupdated": 1643185163286,
-                "tloc-encrypt-type": "aes256",
-                "tloc-proto": "0",
-                "address-family": "ipv4",
-            },
-        ]
-        self.received_tlocs_dataclass = [create_dataclass(OmpReceivedTlocData, item) for item in self.received_tlocs]
-        self.services = [
-            {
-                "path-id": "65",
-                "vdevice-dataKey": "169.254.10.10-10-VPN-172.16.254.2",
-                "vdevice-name": "169.254.10.10",
-                "service": "VPN",
-                "from-peer": "0.0.0.0",
-                "lastupdated": 1643250832867,
-                "originator": "172.16.254.2",
-                "label": "1077",
-                "vpn-id": "10",
-                "vdevice-host-name": "vm3",
-                "address-family": "ipv4",
-                "status": "C Red R",
-            },
-            {
-                "vdevice-dataKey": "169.254.10.10-10-VPN-172.16.254.2",
-                "vdevice-name": "169.254.10.10",
-                "service": "VPN",
-                "lastupdated": 1643250832869,
-                "originator": "172.16.254.2",
-                "vpn-id": "10",
-                "vdevice-host-name": "vm3",
-                "address-family": "ipv4",
-                "to-peer": "172.16.255.130",
-            },
-        ]
-        self.services_dataclass = [create_dataclass(OmpServiceData, item) for item in self.services]
-        self.omp_summary = [
-            {
-                "tlocs-sent": 4,
-                "policy-sent": 0,
-                "mcast-routes-sent": 0,
-                "packets-sent": 81579,
-                "vdevice-name": "169.254.10.10",
-                "inform-sent": 14,
-                "packets-received": 81956,
-                "routes-received": 18,
-                "tlocs-received": 22,
-                "mcast-routes-installed": 0,
-                "update-sent": 84,
-                "devicetype": "vedge",
-                "mcast-routes-received": 0,
-                "hello-received": 81472,
-                "alert-sent": 0,
-                "update-received": 468,
-                "vsmart-peers": 2,
-                "operstate": "UP",
-                "policy-received": 0,
-                "handshake-received": 2,
-                "handshake-sent": 2,
-                "alert-received": 0,
-                "services-sent": 4,
-                "vdevice-host-name": "vm3",
-                "inform-received": 14,
-                "vdevice-dataKey": "169.254.10.10--",
-                "tlocs-installed": 10,
-                "services-installed": 0,
-                "ompuptime": "9:11:16:34",
-                "services-received": 2,
-                "lastupdated": 1645494228477,
-                "routes-sent": 4,
-                "hello-sent": 81479,
-                "routes-installed": 8,
-                "adminstate": "UP",
-            }
-        ]
-        self.omp_summary_dataclass = [create_dataclass(OmpSummaryData, item) for item in self.omp_summary]

catalystwan/tests/test_packet_capture.py

@@ -1,125 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import patch
-
-from catalystwan.api.basic_api import DeviceStateAPI
-from catalystwan.api.packet_capture_api import PacketCaptureAPI
-from catalystwan.dataclasses import Device, PacketSetup, Status
-
-
-class TestPacketCaptureApi(unittest.TestCase):
-    def setUp(self):
-        self.status = Status("COMPLETED", 1)
-        self.status_response = {"fileDownloadStatus": "COMPLETED", "fileSize": 1}
-        self.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",
-        )
-        self.packet_setup = PacketSetup("id", True)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_status(self, mock_session):
-        # Arrange
-        mock_session.get_json.return_value = self.status_response
-        # Act
-        answer = PacketCaptureAPI(mock_session).get_status(self.packet_setup)
-        # Assert
-        self.assertEqual(answer, self.status)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_download_capture_session(self, mock_session):
-        # Act
-        answer = PacketCaptureAPI(mock_session).download_capture_session(self.packet_setup, self.device)
-        # Assert
-        self.assertEqual(answer, True)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_interface_name(self, mock_session):
-        # Arrange
-        interface_response = {"data": [{"ifname": "GE01"}]}
-        mock_session.get_json.return_value = interface_response
-        # Act
-        answer = PacketCaptureAPI(mock_session).get_interface_name(self.device)
-        # Assert
-        self.assertEqual(answer, "GE01")
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_start_stop(self, mock_session):
-        # Arrange
-        mock_session.get_json.return_value = None
-        packet_capture = PacketCaptureAPI(mock_session)
-        packet_capture.packet_channel = self.packet_setup
-        # Act
-        with packet_capture.start_stop(self.device) as answer:
-            pass
-        # Assert
-        self.assertEqual(answer, None)
-
-    @patch("catalystwan.api.packet_capture_api.time.sleep")
-    @patch.object(PacketCaptureAPI, "download_capture_session")
-    @patch.object(PacketCaptureAPI, "get_status")
-    @patch("catalystwan.session.ManagerSession")
-    def test_channel(self, mock_session, mock_get_status, mock_download, mock_sleep):
-        # Arrange
-        device_capture_response = {"sessionId": "id", "isNewSession": True}
-        mock_session.post.return_value.json.return_value = device_capture_response
-        mock_get_status.return_value = self.status
-        # Act
-        with PacketCaptureAPI(mock_session).channel(self.device) as answer:
-            pass
-        # Assert
-        self.assertEqual(answer, self.packet_setup)
-
-    @patch("catalystwan.api.packet_capture_api.time.sleep")
-    @patch("catalystwan.session.ManagerSession")
-    def test_channel_raise_error(self, mock_session, mock_sleep):
-        # Arrange
-        device_capture_response = {"sessionId": "id", "isNewSession": False}
-        mock_session.post.return_value.json.return_value = device_capture_response
-        # Act
-        with self.assertRaises(PermissionError) as error:
-            with PacketCaptureAPI(mock_session).channel(self.device):
-                pass
-        # Assert
-        self.assertEqual(error.expected, PermissionError)
-
-    @patch.object(PacketCaptureAPI, "start_stop")
-    @patch.object(PacketCaptureAPI, "channel")
-    @patch.object(DeviceStateAPI, "enable_data_stream")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_packets(self, mock_session, mock_enable, mock_channel, mock_start_stop):
-        # Arrange
-        mock_enable.return_value.__enter__.return_value = None
-        mock_channel.return_value.__enter__.return_value = None
-        mock_start_stop.return_value.__enter__.return_value = None
-        packet_capture = PacketCaptureAPI(mock_session)
-        packet_capture.status = self.status
-        # Act
-        answer = packet_capture.get_packets(self.device, duration_seconds=1)
-        # Assert
-        self.assertEqual(answer, self.status)
-
-    @patch.object(PacketCaptureAPI, "start_stop")
-    @patch.object(PacketCaptureAPI, "channel")
-    @patch.object(DeviceStateAPI, "enable_data_stream")
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_packets_handle_permission_error(self, mock_session, mock_enable, mock_channel, mock_start_stop):
-        # Arrange
-        mock_enable.return_value.__enter__.return_value = None
-        mock_channel.return_value.__enter__.side_effect = PermissionError()
-        mock_start_stop.return_value.__enter__.return_value = None
-        packet_capture = PacketCaptureAPI(mock_session)
-        failed_status = Status("IMPOSSIBLE", None)
-        # Act
-        answer = packet_capture.get_packets(self.device, duration_seconds=1)
-        # Assert
-        self.assertEqual(answer, failed_status)

catalystwan/tests/test_partition_manager_api.py

@@ -1,121 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import MagicMock, Mock, patch
-
-from catalystwan.api.partition_manager_api import PartitionManagerAPI
-from catalystwan.api.versions_utils import DeviceSoftwareRepository, DeviceVersions, RepositoryAPI
-from catalystwan.endpoints.configuration_device_actions import ActionId, RemovePartitionDevice
-from catalystwan.endpoints.configuration_device_inventory import DeviceDetailsResponse
-from catalystwan.typed_list import DataSequence
-
-
-class TestPartitionManagerAPI(unittest.TestCase):
-    def setUp(self):
-        self.device = DataSequence(
-            DeviceDetailsResponse,
-            [
-                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",
-            ),
-        }
-
-        self.mock_devices = [{"deviceId": "mock_uuid", "deviceIP": "mock_ip", "version": "ver1"}]
-        self.mock_device_version_payload = DataSequence(
-            RemovePartitionDevice, [RemovePartitionDevice(device_id="mock_uuid", device_ip="mock_ip", version="ver1")]
-        )
-        mock_session = Mock()
-        self.mock_repository_object = RepositoryAPI(mock_session)
-        self.mock_device_versions = DeviceVersions(self.mock_repository_object)
-        self.mock_partition_manager_obj = PartitionManagerAPI(mock_session)
-
-    @patch("catalystwan.utils.upgrades_helper.get_install_specification")
-    @patch.object(DeviceVersions, "get_devices_available_versions")
-    def test_remove_partition_if_force_true(self, mock_get_device_list, mock_get_spec):
-        # Prepare mock data
-        mock_get_device_list.return_value = Mock()
-        mock_devices = Mock()
-        mock_devices.return_value = self.mock_devices
-        mock_get_device_list.return_value = self.mock_device_version_payload
-        self.mock_repository_object.devices = self.mock_devices
-        expected_id = ActionId(id="mock_action_id")
-        self.mock_repository_object.session.endpoints.configuration_device_actions.process_remove_partition = MagicMock(
-            return_value=expected_id
-        )
-
-        # Assert
-        answer = self.mock_partition_manager_obj.remove_partition(self.device, force=True).task_id
-        self.assertEqual(answer, "mock_action_id")
-
-    @patch.object(PartitionManagerAPI, "_check_remove_partition_possibility")
-    @patch.object(DeviceVersions, "get_devices_available_versions")
-    def test_remove_partition_not_raise_error_force_false(self, mock_get_device_list, mock_check_remove):
-        # Prepare mock data
-        mock_get_device_list.return_value = self.mock_device_version_payload
-        mock_check_remove.return_value = []
-        self.mock_repository_object.devices = self.mock_devices
-        expected_id = ActionId(id="mock_action_id")
-        self.mock_repository_object.session.endpoints.configuration_device_actions.process_remove_partition = MagicMock(
-            return_value=expected_id
-        )
-
-        # Assert
-        answer = self.mock_partition_manager_obj.remove_partition(self.device, force=False).task_id
-        self.assertEqual(answer, "mock_action_id", "action ids not equal")
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_check_remove_partition_possibility_if_version_incorrect(self, mock_get_devices_versions_repository):
-        # Prepare mock data
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        mock_devices = [
-            RemovePartitionDevice(**{"deviceId": "mock_uuid", "deviceIP": "mock_ip", "version": "curr_ver"})
-        ]
-
-        # Assert
-        with self.assertRaises(ValueError):
-            self.mock_partition_manager_obj._check_remove_partition_possibility(mock_devices)
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_check_remove_partition_possibility_if_version_correct(self, mock_get_devices_versions_repository):
-        # Prepare mock data
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        mock_devices = [RemovePartitionDevice(**{"deviceId": "mock_uuid", "deviceIP": "mock_ip", "version": "any_ver"})]
-
-        # Assert
-        answer = self.mock_partition_manager_obj._check_remove_partition_possibility(mock_devices)
-        self.assertEqual(answer, None, "lists are not equal")
-
-    @patch.object(DeviceVersions, "get_devices_current_version")
-    @patch("catalystwan.session.ManagerSession")
-    def test_set_default_partition(self, mock_session, mock_get_devices):
-        # Arrange
-        mock_partition_manager = PartitionManagerAPI(mock_session)
-        expected_id = ActionId(id="id_1")
-        mock_partition_manager.session.endpoints.configuration_device_actions.process_mark_default_partition = (
-            MagicMock(return_value=expected_id)
-        )
-
-        # Act
-        answer = mock_partition_manager.set_default_partition(self.device).task_id
-
-        # Assert
-        self.assertEqual(answer, "id_1")