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

catalystwan/tests/test_response.py

@@ -1,183 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from typing import Any, List, Optional
-from unittest.mock import patch
-
-from attr import define, field  # type: ignore
-from parameterized import parameterized  # type: ignore
-from pydantic import BaseModel, Field, ValidationError
-from requests.exceptions import JSONDecodeError
-
-from catalystwan.dataclasses import DataclassBase
-from catalystwan.response import ManagerErrorInfo, ManagerResponse
-from catalystwan.typed_list import DataSequence
-
-
-@define
-class ParsedDataTypeAttrs(DataclassBase):
-    key1: str
-    key2: int
-    key3: Optional[float] = field(default=None)
-
-
-class ParsedDataTypePydanticV2(BaseModel):
-    key1: str
-    key2: int
-    key3: Optional[float] = Field(default=None)
-
-
-class DataForValidateTest(BaseModel):
-    important: str
-    not_important: ParsedDataTypePydanticV2
-
-
-PARSE_DATASEQ_TEST_DATA: List = [
-    (True, None, 0, "data"),
-    (True, "string", 0, "data"),
-    (True, {}, 0, "data"),
-    (True, {"key1": "string", "key2": 12, "key3": 4.5}, 0, "data"),
-    (True, 15, 0, "data"),
-    (True, {"data": None}, 0, "data"),
-    (True, {"data": {}}, 0, "data"),
-    (False, {"data": []}, 0, "data"),
-    (True, {"data": "something"}, 0, "data"),
-    (False, {"data": {"key1": "string", "key2": 12, "key3": None}}, 1, "data"),
-    (True, {"data": {"key1": "string", "key2": 12, "key3": None}}, 1, "other"),
-    (False, {"other": {"key1": "string", "key2": 12, "key3": None}}, 1, "other"),
-    (False, {"data": [{"key1": "string", "key2": 66}, {"key1": "required", "key2": 18, "key3": 0.1}]}, 2, "data"),
-    (True, {"headers": {"key1": 1, "key2": "two"}}, 0, "data"),
-    (True, {"error": {"message": "Error happened!", "details": "error details", "code": "ABC123"}}, 0, "data"),
-]
-
-
-PARSE_DATAOBJ_TEST_DATA: List = [
-    (True, None, "data"),
-    (True, "string", "data"),
-    (True, {}, "data"),
-    (True, {"data": "something"}, "data"),
-    (False, {"data": {"key1": "string", "key2": 12, "key3": None}}, "data"),
-    (True, {"data": {"key1": "string", "key2": 12, "key3": None}}, "other"),
-    (False, {"other": {"key1": "string", "key2": 12, "key3": 55.13}}, "other"),
-    (True, {"data": [{"key1": "string", "key2": 66}, {"key1": "required", "key2": 18, "key3": 0.1}]}, "data"),
-]
-
-VALIDATE_DATASEQ_TEST_DATA = [
-    {"important": "correct1", "not_important": {"invalid-key1": "string", "key2": "not int"}},
-    {"important": "correct2", "not_important": {}},
-]
-
-
-class TestResponse(unittest.TestCase):
-    @patch("requests.Response")
-    def setUp(self, response_mock) -> None:
-        self.response_mock = response_mock
-        self.response_mock.headers = {"set-cookie": ""}
-        self.response_mock.cookies = {}
-        self.response_mock.status_code = 200
-
-    @parameterized.expand(PARSE_DATASEQ_TEST_DATA)
-    def test_dataseq_attrs(self, raises: bool, json: Any, expected_len: int, sourcekey: str):
-        self.response_mock.json.return_value = json
-        vmng_response = ManagerResponse(self.response_mock)
-        if not raises:
-            data_sequence = vmng_response.dataseq(ParsedDataTypeAttrs, sourcekey)
-            assert isinstance(data_sequence, DataSequence)
-            assert len(data_sequence) == expected_len
-        else:
-            with self.assertRaises(Exception):
-                vmng_response.dataseq(ParsedDataTypeAttrs, sourcekey)
-
-    @parameterized.expand(PARSE_DATASEQ_TEST_DATA)
-    def test_dataseq_pydantic(self, raises: bool, json: Any, expected_len: int, sourcekey: str):
-        self.response_mock.json.return_value = json
-        vmng_response = ManagerResponse(self.response_mock)
-        if not raises:
-            data_sequence = vmng_response.dataseq(ParsedDataTypePydanticV2, sourcekey)
-            assert isinstance(data_sequence, DataSequence)
-            assert len(data_sequence) == expected_len
-        else:
-            with self.assertRaises(Exception):
-                vmng_response.dataseq(ParsedDataTypePydanticV2, sourcekey)
-
-    @parameterized.expand(PARSE_DATAOBJ_TEST_DATA)
-    def test_dataobj_attrs(self, raises: bool, json: Any, sourcekey: str):
-        self.response_mock.json.return_value = json
-        vmng_response = ManagerResponse(self.response_mock)
-        if not raises:
-            data_object = vmng_response.dataobj(ParsedDataTypeAttrs, sourcekey)
-            assert isinstance(data_object, ParsedDataTypeAttrs)
-        else:
-            with self.assertRaises(Exception):
-                vmng_response.dataobj(ParsedDataTypeAttrs, sourcekey)
-
-    @parameterized.expand(PARSE_DATAOBJ_TEST_DATA)
-    def test_dataobj_pydantic(self, raises: bool, json: Any, sourcekey: str):
-        self.response_mock.json.return_value = json
-        vmng_response = ManagerResponse(self.response_mock)
-        if not raises:
-            data_object = vmng_response.dataobj(ParsedDataTypePydanticV2, sourcekey)
-            assert isinstance(data_object, ParsedDataTypePydanticV2)
-        else:
-            with self.assertRaises(Exception):
-                vmng_response.dataobj(ParsedDataTypePydanticV2, sourcekey)
-
-    @parameterized.expand(
-        [
-            (True, "string"),
-            (True, {}),
-            (True, {"key1": "string", "key2": 12, "key3": 4.5}),
-            (True, 15),
-            (True, {"data": None}),
-            (True, {"data": {}}),
-            (True, {"data": []}),
-            (True, {"data": "something"}),
-            (True, {"data": {"key1": "string", "key2": 12, "key3": -0.7}}),
-            (True, {"data": [{"key1": "string", "key2": 66}, {"key1": "required", "key2": 18, "key3": 0.1}]}),
-            (True, {"headers": {"key1": 1, "key2": "two"}}),
-            (False, {"error": {"message": "Error happened!", "details": "error details", "code": "ABC123"}}),
-        ]
-    )
-    def test_get_error(self, empty_error: bool, json: Any):
-        self.response_mock.json.return_value = json
-        vmng_response = ManagerResponse(self.response_mock)
-        error_info = vmng_response.get_error_info()
-        assert isinstance(error_info, ManagerErrorInfo)
-        if empty_error:
-            assert error_info.message is None
-            assert error_info.details is None
-            assert error_info.code is None
-
-    def test_dataobj_optional_validate(self):
-        # Arrange
-        self.response_mock.json.return_value = VALIDATE_DATASEQ_TEST_DATA[0]
-        vmng_response = ManagerResponse(self.response_mock)
-        # Act
-        data = vmng_response.dataobj(DataForValidateTest, sourcekey=None, validate=False)
-        # Assert
-        assert isinstance(data, DataForValidateTest)
-        assert data.important == VALIDATE_DATASEQ_TEST_DATA[0]["important"]
-        with self.assertRaises(ValidationError):
-            vmng_response.dataobj(DataForValidateTest, sourcekey=None, validate=True)
-
-    def test_dataseq_optional_validate(self):
-        self.response_mock.json.return_value = VALIDATE_DATASEQ_TEST_DATA
-        vmng_response = ManagerResponse(self.response_mock)
-        # Act
-        dataseq = vmng_response.dataseq(DataForValidateTest, sourcekey=None, validate=False)
-        # Assert
-        assert isinstance(dataseq, DataSequence)
-        for i, data in enumerate(dataseq):
-            assert isinstance(data, DataForValidateTest)
-            assert data.important == VALIDATE_DATASEQ_TEST_DATA[i]["important"]
-        with self.assertRaises(ValidationError):
-            vmng_response.dataseq(DataForValidateTest, sourcekey=None, validate=True)
-
-    def test_dataseq_with_misisng_data(self):
-        self.response_mock.json.side_effect = JSONDecodeError("test", "test", 1)
-        vmng_response = ManagerResponse(self.response_mock)
-        # Act
-        dataseq = vmng_response.dataseq(DataForValidateTest, sourcekey="data", validate=True)
-        # Assert
-        assert isinstance(dataseq, DataSequence)
-        assert len(dataseq) == 0

catalystwan/tests/test_session.py

@@ -1,102 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from typing import Optional
-from unittest.mock import patch
-
-from parameterized import parameterized  # type: ignore
-from requests import HTTPError, Request, RequestException, Response
-
-from catalystwan.exceptions import CatalystwanException, ManagerHTTPError, ManagerRequestException
-from catalystwan.session import ManagerSession, create_base_url
-from catalystwan.vmanage_auth import vManageAuth
-
-
-class TestSession(unittest.TestCase):
-    def setUp(self):
-        self.url = "https://example.com:80"
-        self.username = "admin"
-        self.password = "admin"  # pragma: allowlist secret
-
-    def test_session_str(self):
-        # Arrange, Act
-        session = ManagerSession(self.url, auth=vManageAuth(self.username, self.password))
-
-        # Assert
-        self.assertEqual(
-            str(session),
-            "ManagerSession(session_type=SessionType.NOT_DEFINED, " "auth=vManageAuth(username=admin))",
-        )
-
-    @parameterized.expand(
-        [
-            (None, "http://example.com:666", "http://example.com:666"),
-            (None, "www.example.com", "https://www.example.com"),
-            (123, "example.com", "https://example.com:123"),
-            (123, "http://example.com", "http://example.com:123"),
-            (123, "https://example.com", "https://example.com:123"),
-            (None, "https://example.com", "https://example.com"),
-        ]
-    )
-    def test_base_url(self, port: Optional[int], user_url: str, expected_url: str):
-        # Arrange, Act
-        base_url = create_base_url(user_url, port=port)
-        # Assert
-        self.assertEqual(base_url, expected_url)
-
-    @parameterized.expand(
-        [
-            (123, "/devices", "https://example.com:123/devices"),
-            (123, "devices", "https://example.com:123/devices"),
-            (None, "/devices", "https://example.com/devices"),
-            (None, "devices", "https://example.com/devices"),
-        ]
-    )
-    def test_get_full_url(self, port: Optional[int], url: str, expected_url: str):
-        # Arrange, Act
-        base_url = create_base_url("https://example.com", port=port)
-        session = ManagerSession(base_url=base_url, auth=vManageAuth(base_url, self.username, self.password))
-
-        # Assert
-        self.assertEqual(session.get_full_url(url), expected_url)
-
-
-class TestSessionExceptions(unittest.TestCase):
-    def setUp(self):
-        self.session = ManagerSession(
-            base_url="https://domain.com:9443",
-            auth=vManageAuth(username="admin", password="admin"),
-        )
-        response = Response()
-        response.json = lambda: {
-            "error": {
-                "message": "Delete users request failed",
-                "details": "No user with name XYZ was found",
-                "code": "USER0006",
-            }
-        }
-        response.status_code = 500
-        response.request = Request(method="GET", url="/v1/data")
-        self.response = response
-
-    @parameterized.expand(
-        [
-            (RequestException(), [CatalystwanException, ManagerRequestException, RequestException]),
-            (HTTPError(), [CatalystwanException, ManagerHTTPError, ManagerRequestException, RequestException]),
-        ]
-    )
-    @patch("requests.sessions.Session.request")
-    def test_session_request_exceptions(self, lib_exception, sdk_exceptions, mock_request_base):
-        # Arrange
-        if isinstance(lib_exception, HTTPError):
-            mock_request_base.return_value = self.response
-        else:
-            mock_request_base.side_effect = lib_exception
-        for sdk_exception in sdk_exceptions:
-            # Act / Assert
-            with self.assertRaises(sdk_exception):
-                self.session.request(self.response.request.method, self.response.request.url)
-
-
-if __name__ == "__main__":
-    unittest.main()

catalystwan/tests/test_software_action_api.py

@@ -1,154 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import MagicMock, Mock, patch
-
-from catalystwan.api.software_action_api import SoftwareActionAPI
-from catalystwan.api.versions_utils import DeviceSoftwareRepository, DeviceVersions, RepositoryAPI
-from catalystwan.endpoints.configuration.software_actions import SoftwareImageDetails
-from catalystwan.endpoints.configuration_device_actions import ActionId, InstallDevice, PartitionDevice
-from catalystwan.endpoints.configuration_device_inventory import DeviceDetailsResponse
-from catalystwan.exceptions import ImageNotInRepositoryError
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.upgrades_helper import Family, InstallSpecHelper
-
-
-class TestSoftwareAcionAPI(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="20.8",
-                defaultVersion="def_ver",
-                uuid="mock_uuid",
-            ),
-        }
-
-        self.mock_devices = [{"deviceId": "mock_uuid", "deviceIP": "mock_ip", "version": "ver1"}]
-        self.install_spec = InstallSpecHelper.VMANAGE.value
-
-        mock_session = Mock()
-        self.mock_repository_object = RepositoryAPI(mock_session)
-        self.mock_device_versions = DeviceVersions(self.mock_repository_object)
-        self.mock_software_action_obj = SoftwareActionAPI(mock_session)
-
-    @patch.object(SoftwareActionAPI, "_downgrade_check")
-    @patch.object(RepositoryAPI, "get_image_version")
-    def test_upgrade_software_if_downgrade_check_is_none(self, mock_get_image_version, mock_downgrade_check):
-        # Prepare mock data
-        mock_downgrade_check.return_value = False
-        expected_id = ActionId(id="mock_action_id")
-        mock_get_image_version.return_value = "any_version"
-        self.mock_software_action_obj.session.endpoints.configuration_device_actions.process_install_operation = (
-            MagicMock(return_value=expected_id)
-        )
-
-        # Assert
-        answer = self.mock_software_action_obj.install(
-            devices=DataSequence(DeviceDetailsResponse, [self.device]),
-            reboot=True,
-            sync=True,
-            image="path",
-        )
-        self.assertEqual(answer.task_id, "mock_action_id")
-
-    @patch.object(DeviceVersions, "get_device_available")
-    @patch.object(RepositoryAPI, "get_all_software_images")
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_activate_software(
-        self, mock_get_devices_versions_repository, mock_get_all_software_images, mock_get_device_available
-    ):
-        # Prepare mock data
-        expected_id = ActionId(id="mock_action_id")
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        mock_get_device_available.return_value = DataSequence(
-            PartitionDevice, [PartitionDevice(device_id="mock_uuid", device_ip="mock_ip", version="ver2")]
-        )
-        mock_get_all_software_images.return_value = DataSequence(
-            SoftwareImageDetails,
-            [SoftwareImageDetails(**{"availableFiles": "vmanage-20.9.1-x86_64.tar.gz", "versionName": "ver2"})],
-        )
-
-        self.mock_software_action_obj.session.endpoints.configuration_device_actions.process_mark_change_partition = (
-            MagicMock(return_value=expected_id)
-        )
-
-        # Assert
-        answer = self.mock_software_action_obj.activate(
-            devices=DataSequence(DeviceDetailsResponse, [self.device]),
-            image="vmanage-20.9.1-x86_64.tar.gz",
-        )
-        self.assertEqual(answer.task_id, "mock_action_id")
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_downgrade_check_no_incorrect_devices(self, mock_get_devices_versions_repository):
-        # Preapre mock data
-        upgrade_version = "20.9"
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        mock_devices = [InstallDevice(**{"deviceId": "mock_uuid", "deviceIP": "mock_ip", "version": upgrade_version})]
-        self.mock_repository_object.devices = mock_devices
-        # Assert
-        answer = self.mock_software_action_obj._downgrade_check(mock_devices, upgrade_version, Family.VMANAGE.value)
-        self.assertEqual(answer, None, "downgrade detected, but should not")
-
-    @patch.object(RepositoryAPI, "get_devices_versions_repository")
-    def test_downgrade_check_incorrect_devices_exists(self, mock_get_devices_versions_repository):
-        # Preapre mock data
-        upgrade_version = "20.6"
-        mock_get_devices_versions_repository.return_value = self.DeviceSoftwareRepository_obj
-        mock_devices = [InstallDevice(**{"deviceId": "mock_uuid", "deviceIP": "mock_ip", "version": upgrade_version})]
-        self.mock_repository_object.devices = mock_devices
-        # Assert
-        # answer = self.mock_software_action_obj._downgrade_check(mock_devices, upgrade_version, Family.VMANAGE.value)
-        self.assertRaises(
-            ValueError,
-            self.mock_software_action_obj._downgrade_check,
-            mock_devices,
-            upgrade_version,
-            Family.VMANAGE.value,
-        )
-
-    def test_install_software_from_remote_image_not_available_with_downgrade_check(self):
-        with self.assertRaises(ValueError):
-            self.mock_software_action_obj.install(
-                devices=DataSequence(DeviceDetailsResponse, [self.device]),
-                remote_server_name="dummy",
-                remote_image_filename="dummy",
-            )
-
-    @patch.object(RepositoryAPI, "get_all_software_images")
-    def test_install_software_from_remote_image_with_wrong_version(self, mock_get_all_software_images):
-        mock_get_all_software_images.return_value = DataSequence(
-            SoftwareImageDetails,
-            [
-                SoftwareImageDetails(
-                    **{
-                        "availableFiles": "vmanage-20.9.1-x86_64.tar.gz",
-                        "versionType": "remote-server-test",
-                        "remoteServerId": "123456789-abcdabcd",
-                        "versionId": "ver1",
-                    }
-                )
-            ],
-        )
-
-        with self.assertRaises(ImageNotInRepositoryError):
-            self.mock_software_action_obj.install(
-                devices=DataSequence(DeviceDetailsResponse, [self.device]),
-                remote_server_name="remote-server-test",
-                remote_image_filename="not-ver1",
-                downgrade_check=False,
-            )

catalystwan/tests/test_speed_test_api.py

@@ -1,143 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-import unittest
-from unittest.mock import patch
-from urllib.error import HTTPError
-
-from catalystwan.api.basic_api import DeviceStateAPI
-from catalystwan.api.speedtest_api import SpeedtestAPI
-from catalystwan.dataclasses import Device, Speedtest
-
-
-class TestSpeedTestAPI(unittest.TestCase):
-    def setUp(self):
-        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.device_unreachable = Device(
-            personality="vedge",
-            uuid="mock_uuid",
-            id="mock_ip",
-            hostname="mock_host",
-            reachability="unreachable",
-            local_system_ip="mock_ip",
-            status="normal",
-            memUsage=1.0,
-            connected_vManages=["192.168.0.1"],
-            model="vedge-cloud",
-        )
-
-    @patch("catalystwan.api.speedtest_api.sleep")
-    @patch("catalystwan.session.ManagerSession")
-    def test_perform(self, mock_session, mock_sleep):
-        # Arrange
-        mock_session.post.return_value.json.return_value = {
-            "sessionId": "id",
-            "data": [{"up_speed": "up_speed", "down_speed": "down_speed"}],
-        }
-        mock_session.get_json.return_value = {"status": "status"}
-        speed_test_api = SpeedtestAPI(mock_session)
-        speed_test_api.speedtest_output = Speedtest("ip", "device_name", "ip", "device_name", None, None, None)
-        speed_test_api_compare = SpeedtestAPI(mock_session)
-        speed_test_api_compare.speedtest_output = Speedtest(
-            "ip", "device_name", "ip", "device_name", "status", "up_speed", "down_speed"
-        )
-        # Act
-        speed_test_api._SpeedtestAPI__perform(self.device, self.device, "blue", "red", 1)
-        # Assert
-        self.assertEqual(speed_test_api.speedtest_output, speed_test_api_compare.speedtest_output)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_perform_handle_error(self, mock_session):
-        # Arrange
-        mock_session.post.return_value.json.return_value = {"sessionId": "id", "data": []}
-        mock_session.get_json.return_value = {"status": "status"}
-        speed_test_api = SpeedtestAPI(mock_session)
-        speed_test_api.speedtest_output = Speedtest("ip", "device_name", "ip", "device_name", None, None, None)
-        speed_test_api_compare = SpeedtestAPI(mock_session)
-        speed_test_api_compare.speedtest_output = Speedtest(
-            "ip", "device_name", "ip", "device_name", "No speed received", None, None
-        )
-        # Act
-        speed_test_api._SpeedtestAPI__perform(self.device, self.device, "blue", "red", 1)
-        # Assert
-        self.assertEqual(speed_test_api.speedtest_output, speed_test_api_compare.speedtest_output)
-
-    @patch.object(SpeedtestAPI, "_SpeedtestAPI__perform")
-    @patch.object(DeviceStateAPI, "enable_data_stream")
-    @patch.object(DeviceStateAPI, "get_colors")
-    @patch("catalystwan.session.ManagerSession")
-    def test_speedtest(self, mock_session, mock_get_colors, mock_enable, mock_perform):
-        # Arrange
-        mock_enable.return_value.__enter__.return_value = None
-        speed_test_api = SpeedtestAPI(mock_session)
-        speed_test_api_compare = SpeedtestAPI(mock_session)
-        speed_test_api_compare.speedtest_output = Speedtest(
-            self.device.local_system_ip,
-            self.device.hostname,
-            self.device.local_system_ip,
-            self.device.hostname,
-            "",
-            0.0,
-            0.0,
-        )
-        # Act
-        answer = speed_test_api.speedtest(self.device, self.device, 1)
-        # Assert
-        self.assertEqual(answer, speed_test_api_compare.speedtest_output)
-
-    @patch.object(SpeedtestAPI, "_SpeedtestAPI__perform")
-    @patch.object(DeviceStateAPI, "enable_data_stream")
-    @patch.object(DeviceStateAPI, "get_colors")
-    @patch("catalystwan.session.ManagerSession")
-    def test_speedtest_not_reachable(self, mock_session, mock_get_colors, mock_enable, mock_perform):
-        # Arrange
-        mock_enable.return_value.__enter__.return_value = None
-        speed_test_api = SpeedtestAPI(mock_session)
-        speed_test_api_compare = SpeedtestAPI(mock_session)
-        speed_test_api_compare.speedtest_output = Speedtest(
-            self.device.local_system_ip,
-            self.device.hostname,
-            self.device.local_system_ip,
-            self.device.hostname,
-            "Source is unreachable and destination device is unreachable",
-            0.0,
-            0.0,
-        )
-        # Act
-        answer = speed_test_api.speedtest(self.device_unreachable, self.device_unreachable, 1)
-        # Assert
-        self.assertEqual(answer, speed_test_api_compare.speedtest_output)
-
-    @patch.object(SpeedtestAPI, "_SpeedtestAPI__perform")
-    @patch.object(DeviceStateAPI, "enable_data_stream")
-    @patch.object(DeviceStateAPI, "get_colors")
-    @patch("catalystwan.session.ManagerSession")
-    def test_speedtest_handle_error(self, mock_session, mock_get_colors, mock_enable, mock_perform):
-        # Arrange
-        mock_enable.return_value.__enter__.return_value = None
-        mock_perform.side_effect = HTTPError("url", 400, "error_400", "msg", 1)
-        speed_test_api = SpeedtestAPI(mock_session)
-        speed_test_api_compare = SpeedtestAPI(mock_session)
-        speed_test_api_compare.speedtest_output = Speedtest(
-            self.device.local_system_ip,
-            self.device.hostname,
-            self.device.local_system_ip,
-            self.device.hostname,
-            "HTTP Error 400: error_400",
-            0.0,
-            0.0,
-        )
-        # Act
-        answer = speed_test_api.speedtest(self.device, self.device, 1)
-        # Assert
-        self.assertEqual(answer, speed_test_api_compare.speedtest_output)