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

catalystwan/tests/test_admin_tech_api.py

@@ -1,198 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-import io
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import ANY, MagicMock, patch
-
-from catalystwan.api.admin_tech_api import (
-    AdminTechAPI,
-    DownloadAdminTechLogError,
-    GenerateAdminTechLogError,
-    RequestTokenIdNotFound,
-)
-from catalystwan.dataclasses import DeviceAdminTech
-
-
-class TestAdminTechAPI(unittest.TestCase):
-    def setUp(self):
-        self.maxDiff = None
-        self.device_ip = "169.254.10.4"
-        self.admin_tech_generate_response = {
-            "size": 1479740,
-            "fileName": "172.16.253.129-vm129-20221116-065219-admin-tech.tar.gz",
-        }
-        self.device_admin_tech_infos = {
-            "data": [
-                {
-                    "fileName": "172.16.255.200-vm200-20221116-060922-admin-tech.tar.gz",
-                    "creationTime": 1668578961380,
-                    "size": 31934859,
-                    "state": "done",
-                    "requestTokenId": "null",
-                }
-            ]
-        }
-        self.admin_tech_infos = {
-            "data": [
-                {
-                    "creationTime": 1668581537503,
-                    "size": self.admin_tech_generate_response["size"],
-                    "fileName": self.admin_tech_generate_response["fileName"],
-                    "state": "done",
-                    "tac_state": "notStarted",
-                    "deviceIP": self.device_ip,
-                    "local-system-ip": "172.16.253.129",
-                    "requestTokenId": "aace1605-ba9a-40fa-990b-c694a011a866",
-                },
-                {
-                    "creationTime": 1668578961380,
-                    "size": 31934859,
-                    "fileName": "172.16.255.200-vm200-20221116-060922-admin-tech.tar.gz",
-                    "state": "done",
-                    "tac_state": "notStarted",
-                    "deviceIP": "169.254.10.1",
-                    "local-system-ip": "172.16.255.200",
-                    "requestTokenId": "8b7f9a3a-e137-4af4-b2f9-b04808e1e2eb",
-                },
-            ]
-        }
-        self.admin_tech_info = self.admin_tech_infos["data"][0]
-        self.download_file_content = "Downloaded file content"
-        self.download_file = io.BytesIO(self.download_file_content.encode())
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_get(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.json.return_value = self.device_admin_tech_infos
-        # Act
-        admintechs = AdminTechAPI(mock_session).get(self.device_ip)
-        # Assert
-        mock_session.post.assert_called_once_with(
-            url="/dataservice/device/tools/admintechlist",
-            json={"deviceIP": self.device_ip},
-        )
-        self.assertIsInstance(admintechs[0], DeviceAdminTech)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_get_all(self, mock_session, mock_response):
-        # Arrange
-        mock_session.get.return_value = mock_response
-        mock_response.json.return_value = self.admin_tech_infos
-        # Act
-        admintechs = AdminTechAPI(mock_session).get_all()
-        # Assert
-        mock_session.get.assert_called_once_with("/dataservice/device/tools/admintechs")
-        self.assertEqual(len(admintechs), len(self.admin_tech_infos["data"]))
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_generate(self, mock_session, mock_response):
-        # Arrange
-        post_response = MagicMock()
-        mock_session.post.return_value = post_response
-        post_response.status_code = 200
-        post_response.json.return_value = self.admin_tech_generate_response
-        get_response = MagicMock()
-        mock_session.get.return_value = get_response
-        get_response.json.return_value = self.admin_tech_infos
-
-        # Act
-        filename = AdminTechAPI(mock_session).generate(
-            device_id=self.device_ip, polling_timeout=0.01, polling_interval=0.01
-        )
-
-        # Assert
-        mock_session.post.assert_called_once_with(url="/dataservice/device/tools/admintech", json=ANY, timeout=ANY)
-        mock_session.get.assert_called_once_with("/dataservice/device/tools/admintechs")
-        self.assertEqual(filename, self.admin_tech_generate_response["fileName"])
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_generate_in_progress_error_retry(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = 400
-        mock_response.json.return_value = {"error": {"details": "Admin tech creation already in progress"}}
-        interval = 0.01
-        count = 2
-        # Act/Assert
-        with self.assertRaises(GenerateAdminTechLogError):
-            AdminTechAPI(mock_session).generate(
-                device_id=self.device_ip,
-                polling_timeout=interval * count,
-                polling_interval=interval,
-            )
-        self.assertEqual(mock_session.post.call_count, count)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_generate_error(self, mock_session, mock_response):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = 500
-        mock_response.json.return_value = {"error": {"details": "Server Error"}}
-        interval = 0.01
-        count = 3
-        # Act/Assert
-        with self.assertRaises(GenerateAdminTechLogError):
-            AdminTechAPI(mock_session).generate(
-                device_id=self.device_ip,
-                polling_timeout=interval * count,
-                polling_interval=interval,
-            )
-        mock_session.post.assert_called_once()
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_delete(self, mock_session, mock_response):
-        # Arrange
-        filename = self.admin_tech_generate_response["fileName"]
-        token_id = self.admin_tech_info["requestTokenId"]
-        mock_session.get.return_value = mock_response
-        mock_response.json.return_value = self.admin_tech_infos
-        # Act
-        AdminTechAPI(mock_session).delete(filename)
-        # Assert
-        mock_session.delete.assert_called_once_with(f"/dataservice/device/tools/admintech/{token_id}")
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_delete_token_not_found(self, mock_session, mock_response):
-        # Arrange
-        mock_session.get.return_value = mock_response
-        mock_response.json.return_value = self.admin_tech_infos
-        # Act/Assert
-        with self.assertRaises(RequestTokenIdNotFound):
-            AdminTechAPI(mock_session).delete("fake-filename.tar.gz", timeout=0.01, interval=0.01)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_download(self, mock_session, mock_response):
-        # Arrange
-        filename = self.admin_tech_generate_response["fileName"]
-        mock_session.get_file.return_value = mock_response
-        mock_session.get.return_value = mock_response
-        mock_response.status_code = 200
-        mock_response.content = self.download_file_content
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Act
-            download_path = AdminTechAPI(mock_session).download(filename, Path(tmpdir))
-            # Assert
-            self.assertEqual(download_path, Path(tmpdir) / filename)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("catalystwan.response.ManagerResponse")
-    def test_download_error(self, mock_session, mock_response):
-        # Arrange
-        mock_session.get.return_value = mock_response
-        mock_response.status_code = 500
-        mock_response.json.return_value = {"error": {"details": "Server Error"}}
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Act/Assert
-            with self.assertRaises(DownloadAdminTechLogError):
-                AdminTechAPI(mock_session).download("fake-filename.tar.gz", Path(tmpdir))

catalystwan/tests/test_administration.py

@@ -1,470 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-# type: ignore
-import unittest
-from unittest.mock import MagicMock, patch
-
-from attr.exceptions import NotAnAttrsClassError
-from parameterized import parameterized  # type: ignore
-
-from catalystwan.api.administration import (
-    AdministrationSettingsAPI,
-    ClusterManagementAPI,
-    ResourceGroupsAPI,
-    UserGroupsAPI,
-    UsersAPI,
-)
-from catalystwan.dataclasses import (
-    Certificate,
-    CloudConnectorData,
-    CloudServicesSettings,
-    Connection,
-    Organization,
-    Password,
-    ServiceConfigurationData,
-    Vbond,
-)
-from catalystwan.endpoints.administration_user_and_group import (
-    ResourceGroup,
-    ResourceGroupSwitchRequest,
-    ResourceGroupUpdateRequest,
-    User,
-    UserAuthType,
-    UserGroup,
-    UserGroupTask,
-    UserResetRequest,
-    UserRole,
-    UserUpdateRequest,
-)
-from catalystwan.exceptions import CatalystwanException
-from catalystwan.utils.certificate_status import ValidityPeriod
-from catalystwan.utils.creation_tools import create_dataclass
-
-password_dataclass = Password(old_password="old_password_123", new_password="new_password_123")
-certificate_dataclass = Certificate("cert", "Name", "Surname", "name@sur.name", ValidityPeriod.ONE_YEAR, 10)
-vbond_dataclass = Vbond("1.1.1.1", 1234)
-organization_dataclass = Organization("My org name", 1)
-
-
-class TestUsersAPI(unittest.TestCase):
-    @patch("catalystwan.session.ManagerSession")
-    def setUp(self, session_mock):
-        self.session = session_mock
-        self.session.api_version = None
-        self.session.session_type = None
-        self.session.password = "<>"
-        self.api = UsersAPI(self.session)
-        self.api._endpoints = MagicMock()
-
-    def test_get(self):
-        # Arrange
-        expected_users = [
-            User(
-                username="new_user",
-                password="new_user",  # pragma: allowlist secret
-                group=["netadmin"],
-                description="new user",
-            )
-        ]
-        self.api._endpoints.find_users = MagicMock(return_value=expected_users)
-        # Act
-        observed_users = self.api.get()
-        self.api._endpoints.find_users.assert_called_once()
-        assert expected_users == observed_users
-
-    def test_get_role(self):
-        # Arrange
-        expected_user_role = UserRole(isAdmin=True)
-        self.api._endpoints.find_user_role = MagicMock(return_value=expected_user_role)
-        # Act
-        observed_user_role = self.api.get_role()
-        # Assert
-        self.api._endpoints.find_user_role.assert_called_once()
-        assert expected_user_role == observed_user_role
-
-    def test_get_auth_type(self):
-        # Arrange
-        expected_auth_type = "local"
-        self.api._endpoints.find_user_auth_type = MagicMock(
-            return_value=UserAuthType(user_auth_type=expected_auth_type)
-        )
-        # Act
-        observed_auth_type = self.api.get_auth_type()
-        # Assert
-        self.api._endpoints.find_user_auth_type.assert_called_once()
-        assert expected_auth_type == observed_auth_type
-
-    def test_create(self):
-        # Arrange
-        user = User(username="new_user", password="new_user", group=["netadmin"], description="new user")
-        self.api._endpoints.create_user = MagicMock()
-        # Act
-        self.api.create(user)
-        # Assert
-        self.api._endpoints.create_user.assert_called_once_with(user)
-
-    def test_update(self):
-        # Arrange
-        user_update = UserUpdateRequest(
-            username="new_user",
-            password="new_user",  # pragma: allowlist secret
-            group=["netadmin"],
-            description="new user",
-            resource_group="global",
-        )
-        self.api._endpoints.update_user = MagicMock()
-        # Act
-        self.api.update(user_update)
-        # Assert
-        self.api._endpoints.update_user.assert_called_once_with(user_update.username, user_update)
-
-    def test_update_password(self):
-        # Arrange
-        username = "new_user"
-        new_password = "PaSsWoRd"  # pragma: allowlist secret
-        current_password = "32313123213"  # pragma: allowlist secret
-        self.api._endpoints.update_password = MagicMock()
-        # Act
-        self.api.update_password(username, new_password, current_password)
-        # Assert
-        self.api._endpoints.update_password.assert_called_once_with(
-            username,
-            UserUpdateRequest(username=username, password=new_password, current_user_password=current_password),
-        )
-
-    def test_reset(self):
-        # Arrange
-        username = "new_user"
-        user_reset_request = UserResetRequest(username=username)
-        self.api._endpoints.reset_user = MagicMock()
-        # Act
-        self.api.reset(username)
-        # Assert
-        self.api._endpoints.reset_user.assert_called_once_with(user_reset_request)
-
-    def test_delete(self):
-        # Arrange
-        username = "new_user"
-        self.api._endpoints.delete_user = MagicMock()
-        # Act
-        self.api.delete(username)
-        # Assert
-        self.api._endpoints.delete_user.assert_called_once_with(username)
-
-
-class TestUserGroupsAPI(unittest.TestCase):
-    @patch("catalystwan.session.ManagerSession")
-    def setUp(self, session_mock):
-        self.session = session_mock
-        self.session.api_version = None
-        self.session.session_type = None
-        self.session.password = "<>"
-        self.api = UserGroupsAPI(self.session)
-        self.api._endpoints = MagicMock()
-
-    def test_get(self):
-        # Arrange
-        expected_user_groups = [
-            UserGroup(
-                groupName="new_group", tasks=[UserGroupTask(enabled=True, feature="Alarms", read=True, write=False)]
-            )
-        ]
-        self.api._endpoints.find_user_groups = MagicMock(return_value=expected_user_groups)
-        # Act
-        observed_user_groups = self.api.get()
-        # Assert
-        self.api._endpoints.find_user_groups.assert_called_once()
-        assert expected_user_groups == observed_user_groups
-
-    def test_create(self):
-        # Arrange
-        user_group = UserGroup(
-            group_name="new_group", tasks=[UserGroupTask(enabled=True, feature="Alarms", read=True, write=False)]
-        )
-        self.api._endpoints.create_user_group = MagicMock()
-        # Act
-        self.api.create(user_group)
-        # Assert
-        self.api._endpoints.create_user_group.assert_called_once_with(user_group)
-
-    def test_update(self):
-        # Arrange
-        user_group = UserGroup(
-            group_name="new_group", tasks=[UserGroupTask(enabled=True, feature="Alarms", read=True, write=False)]
-        )
-        self.api._endpoints.update_user_group = MagicMock()
-        # Act
-        self.api.update(user_group)
-        # Assert
-        self.api._endpoints.update_user_group.assert_called_once_with(user_group.group_name, user_group)
-
-    def test_delete(self):
-        # Arrange
-        group_name = "new_group"
-        self.api._endpoints.delete_user_group = MagicMock()
-        # Act
-        self.api.delete(group_name)
-        # Assert
-        self.api._endpoints.delete_user_group.assert_called_once_with(group_name)
-
-
-class TestResourceGroupsAPI(unittest.TestCase):
-    @patch("catalystwan.session.ManagerSession")
-    def setUp(self, session_mock):
-        self.session = session_mock
-        self.session.api_version = None
-        self.session.session_type = None
-        self.session.password = "<>"
-        self.api = ResourceGroupsAPI(self.session)
-        self.api._endpoints = MagicMock()
-
-    def test_get(self):
-        # Arrange
-        expected_resource_groups = [
-            ResourceGroup(
-                id="0:RESGROUP:14567:XD$eD", name="new_resource_group1", desc="New Resource Group #1", site_ids=[200]
-            )
-        ]
-        self.api._endpoints.find_resource_groups = MagicMock(return_value=expected_resource_groups)
-        # Act
-        observed_resource_groups = self.api.get()
-        # Assert
-        self.api._endpoints.find_resource_groups.assert_called_once()
-        assert expected_resource_groups == observed_resource_groups
-
-    def test_create(self):
-        # Arrange
-        resource_group = ResourceGroup(name="new_resource_group3", desc="New Resource Group #3", site_ids=[200])
-        self.api._endpoints.create_resource_group = MagicMock()
-        # Act
-        self.api.create(resource_group)
-        # Assert
-        self.api._endpoints.create_resource_group.assert_called_once_with(resource_group)
-
-    def test_update(self):
-        # Arrange
-        resource_group_update = ResourceGroupUpdateRequest(
-            id="0:RESGROUP:14567:XD$eD", name="new_resource_group1", desc="New Resource Group #1", site_ids=[101, 102]
-        )
-        self.api._endpoints.update_resource_group = MagicMock()
-        # Act
-        self.api.update(resource_group_update)
-        # Assert
-        self.api._endpoints.update_resource_group.assert_called_once_with(
-            resource_group_update.id, resource_group_update
-        )
-
-    def test_switch(self):
-        # Arrange
-        resource_group_name = "new_resource_group1"
-        self.api._endpoints.switch_resource_group = MagicMock()
-        # Act
-        self.api.switch(resource_group_name)
-        # Assert
-        self.api._endpoints.switch_resource_group.assert_called_once_with(
-            ResourceGroupSwitchRequest(resource_group_name=resource_group_name)
-        )
-
-    def test_delete(self):
-        # Arrange
-        resource_group_id = "0:RESGROUP:14567:XD$eD"
-        self.api._endpoints.delete_resource_group = MagicMock()
-        # Act
-        self.api.delete(resource_group_id)
-        # Assert
-        self.api._endpoints.delete_resource_group.assert_called_once_with(resource_group_id)
-
-
-class TestClusterManagementAPI(unittest.TestCase):
-    def setUp(self) -> None:
-        self.service_configuration = {
-            "vmanageID": "1.1.1.1",
-            "deviceIP": "1.1.1.2",
-            "services": "none",
-        }
-        self.service_configuration_dataclass = create_dataclass(ServiceConfigurationData, self.service_configuration)
-        self.cluster_management_health_status = [
-            {"deviceIP": "localhost"},
-            {
-                "statistics-db": True,
-                "application-server": True,
-                "messaging-server": True,
-                "configuration-db": True,
-                "deviceIP": "localhost",
-            },
-        ]
-
-    @parameterized.expand([[200, True], [400, False]])
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_modify_cluster_setup(self, status_code, expected_outcome, mock_response, mock_session):
-        # Arrange
-        mock_session.put.return_value = mock_response
-        mock_response.status_code = status_code
-        # Act
-        answer = ClusterManagementAPI(mock_session).modify_cluster_setup(self.service_configuration_dataclass)
-        # Assert
-        self.assertEqual(answer, expected_outcome)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_cluster_management_health_status(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.cluster_management_health_status
-        # Act
-        answer = ClusterManagementAPI(mock_session).get_cluster_management_health_status()
-        # Assert
-        self.assertEqual(answer, self.cluster_management_health_status)
-
-
-class TestAdministrationSettingsAPI(unittest.TestCase):
-    def setUp(self) -> None:
-        self.cloud_connector_data = {
-            "clientId": "12345",
-            "clientSecret": "secret",  # pragma: allowlist secret
-            "orgName": "organization",
-            "telemetryEnabled": True,
-        }
-        self.cloud_connector_data_dataclass = create_dataclass(CloudConnectorData, self.cloud_connector_data)
-        self.cloud_services_settings = {"enabled": True}
-        self.cloud_services_settings_dataclass = create_dataclass(CloudServicesSettings, self.cloud_services_settings)
-        self.cloud_on_ramp = [{"": ""}]
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_sdavc_cloud_connector_config(self, mock_session):
-        # Arrange
-        mock_session.get_json.return_value = self.cloud_connector_data
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).get_sdavc_cloud_connector_config()
-        # Assert
-        self.assertEqual(answer, self.cloud_connector_data_dataclass)
-
-    @parameterized.expand([[200, True], [400, False]])
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_enable_sdavc_cloud_connector(self, status_code, expected_outcome, mock_response, mock_session):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = status_code
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).enable_sdavc_cloud_connector(
-            self.cloud_connector_data_dataclass
-        )
-        # Assert
-        self.assertEqual(answer, expected_outcome)
-
-    @parameterized.expand([[200, True], [400, False]])
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_disable_sdavc_cloud_connector(self, status_code, expected_outcome, mock_response, mock_session):
-        # Arrange
-        mock_session.put.return_value = mock_response
-        mock_response.status_code = status_code
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).disable_sdavc_cloud_connector()
-        # Assert
-        self.assertEqual(answer, expected_outcome)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_cloud_services(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = [self.cloud_services_settings]
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).get_cloud_services()
-        # Assert
-        self.assertEqual(answer, self.cloud_services_settings_dataclass)
-
-    @parameterized.expand([[200, True], [400, False]])
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_set_cloud_services(self, status_code, expected_outcome, mock_response, mock_session):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = status_code
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).set_cloud_services(self.cloud_services_settings_dataclass)
-        # Assert
-        self.assertEqual(answer, expected_outcome)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_cloud_on_ramp_for_saas_mode(self, mock_session):
-        # Arrange
-        mock_session.get_data.return_value = self.cloud_on_ramp
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).get_cloud_on_ramp_for_saas_mode()
-        # Assert
-        self.assertEqual(answer, self.cloud_on_ramp)
-
-    @parameterized.expand([[200, True], [400, False]])
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_enable_cloud_on_ramp_for_saas_mode(self, status_code, expected_outcome, mock_response, mock_session):
-        # Arrange
-        mock_session.put.return_value = mock_response
-        mock_response.status_code = status_code
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).enable_cloud_on_ramp_for_saas_mode(True)
-        # Assert
-        self.assertEqual(answer, expected_outcome)
-
-    @patch("catalystwan.session.ManagerSession")
-    def test_get_organization(self, mock_session):
-        # Arrange
-        organization = [{"domain-id": "1", "org": "My org name", "controlConnectionUp": "true"}]
-        organization_data = create_dataclass(Organization, organization[0])
-        mock_session.get_data.return_value = organization
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).get_organization()
-        # Assert
-        self.assertEqual(answer, organization_data)
-
-    @parameterized.expand([[password_dataclass], [certificate_dataclass], [organization_dataclass]])
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_update(self, payload, mock_response, mock_session):
-        # Arrange
-        mock_session.put.return_value = mock_response
-        mock_response.status_code = 200
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).update(payload)
-        # Assert
-        self.assertEqual(answer, True)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_update_vbond(self, mock_response, mock_session):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = 200
-        # Act
-        answer = AdministrationSettingsAPI(mock_session).update(vbond_dataclass)
-        # Assert
-        self.assertEqual(answer, True)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_update_error_with_dataclass(self, mock_response, mock_session):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = 200
-        random_dataclass = Connection("random state", "random peer", "127.0.0.1")
-
-        # Act
-        def answer():
-            AdministrationSettingsAPI(mock_session).update(random_dataclass)
-
-        # Assert
-        self.assertRaises(CatalystwanException, answer)
-
-    @patch("catalystwan.session.ManagerSession")
-    @patch("requests.Response")
-    def test_update_error_without_dataclass(self, mock_response, mock_session):
-        # Arrange
-        mock_session.post.return_value = mock_response
-        mock_response.status_code = 200
-
-        # Act
-        def answer():
-            AdministrationSettingsAPI(mock_session).update("random_dataclass")
-
-        # Assert
-        self.assertRaises(NotAnAttrsClassError, answer)