diff --git a/tests/unit/actions/test_client.py b/tests/unit/actions/test_client.py index a6a3ce25..ed207400 100644 --- a/tests/unit/actions/test_client.py +++ b/tests/unit/actions/test_client.py @@ -77,15 +77,18 @@ def test_wait_until_finished_max_retries( class TestResourceActionsClient: @pytest.fixture() - def actions_client(self): - return ResourceActionsClient(client=mock.MagicMock(), resource="/resource") + def actions_client(self, client: Client): + return ResourceActionsClient(client, resource="/resource") - def test_get_by_id(self, actions_client, generic_action): - actions_client._client.request.return_value = generic_action + def test_get_by_id( + self, + request_mock: mock.MagicMock, + actions_client: ActionsClient, + generic_action, + ): + request_mock.return_value = generic_action action = actions_client.get_by_id(1) - actions_client._client.request.assert_called_with( - url="/resource/actions/1", method="GET" - ) + request_mock.assert_called_with(url="/resource/actions/1", method="GET") assert action._client == actions_client._client.actions assert action.id == 1 assert action.command == "stop_server" @@ -94,10 +97,16 @@ def test_get_by_id(self, actions_client, generic_action): "params", [{}, {"status": ["active"], "sort": ["status"], "page": 2, "per_page": 10}], ) - def test_get_list(self, actions_client, generic_action_list, params): - actions_client._client.request.return_value = generic_action_list + def test_get_list( + self, + request_mock: mock.MagicMock, + actions_client: ActionsClient, + generic_action_list, + params, + ): + request_mock.return_value = generic_action_list result = actions_client.get_list(**params) - actions_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/resource/actions", method="GET", params=params ) @@ -118,13 +127,19 @@ def test_get_list(self, actions_client, generic_action_list, params): assert action2.command == "stop_server" @pytest.mark.parametrize("params", [{}, {"status": ["active"], "sort": ["status"]}]) - def test_get_all(self, actions_client, generic_action_list, params): - actions_client._client.request.return_value = generic_action_list + def test_get_all( + self, + request_mock: mock.MagicMock, + actions_client: ActionsClient, + generic_action_list, + params, + ): + request_mock.return_value = generic_action_list actions = actions_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - actions_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/resource/actions", method="GET", params=params ) @@ -144,15 +159,18 @@ def test_get_all(self, actions_client, generic_action_list, params): class TestActionsClient: @pytest.fixture() - def actions_client(self): - return ActionsClient(client=mock.MagicMock()) + def actions_client(self, client: Client): + return ActionsClient(client) - def test_get_by_id(self, actions_client, generic_action): - actions_client._client.request.return_value = generic_action + def test_get_by_id( + self, + request_mock: mock.MagicMock, + actions_client: ActionsClient, + generic_action, + ): + request_mock.return_value = generic_action action = actions_client.get_by_id(1) - actions_client._client.request.assert_called_with( - url="/actions/1", method="GET" - ) + request_mock.assert_called_with(url="/actions/1", method="GET") assert action._client == actions_client._client.actions assert action.id == 1 assert action.command == "stop_server" @@ -161,13 +179,17 @@ def test_get_by_id(self, actions_client, generic_action): "params", [{}, {"status": ["active"], "sort": ["status"], "page": 2, "per_page": 10}], ) - def test_get_list(self, actions_client, generic_action_list, params): - actions_client._client.request.return_value = generic_action_list + def test_get_list( + self, + request_mock: mock.MagicMock, + actions_client: ActionsClient, + generic_action_list, + params, + ): + request_mock.return_value = generic_action_list with pytest.deprecated_call(): result = actions_client.get_list(**params) - actions_client._client.request.assert_called_with( - url="/actions", method="GET", params=params - ) + request_mock.assert_called_with(url="/actions", method="GET", params=params) assert result.meta is not None @@ -186,16 +208,20 @@ def test_get_list(self, actions_client, generic_action_list, params): assert action2.command == "stop_server" @pytest.mark.parametrize("params", [{}, {"status": ["active"], "sort": ["status"]}]) - def test_get_all(self, actions_client, generic_action_list, params): - actions_client._client.request.return_value = generic_action_list + def test_get_all( + self, + request_mock: mock.MagicMock, + actions_client: ActionsClient, + generic_action_list, + params, + ): + request_mock.return_value = generic_action_list with pytest.deprecated_call(): actions = actions_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - actions_client._client.request.assert_called_with( - url="/actions", method="GET", params=params - ) + request_mock.assert_called_with(url="/actions", method="GET", params=params) assert len(actions) == 2 diff --git a/tests/unit/certificates/test_client.py b/tests/unit/certificates/test_client.py index 77a0ad0b..d8ebaf0d 100644 --- a/tests/unit/certificates/test_client.py +++ b/tests/unit/certificates/test_client.py @@ -133,15 +133,18 @@ def test_retry_issuance( class TestCertificatesClient: @pytest.fixture() - def certificates_client(self): - return CertificatesClient(client=mock.MagicMock()) + def certificates_client(self, client: Client): + return CertificatesClient(client) - def test_get_by_id(self, certificates_client, certificate_response): - certificates_client._client.request.return_value = certificate_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + certificate_response, + ): + request_mock.return_value = certificate_response certificate = certificates_client.get_by_id(1) - certificates_client._client.request.assert_called_with( - url="/certificates/1", method="GET" - ) + request_mock.assert_called_with(url="/certificates/1", method="GET") assert certificate._client is certificates_client assert certificate.id == 2323 assert certificate.name == "My Certificate" @@ -159,10 +162,16 @@ def test_get_by_id(self, certificates_client, certificate_response): {}, ], ) - def test_get_list(self, certificates_client, two_certificates_response, params): - certificates_client._client.request.return_value = two_certificates_response + def test_get_list( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + two_certificates_response, + params, + ): + request_mock.return_value = two_certificates_response result = certificates_client.get_list(**params) - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates", method="GET", params=params ) @@ -183,12 +192,18 @@ def test_get_list(self, certificates_client, two_certificates_response, params): @pytest.mark.parametrize( "params", [{"name": "My Certificate", "label_selector": "label1"}, {}] ) - def test_get_all(self, certificates_client, two_certificates_response, params): - certificates_client._client.request.return_value = two_certificates_response + def test_get_all( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + two_certificates_response, + params, + ): + request_mock.return_value = two_certificates_response certificates = certificates_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates", method="GET", params=params ) @@ -205,12 +220,17 @@ def test_get_all(self, certificates_client, two_certificates_response, params): assert certificates2.id == 2324 assert certificates2.name == "My website cert" - def test_get_by_name(self, certificates_client, one_certificates_response): - certificates_client._client.request.return_value = one_certificates_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + one_certificates_response, + ): + request_mock.return_value = one_certificates_response certificates = certificates_client.get_by_name("My Certificate") params = {"name": "My Certificate"} - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates", method="GET", params=params ) @@ -218,14 +238,19 @@ def test_get_by_name(self, certificates_client, one_certificates_response): assert certificates.id == 2323 assert certificates.name == "My Certificate" - def test_create(self, certificates_client, certificate_response): - certificates_client._client.request.return_value = certificate_response + def test_create( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + certificate_response, + ): + request_mock.return_value = certificate_response certificate = certificates_client.create( name="My Certificate", certificate="-----BEGIN CERTIFICATE-----\n...", private_key="-----BEGIN PRIVATE KEY-----\n...", ) - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates", method="POST", json={ @@ -240,15 +265,16 @@ def test_create(self, certificates_client, certificate_response): assert certificate.name == "My Certificate" def test_create_managed( - self, certificates_client, create_managed_certificate_response + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + create_managed_certificate_response, ): - certificates_client._client.request.return_value = ( - create_managed_certificate_response - ) + request_mock.return_value = create_managed_certificate_response create_managed_certificate_rsp = certificates_client.create_managed( name="My Certificate", domain_names=["example.com", "*.example.org"] ) - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates", method="POST", json={ @@ -268,11 +294,15 @@ def test_create_managed( [Certificate(id=1), BoundCertificate(mock.MagicMock(), dict(id=1))], ) def test_update( - self, certificates_client, certificate, response_update_certificate + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + certificate, + response_update_certificate, ): - certificates_client._client.request.return_value = response_update_certificate + request_mock.return_value = response_update_certificate certificate = certificates_client.update(certificate, name="New name") - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates/1", method="PUT", json={"name": "New name"} ) @@ -283,12 +313,16 @@ def test_update( "certificate", [Certificate(id=1), BoundCertificate(mock.MagicMock(), dict(id=1))], ) - def test_delete(self, certificates_client, certificate, generic_action): - certificates_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + certificate, + generic_action, + ): + request_mock.return_value = generic_action delete_success = certificates_client.delete(certificate) - certificates_client._client.request.assert_called_with( - url="/certificates/1", method="DELETE" - ) + request_mock.assert_called_with(url="/certificates/1", method="DELETE") assert delete_success is True @@ -297,39 +331,47 @@ def test_delete(self, certificates_client, certificate, generic_action): [Certificate(id=1), BoundCertificate(mock.MagicMock(), dict(id=1))], ) def test_retry_issuance( - self, certificates_client, certificate, response_retry_issuance_action + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + certificate, + response_retry_issuance_action, ): - certificates_client._client.request.return_value = ( - response_retry_issuance_action - ) + request_mock.return_value = response_retry_issuance_action action = certificates_client.retry_issuance(certificate) - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates/1/actions/retry", method="POST" ) assert action.id == 14 assert action.command == "issue_certificate" - def test_actions_get_by_id(self, certificates_client, response_get_actions): - certificates_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = certificates_client.actions.get_by_id(13) - certificates_client._client.request.assert_called_with( - url="/certificates/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/certificates/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == certificates_client._client.actions assert action.id == 13 assert action.command == "change_protection" - def test_actions_get_list(self, certificates_client, response_get_actions): - certificates_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = certificates_client.actions.get_list() - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates/actions", method="GET", params={}, @@ -344,11 +386,16 @@ def test_actions_get_list(self, certificates_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "change_protection" - def test_actions_get_all(self, certificates_client, response_get_actions): - certificates_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + certificates_client: CertificatesClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = certificates_client.actions.get_all() - certificates_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/certificates/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/conftest.py b/tests/unit/conftest.py index fb620c20..d5e760e9 100644 --- a/tests/unit/conftest.py +++ b/tests/unit/conftest.py @@ -35,12 +35,3 @@ def generic_action(): "error": {"code": "action_failed", "message": "Action failed"}, } } - - -@pytest.fixture() -def hetzner_client(): - client = Client(token="token") - patcher = mock.patch.object(client, "request") - patcher.start() - yield client - patcher.stop() diff --git a/tests/unit/datacenters/test_client.py b/tests/unit/datacenters/test_client.py index 3da55e37..c51331bd 100644 --- a/tests/unit/datacenters/test_client.py +++ b/tests/unit/datacenters/test_client.py @@ -4,6 +4,7 @@ import pytest # noqa: F401 +from hcloud import Client from hcloud.datacenters import BoundDatacenter, DatacentersClient, DatacenterServerTypes from hcloud.locations import BoundLocation @@ -58,15 +59,18 @@ def test_bound_datacenter_init(self, datacenter_response): class TestDatacentersClient: @pytest.fixture() - def datacenters_client(self): - return DatacentersClient(client=mock.MagicMock()) - - def test_get_by_id(self, datacenters_client, datacenter_response): - datacenters_client._client.request.return_value = datacenter_response + def datacenters_client(self, client: Client): + return DatacentersClient(client) + + def test_get_by_id( + self, + request_mock: mock.MagicMock, + datacenters_client: DatacentersClient, + datacenter_response, + ): + request_mock.return_value = datacenter_response datacenter = datacenters_client.get_by_id(1) - datacenters_client._client.request.assert_called_with( - url="/datacenters/1", method="GET" - ) + request_mock.assert_called_with(url="/datacenters/1", method="GET") assert datacenter._client is datacenters_client assert datacenter.id == 1 assert datacenter.name == "fsn1-dc8" @@ -74,12 +78,16 @@ def test_get_by_id(self, datacenters_client, datacenter_response): @pytest.mark.parametrize( "params", [{"name": "fsn1", "page": 1, "per_page": 10}, {"name": ""}, {}] ) - def test_get_list(self, datacenters_client, two_datacenters_response, params): - datacenters_client._client.request.return_value = two_datacenters_response + def test_get_list( + self, + request_mock: mock.MagicMock, + datacenters_client: DatacentersClient, + two_datacenters_response, + params, + ): + request_mock.return_value = two_datacenters_response result = datacenters_client.get_list(**params) - datacenters_client._client.request.assert_called_with( - url="/datacenters", method="GET", params=params - ) + request_mock.assert_called_with(url="/datacenters", method="GET", params=params) datacenters = result.datacenters assert result.meta is not None @@ -100,14 +108,18 @@ def test_get_list(self, datacenters_client, two_datacenters_response, params): assert isinstance(datacenter2.location, BoundLocation) @pytest.mark.parametrize("params", [{"name": "fsn1"}, {}]) - def test_get_all(self, datacenters_client, two_datacenters_response, params): - datacenters_client._client.request.return_value = two_datacenters_response + def test_get_all( + self, + request_mock: mock.MagicMock, + datacenters_client: DatacentersClient, + two_datacenters_response, + params, + ): + request_mock.return_value = two_datacenters_response datacenters = datacenters_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - datacenters_client._client.request.assert_called_with( - url="/datacenters", method="GET", params=params - ) + request_mock.assert_called_with(url="/datacenters", method="GET", params=params) assert len(datacenters) == 2 @@ -124,14 +136,17 @@ def test_get_all(self, datacenters_client, two_datacenters_response, params): assert datacenter2.name == "nbg1-dc3" assert isinstance(datacenter2.location, BoundLocation) - def test_get_by_name(self, datacenters_client, one_datacenters_response): - datacenters_client._client.request.return_value = one_datacenters_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + datacenters_client: DatacentersClient, + one_datacenters_response, + ): + request_mock.return_value = one_datacenters_response datacenter = datacenters_client.get_by_name("fsn1-dc8") params = {"name": "fsn1-dc8"} - datacenters_client._client.request.assert_called_with( - url="/datacenters", method="GET", params=params - ) + request_mock.assert_called_with(url="/datacenters", method="GET", params=params) assert datacenter._client is datacenters_client assert datacenter.id == 1 diff --git a/tests/unit/firewalls/test_client.py b/tests/unit/firewalls/test_client.py index bb3f9402..e3bdf5e4 100644 --- a/tests/unit/firewalls/test_client.py +++ b/tests/unit/firewalls/test_client.py @@ -227,15 +227,18 @@ def test_remove_from_resources( class TestFirewallsClient: @pytest.fixture() - def firewalls_client(self): - return FirewallsClient(client=mock.MagicMock()) + def firewalls_client(self, client: Client): + return FirewallsClient(client) - def test_get_by_id(self, firewalls_client, firewall_response): - firewalls_client._client.request.return_value = firewall_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall_response, + ): + request_mock.return_value = firewall_response firewall = firewalls_client.get_by_id(1) - firewalls_client._client.request.assert_called_with( - url="/firewalls/1", method="GET" - ) + request_mock.assert_called_with(url="/firewalls/1", method="GET") assert firewall._client is firewalls_client assert firewall.id == 38 assert firewall.name == "Corporate Intranet Protection" @@ -254,12 +257,16 @@ def test_get_by_id(self, firewalls_client, firewall_response): {}, ], ) - def test_get_list(self, firewalls_client, two_firewalls_response, params): - firewalls_client._client.request.return_value = two_firewalls_response + def test_get_list( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + two_firewalls_response, + params, + ): + request_mock.return_value = two_firewalls_response result = firewalls_client.get_list(**params) - firewalls_client._client.request.assert_called_with( - url="/firewalls", method="GET", params=params - ) + request_mock.assert_called_with(url="/firewalls", method="GET", params=params) firewalls = result.firewalls assert result.meta is not None @@ -288,15 +295,19 @@ def test_get_list(self, firewalls_client, two_firewalls_response, params): {}, ], ) - def test_get_all(self, firewalls_client, two_firewalls_response, params): - firewalls_client._client.request.return_value = two_firewalls_response + def test_get_all( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + two_firewalls_response, + params, + ): + request_mock.return_value = two_firewalls_response firewalls = firewalls_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - firewalls_client._client.request.assert_called_with( - url="/firewalls", method="GET", params=params - ) + request_mock.assert_called_with(url="/firewalls", method="GET", params=params) assert len(firewalls) == 2 @@ -311,15 +322,18 @@ def test_get_all(self, firewalls_client, two_firewalls_response, params): assert firewalls2.id == 39 assert firewalls2.name == "Corporate Extranet Protection" - def test_get_by_name(self, firewalls_client, one_firewalls_response): - firewalls_client._client.request.return_value = one_firewalls_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + one_firewalls_response, + ): + request_mock.return_value = one_firewalls_response firewall = firewalls_client.get_by_name("Corporate Intranet Protection") params = {"name": "Corporate Intranet Protection"} - firewalls_client._client.request.assert_called_with( - url="/firewalls", method="GET", params=params - ) + request_mock.assert_called_with(url="/firewalls", method="GET", params=params) assert firewall._client is firewalls_client assert firewall.id == 38 @@ -328,10 +342,16 @@ def test_get_by_name(self, firewalls_client, one_firewalls_response): @pytest.mark.parametrize( "firewall", [Firewall(id=1), BoundFirewall(mock.MagicMock(), dict(id=1))] ) - def test_get_actions_list(self, firewalls_client, firewall, response_get_actions): - firewalls_client._client.request.return_value = response_get_actions + def test_get_actions_list( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = firewalls_client.get_actions_list(firewall) - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/1/actions", method="GET", params={} ) @@ -345,8 +365,13 @@ def test_get_actions_list(self, firewalls_client, firewall, response_get_actions assert actions[0].id == 13 assert actions[0].command == "set_firewall_rules" - def test_create(self, firewalls_client, response_create_firewall): - firewalls_client._client.request.return_value = response_create_firewall + def test_create( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + response_create_firewall, + ): + request_mock.return_value = response_create_firewall response = firewalls_client.create( "Corporate Intranet Protection", rules=[ @@ -366,7 +391,7 @@ def test_create(self, firewalls_client, response_create_firewall): ), ], ) - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls", method="POST", json={ @@ -397,12 +422,18 @@ def test_create(self, firewalls_client, response_create_firewall): @pytest.mark.parametrize( "firewall", [Firewall(id=38), BoundFirewall(mock.MagicMock(), dict(id=38))] ) - def test_update(self, firewalls_client, firewall, response_update_firewall): - firewalls_client._client.request.return_value = response_update_firewall + def test_update( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall, + response_update_firewall, + ): + request_mock.return_value = response_update_firewall firewall = firewalls_client.update( firewall, name="New Corporate Intranet Protection", labels={} ) - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/38", method="PUT", json={"name": "New Corporate Intranet Protection", "labels": {}}, @@ -414,8 +445,14 @@ def test_update(self, firewalls_client, firewall, response_update_firewall): @pytest.mark.parametrize( "firewall", [Firewall(id=1), BoundFirewall(mock.MagicMock(), dict(id=1))] ) - def test_set_rules(self, firewalls_client, firewall, response_set_rules): - firewalls_client._client.request.return_value = response_set_rules + def test_set_rules( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall, + response_set_rules, + ): + request_mock.return_value = response_set_rules actions = firewalls_client.set_rules( firewall, [ @@ -426,7 +463,7 @@ def test_set_rules(self, firewalls_client, firewall, response_set_rules): ) ], ) - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/1/actions/set_rules", method="POST", json={ @@ -446,25 +483,34 @@ def test_set_rules(self, firewalls_client, firewall, response_set_rules): @pytest.mark.parametrize( "firewall", [Firewall(id=1), BoundFirewall(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, firewalls_client, firewall): + def test_delete( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall, + ): delete_success = firewalls_client.delete(firewall) - firewalls_client._client.request.assert_called_with( - url="/firewalls/1", method="DELETE" - ) + request_mock.assert_called_with(url="/firewalls/1", method="DELETE") assert delete_success is True @pytest.mark.parametrize( "firewall", [Firewall(id=1), BoundFirewall(mock.MagicMock(), dict(id=1))] ) - def test_apply_to_resources(self, firewalls_client, firewall, response_set_rules): - firewalls_client._client.request.return_value = response_set_rules + def test_apply_to_resources( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall, + response_set_rules, + ): + request_mock.return_value = response_set_rules actions = firewalls_client.apply_to_resources( firewall, [FirewallResource(type=FirewallResource.TYPE_SERVER, server=Server(id=5))], ) - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/1/actions/apply_to_resources", method="POST", json={"apply_to": [{"type": "server", "server": {"id": 5}}]}, @@ -477,15 +523,19 @@ def test_apply_to_resources(self, firewalls_client, firewall, response_set_rules "firewall", [Firewall(id=1), BoundFirewall(mock.MagicMock(), dict(id=1))] ) def test_remove_from_resources( - self, firewalls_client, firewall, response_set_rules + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + firewall, + response_set_rules, ): - firewalls_client._client.request.return_value = response_set_rules + request_mock.return_value = response_set_rules actions = firewalls_client.remove_from_resources( firewall, [FirewallResource(type=FirewallResource.TYPE_SERVER, server=Server(id=5))], ) - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/1/actions/remove_from_resources", method="POST", json={"remove_from": [{"type": "server", "server": {"id": 5}}]}, @@ -494,26 +544,32 @@ def test_remove_from_resources( assert actions[0].id == 13 assert actions[0].progress == 100 - def test_actions_get_by_id(self, firewalls_client, response_get_actions): - firewalls_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = firewalls_client.actions.get_by_id(13) - firewalls_client._client.request.assert_called_with( - url="/firewalls/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/firewalls/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == firewalls_client._client.actions assert action.id == 13 assert action.command == "set_firewall_rules" - def test_actions_get_list(self, firewalls_client, response_get_actions): - firewalls_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = firewalls_client.actions.get_list() - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/actions", method="GET", params={}, @@ -528,11 +584,16 @@ def test_actions_get_list(self, firewalls_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "set_firewall_rules" - def test_actions_get_all(self, firewalls_client, response_get_actions): - firewalls_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + firewalls_client: FirewallsClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = firewalls_client.actions.get_all() - firewalls_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/firewalls/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/floating_ips/test_client.py b/tests/unit/floating_ips/test_client.py index d48c85cb..e26da382 100644 --- a/tests/unit/floating_ips/test_client.py +++ b/tests/unit/floating_ips/test_client.py @@ -163,23 +163,31 @@ def test_change_dns_ptr( class TestFloatingIPsClient: @pytest.fixture() - def floating_ips_client(self): - return FloatingIPsClient(client=mock.MagicMock()) + def floating_ips_client(self, client: Client): + return FloatingIPsClient(client) - def test_get_by_id(self, floating_ips_client, floating_ip_response): - floating_ips_client._client.request.return_value = floating_ip_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip_response, + ): + request_mock.return_value = floating_ip_response bound_floating_ip = floating_ips_client.get_by_id(1) - floating_ips_client._client.request.assert_called_with( - url="/floating_ips/1", method="GET" - ) + request_mock.assert_called_with(url="/floating_ips/1", method="GET") assert bound_floating_ip._client is floating_ips_client assert bound_floating_ip.id == 4711 assert bound_floating_ip.description == "Web Frontend" - def test_get_by_name(self, floating_ips_client, one_floating_ips_response): - floating_ips_client._client.request.return_value = one_floating_ips_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + one_floating_ips_response, + ): + request_mock.return_value = one_floating_ips_response bound_floating_ip = floating_ips_client.get_by_name("Web Frontend") - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips", method="GET", params={"name": "Web Frontend"} ) assert bound_floating_ip._client is floating_ips_client @@ -191,10 +199,16 @@ def test_get_by_name(self, floating_ips_client, one_floating_ips_response): "params", [{"label_selector": "label1", "page": 1, "per_page": 10}, {"name": ""}, {}], ) - def test_get_list(self, floating_ips_client, two_floating_ips_response, params): - floating_ips_client._client.request.return_value = two_floating_ips_response + def test_get_list( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + two_floating_ips_response, + params, + ): + request_mock.return_value = two_floating_ips_response result = floating_ips_client.get_list(**params) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips", method="GET", params=params ) @@ -215,13 +229,19 @@ def test_get_list(self, floating_ips_client, two_floating_ips_response, params): assert bound_floating_ip2.description == "Web Backend" @pytest.mark.parametrize("params", [{"label_selector": "label1"}, {}]) - def test_get_all(self, floating_ips_client, two_floating_ips_response, params): - floating_ips_client._client.request.return_value = two_floating_ips_response + def test_get_all( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + two_floating_ips_response, + params, + ): + request_mock.return_value = two_floating_ips_response bound_floating_ips = floating_ips_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips", method="GET", params=params ) @@ -238,12 +258,17 @@ def test_get_all(self, floating_ips_client, two_floating_ips_response, params): assert bound_floating_ip2.id == 4712 assert bound_floating_ip2.description == "Web Backend" - def test_create_with_location(self, floating_ips_client, floating_ip_response): - floating_ips_client._client.request.return_value = floating_ip_response + def test_create_with_location( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip_response, + ): + request_mock.return_value = floating_ip_response response = floating_ips_client.create( "ipv6", "Web Frontend", home_location=Location(name="location") ) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips", method="POST", json={ @@ -265,13 +290,17 @@ def test_create_with_location(self, floating_ips_client, floating_ip_response): "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) def test_create_with_server( - self, floating_ips_client, server, floating_ip_create_response + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + server, + floating_ip_create_response, ): - floating_ips_client._client.request.return_value = floating_ip_create_response + request_mock.return_value = floating_ip_create_response response = floating_ips_client.create( type="ipv6", description="Web Frontend", server=server ) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips", method="POST", json={"description": "Web Frontend", "type": "ipv6", "server": 1}, @@ -288,13 +317,17 @@ def test_create_with_server( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) def test_create_with_name( - self, floating_ips_client, server, floating_ip_create_response + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + server, + floating_ip_create_response, ): - floating_ips_client._client.request.return_value = floating_ip_create_response + request_mock.return_value = floating_ip_create_response response = floating_ips_client.create( type="ipv6", description="Web Frontend", name="Web Frontend" ) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips", method="POST", json={ @@ -315,10 +348,16 @@ def test_create_with_name( @pytest.mark.parametrize( "floating_ip", [FloatingIP(id=1), BoundFloatingIP(mock.MagicMock(), dict(id=1))] ) - def test_get_actions(self, floating_ips_client, floating_ip, response_get_actions): - floating_ips_client._client.request.return_value = response_get_actions + def test_get_actions( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = floating_ips_client.get_actions(floating_ip) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/1/actions", method="GET", params={"page": 1, "per_page": 50}, @@ -335,13 +374,17 @@ def test_get_actions(self, floating_ips_client, floating_ip, response_get_action "floating_ip", [FloatingIP(id=1), BoundFloatingIP(mock.MagicMock(), dict(id=1))] ) def test_update( - self, floating_ips_client, floating_ip, response_update_floating_ip + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip, + response_update_floating_ip, ): - floating_ips_client._client.request.return_value = response_update_floating_ip + request_mock.return_value = response_update_floating_ip floating_ip = floating_ips_client.update( floating_ip, description="New description", name="New name" ) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/1", method="PUT", json={"description": "New description", "name": "New name"}, @@ -354,10 +397,16 @@ def test_update( @pytest.mark.parametrize( "floating_ip", [FloatingIP(id=1), BoundFloatingIP(mock.MagicMock(), dict(id=1))] ) - def test_change_protection(self, floating_ips_client, floating_ip, generic_action): - floating_ips_client._client.request.return_value = generic_action + def test_change_protection( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip, + generic_action, + ): + request_mock.return_value = generic_action action = floating_ips_client.change_protection(floating_ip, True) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/1/actions/change_protection", method="POST", json={"delete": True}, @@ -369,12 +418,16 @@ def test_change_protection(self, floating_ips_client, floating_ip, generic_actio @pytest.mark.parametrize( "floating_ip", [FloatingIP(id=1), BoundFloatingIP(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, floating_ips_client, floating_ip, generic_action): - floating_ips_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip, + generic_action, + ): + request_mock.return_value = generic_action delete_success = floating_ips_client.delete(floating_ip) - floating_ips_client._client.request.assert_called_with( - url="/floating_ips/1", method="DELETE" - ) + request_mock.assert_called_with(url="/floating_ips/1", method="DELETE") assert delete_success is True @@ -388,10 +441,17 @@ def test_delete(self, floating_ips_client, floating_ip, generic_action): ), ], ) - def test_assign(self, floating_ips_client, server, floating_ip, generic_action): - floating_ips_client._client.request.return_value = generic_action + def test_assign( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + server, + floating_ip, + generic_action, + ): + request_mock.return_value = generic_action action = floating_ips_client.assign(floating_ip, server) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/12/actions/assign", method="POST", json={"server": 1} ) assert action.id == 1 @@ -401,10 +461,16 @@ def test_assign(self, floating_ips_client, server, floating_ip, generic_action): "floating_ip", [FloatingIP(id=12), BoundFloatingIP(mock.MagicMock(), dict(id=12))], ) - def test_unassign(self, floating_ips_client, floating_ip, generic_action): - floating_ips_client._client.request.return_value = generic_action + def test_unassign( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip, + generic_action, + ): + request_mock.return_value = generic_action action = floating_ips_client.unassign(floating_ip) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/12/actions/unassign", method="POST" ) assert action.id == 1 @@ -414,12 +480,18 @@ def test_unassign(self, floating_ips_client, floating_ip, generic_action): "floating_ip", [FloatingIP(id=12), BoundFloatingIP(mock.MagicMock(), dict(id=12))], ) - def test_change_dns_ptr(self, floating_ips_client, floating_ip, generic_action): - floating_ips_client._client.request.return_value = generic_action + def test_change_dns_ptr( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + floating_ip, + generic_action, + ): + request_mock.return_value = generic_action action = floating_ips_client.change_dns_ptr( floating_ip, "1.2.3.4", "server02.example.com" ) - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/12/actions/change_dns_ptr", method="POST", json={"ip": "1.2.3.4", "dns_ptr": "server02.example.com"}, @@ -427,26 +499,32 @@ def test_change_dns_ptr(self, floating_ips_client, floating_ip, generic_action): assert action.id == 1 assert action.progress == 0 - def test_actions_get_by_id(self, floating_ips_client, response_get_actions): - floating_ips_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = floating_ips_client.actions.get_by_id(13) - floating_ips_client._client.request.assert_called_with( - url="/floating_ips/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/floating_ips/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == floating_ips_client._client.actions assert action.id == 13 assert action.command == "assign_floating_ip" - def test_actions_get_list(self, floating_ips_client, response_get_actions): - floating_ips_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = floating_ips_client.actions.get_list() - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/actions", method="GET", params={}, @@ -461,11 +539,16 @@ def test_actions_get_list(self, floating_ips_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "assign_floating_ip" - def test_actions_get_all(self, floating_ips_client, response_get_actions): - floating_ips_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + floating_ips_client: FloatingIPsClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = floating_ips_client.actions.get_all() - floating_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/floating_ips/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/images/test_client.py b/tests/unit/images/test_client.py index 62b42bcc..8e6add3a 100644 --- a/tests/unit/images/test_client.py +++ b/tests/unit/images/test_client.py @@ -152,13 +152,18 @@ def test_change_protection( class TestImagesClient: @pytest.fixture() - def images_client(self): - return ImagesClient(client=mock.MagicMock()) + def images_client(self, client: Client): + return ImagesClient(client) - def test_get_by_id(self, images_client, image_response): - images_client._client.request.return_value = image_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + image_response, + ): + request_mock.return_value = image_response image = images_client.get_by_id(1) - images_client._client.request.assert_called_with(url="/images/1", method="GET") + request_mock.assert_called_with(url="/images/1", method="GET") assert image._client is images_client assert image.id == 4711 assert image.name == "ubuntu-20.04" @@ -180,12 +185,16 @@ def test_get_by_id(self, images_client, image_response): {}, ], ) - def test_get_list(self, images_client, two_images_response, params): - images_client._client.request.return_value = two_images_response + def test_get_list( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + two_images_response, + params, + ): + request_mock.return_value = two_images_response result = images_client.get_list(**params) - images_client._client.request.assert_called_with( - url="/images", method="GET", params=params - ) + request_mock.assert_called_with(url="/images", method="GET", params=params) images = result.images assert result.meta is not None @@ -217,15 +226,19 @@ def test_get_list(self, images_client, two_images_response, params): {}, ], ) - def test_get_all(self, images_client, two_images_response, params): - images_client._client.request.return_value = two_images_response + def test_get_all( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + two_images_response, + params, + ): + request_mock.return_value = two_images_response images = images_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - images_client._client.request.assert_called_with( - url="/images", method="GET", params=params - ) + request_mock.assert_called_with(url="/images", method="GET", params=params) assert len(images) == 2 @@ -240,30 +253,36 @@ def test_get_all(self, images_client, two_images_response, params): assert images2.id == 4712 assert images2.name == "ubuntu-18.10" - def test_get_by_name(self, images_client, one_images_response): - images_client._client.request.return_value = one_images_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + one_images_response, + ): + request_mock.return_value = one_images_response with pytest.deprecated_call(): image = images_client.get_by_name("ubuntu-20.04") params = {"name": "ubuntu-20.04"} - images_client._client.request.assert_called_with( - url="/images", method="GET", params=params - ) + request_mock.assert_called_with(url="/images", method="GET", params=params) assert image._client is images_client assert image.id == 4711 assert image.name == "ubuntu-20.04" - def test_get_by_name_and_architecture(self, images_client, one_images_response): - images_client._client.request.return_value = one_images_response + def test_get_by_name_and_architecture( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + one_images_response, + ): + request_mock.return_value = one_images_response image = images_client.get_by_name_and_architecture("ubuntu-20.04", "x86") params = {"name": "ubuntu-20.04", "architecture": ["x86"]} - images_client._client.request.assert_called_with( - url="/images", method="GET", params=params - ) + request_mock.assert_called_with(url="/images", method="GET", params=params) assert image._client is images_client assert image.id == 4711 @@ -273,10 +292,16 @@ def test_get_by_name_and_architecture(self, images_client, one_images_response): @pytest.mark.parametrize( "image", [Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))] ) - def test_get_actions_list(self, images_client, image, response_get_actions): - images_client._client.request.return_value = response_get_actions + def test_get_actions_list( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + image, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = images_client.get_actions_list(image) - images_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/images/1/actions", method="GET", params={} ) @@ -293,12 +318,18 @@ def test_get_actions_list(self, images_client, image, response_get_actions): @pytest.mark.parametrize( "image", [Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))] ) - def test_update(self, images_client, image, response_update_image): - images_client._client.request.return_value = response_update_image + def test_update( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + image, + response_update_image, + ): + request_mock.return_value = response_update_image image = images_client.update( image, description="My new Image description", type="snapshot", labels={} ) - images_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/images/1", method="PUT", json={ @@ -314,10 +345,16 @@ def test_update(self, images_client, image, response_update_image): @pytest.mark.parametrize( "image", [Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))] ) - def test_change_protection(self, images_client, image, generic_action): - images_client._client.request.return_value = generic_action + def test_change_protection( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + image, + generic_action, + ): + request_mock.return_value = generic_action action = images_client.change_protection(image, True) - images_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/images/1/actions/change_protection", method="POST", json={"delete": True}, @@ -329,35 +366,45 @@ def test_change_protection(self, images_client, image, generic_action): @pytest.mark.parametrize( "image", [Image(id=1), BoundImage(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, images_client, image, generic_action): - images_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + image, + generic_action, + ): + request_mock.return_value = generic_action delete_success = images_client.delete(image) - images_client._client.request.assert_called_with( - url="/images/1", method="DELETE" - ) + request_mock.assert_called_with(url="/images/1", method="DELETE") assert delete_success is True - def test_actions_get_by_id(self, images_client, response_get_actions): - images_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = images_client.actions.get_by_id(13) - images_client._client.request.assert_called_with( - url="/images/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/images/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == images_client._client.actions assert action.id == 13 assert action.command == "change_protection" - def test_actions_get_list(self, images_client, response_get_actions): - images_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = images_client.actions.get_list() - images_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/images/actions", method="GET", params={}, @@ -372,11 +419,16 @@ def test_actions_get_list(self, images_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "change_protection" - def test_actions_get_all(self, images_client, response_get_actions): - images_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + images_client: ImagesClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = images_client.actions.get_all() - images_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/images/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/isos/test_client.py b/tests/unit/isos/test_client.py index 9c824377..2f57f170 100644 --- a/tests/unit/isos/test_client.py +++ b/tests/unit/isos/test_client.py @@ -37,13 +37,18 @@ def test_bound_iso_init(self, iso_response): class TestIsosClient: @pytest.fixture() - def isos_client(self): - return IsosClient(client=mock.MagicMock()) - - def test_get_by_id(self, isos_client, iso_response): - isos_client._client.request.return_value = iso_response + def isos_client(self, client: Client): + return IsosClient(client) + + def test_get_by_id( + self, + request_mock: mock.MagicMock, + isos_client: IsosClient, + iso_response, + ): + request_mock.return_value = iso_response iso = isos_client.get_by_id(1) - isos_client._client.request.assert_called_with(url="/isos/1", method="GET") + request_mock.assert_called_with(url="/isos/1", method="GET") assert iso._client is isos_client assert iso.id == 4711 assert iso.name == "FreeBSD-11.0-RELEASE-amd64-dvd1" @@ -56,12 +61,16 @@ def test_get_by_id(self, isos_client, iso_response): {"name": "FreeBSD-11.0-RELEASE-amd64-dvd1", "page": 1, "per_page": 2}, ], ) - def test_get_list(self, isos_client, two_isos_response, params): - isos_client._client.request.return_value = two_isos_response + def test_get_list( + self, + request_mock: mock.MagicMock, + isos_client: IsosClient, + two_isos_response, + params, + ): + request_mock.return_value = two_isos_response result = isos_client.get_list(**params) - isos_client._client.request.assert_called_with( - url="/isos", method="GET", params=params - ) + request_mock.assert_called_with(url="/isos", method="GET", params=params) isos = result.isos assert result.meta is not None @@ -82,15 +91,19 @@ def test_get_list(self, isos_client, two_isos_response, params): @pytest.mark.parametrize( "params", [{}, {"name": "FreeBSD-11.0-RELEASE-amd64-dvd1"}] ) - def test_get_all(self, isos_client, two_isos_response, params): - isos_client._client.request.return_value = two_isos_response + def test_get_all( + self, + request_mock: mock.MagicMock, + isos_client: IsosClient, + two_isos_response, + params, + ): + request_mock.return_value = two_isos_response isos = isos_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - isos_client._client.request.assert_called_with( - url="/isos", method="GET", params=params - ) + request_mock.assert_called_with(url="/isos", method="GET", params=params) assert len(isos) == 2 @@ -105,15 +118,18 @@ def test_get_all(self, isos_client, two_isos_response, params): assert isos2.id == 4712 assert isos2.name == "FreeBSD-11.0-RELEASE-amd64-dvd1" - def test_get_by_name(self, isos_client, one_isos_response): - isos_client._client.request.return_value = one_isos_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + isos_client: IsosClient, + one_isos_response, + ): + request_mock.return_value = one_isos_response iso = isos_client.get_by_name("FreeBSD-11.0-RELEASE-amd64-dvd1") params = {"name": "FreeBSD-11.0-RELEASE-amd64-dvd1"} - isos_client._client.request.assert_called_with( - url="/isos", method="GET", params=params - ) + request_mock.assert_called_with(url="/isos", method="GET", params=params) assert iso._client is isos_client assert iso.id == 4711 diff --git a/tests/unit/load_balancer_types/test_client.py b/tests/unit/load_balancer_types/test_client.py index f0a4c12e..96e65e9a 100644 --- a/tests/unit/load_balancer_types/test_client.py +++ b/tests/unit/load_balancer_types/test_client.py @@ -4,22 +4,24 @@ import pytest +from hcloud import Client from hcloud.load_balancer_types import LoadBalancerTypesClient class TestLoadBalancerTypesClient: @pytest.fixture() - def load_balancer_types_client(self): - return LoadBalancerTypesClient(client=mock.MagicMock()) - - def test_get_by_id(self, load_balancer_types_client, load_balancer_type_response): - load_balancer_types_client._client.request.return_value = ( - load_balancer_type_response - ) + def load_balancer_types_client(self, client: Client): + return LoadBalancerTypesClient(client) + + def test_get_by_id( + self, + request_mock: mock.MagicMock, + load_balancer_types_client: LoadBalancerTypesClient, + load_balancer_type_response, + ): + request_mock.return_value = load_balancer_type_response load_balancer_type = load_balancer_types_client.get_by_id(1) - load_balancer_types_client._client.request.assert_called_with( - url="/load_balancer_types/1", method="GET" - ) + request_mock.assert_called_with(url="/load_balancer_types/1", method="GET") assert load_balancer_type._client is load_balancer_types_client assert load_balancer_type.id == 1 assert load_balancer_type.name == "LB11" @@ -28,13 +30,15 @@ def test_get_by_id(self, load_balancer_types_client, load_balancer_type_response "params", [{"name": "LB11", "page": 1, "per_page": 10}, {"name": ""}, {}] ) def test_get_list( - self, load_balancer_types_client, two_load_balancer_types_response, params + self, + request_mock: mock.MagicMock, + load_balancer_types_client: LoadBalancerTypesClient, + two_load_balancer_types_response, + params, ): - load_balancer_types_client._client.request.return_value = ( - two_load_balancer_types_response - ) + request_mock.return_value = two_load_balancer_types_response result = load_balancer_types_client.get_list(**params) - load_balancer_types_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancer_types", method="GET", params=params ) @@ -56,16 +60,18 @@ def test_get_list( @pytest.mark.parametrize("params", [{"name": "LB21"}]) def test_get_all( - self, load_balancer_types_client, two_load_balancer_types_response, params + self, + request_mock: mock.MagicMock, + load_balancer_types_client: LoadBalancerTypesClient, + two_load_balancer_types_response, + params, ): - load_balancer_types_client._client.request.return_value = ( - two_load_balancer_types_response - ) + request_mock.return_value = two_load_balancer_types_response load_balancer_types = load_balancer_types_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - load_balancer_types_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancer_types", method="GET", params=params ) @@ -83,16 +89,17 @@ def test_get_all( assert load_balancer_types2.name == "LB21" def test_get_by_name( - self, load_balancer_types_client, one_load_balancer_types_response + self, + request_mock: mock.MagicMock, + load_balancer_types_client: LoadBalancerTypesClient, + one_load_balancer_types_response, ): - load_balancer_types_client._client.request.return_value = ( - one_load_balancer_types_response - ) + request_mock.return_value = one_load_balancer_types_response load_balancer_type = load_balancer_types_client.get_by_name("LB21") params = {"name": "LB21"} - load_balancer_types_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancer_types", method="GET", params=params ) diff --git a/tests/unit/load_balancers/test_client.py b/tests/unit/load_balancers/test_client.py index 9010ec7c..158493c2 100644 --- a/tests/unit/load_balancers/test_client.py +++ b/tests/unit/load_balancers/test_client.py @@ -434,15 +434,18 @@ def test_change_type( class TestLoadBalancerslient: @pytest.fixture() - def load_balancers_client(self): - return LoadBalancersClient(client=mock.MagicMock()) + def load_balancers_client(self, client: Client): + return LoadBalancersClient(client) - def test_get_by_id(self, load_balancers_client, response_load_balancer): - load_balancers_client._client.request.return_value = response_load_balancer + def test_get_by_id( + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_load_balancer, + ): + request_mock.return_value = response_load_balancer bound_load_balancer = load_balancers_client.get_by_id(1) - load_balancers_client._client.request.assert_called_with( - url="/load_balancers/1", method="GET" - ) + request_mock.assert_called_with(url="/load_balancers/1", method="GET") assert bound_load_balancer._client is load_balancers_client assert bound_load_balancer.id == 4711 assert bound_load_balancer.name == "Web Frontend" @@ -464,13 +467,15 @@ def test_get_by_id(self, load_balancers_client, response_load_balancer): ], ) def test_get_list( - self, load_balancers_client, response_simple_load_balancers, params + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_simple_load_balancers, + params, ): - load_balancers_client._client.request.return_value = ( - response_simple_load_balancers - ) + request_mock.return_value = response_simple_load_balancers result = load_balancers_client.get_list(**params) - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers", method="GET", params=params ) @@ -494,16 +499,18 @@ def test_get_list( "params", [{"name": "loadbalancer1", "label_selector": "label1"}, {}] ) def test_get_all( - self, load_balancers_client, response_simple_load_balancers, params + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_simple_load_balancers, + params, ): - load_balancers_client._client.request.return_value = ( - response_simple_load_balancers - ) + request_mock.return_value = response_simple_load_balancers bound_load_balancers = load_balancers_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers", method="GET", params=params ) @@ -520,15 +527,18 @@ def test_get_all( assert bound_load_balancer2.id == 4712 assert bound_load_balancer2.name == "Web Frontend2" - def test_get_by_name(self, load_balancers_client, response_simple_load_balancers): - load_balancers_client._client.request.return_value = ( - response_simple_load_balancers - ) + def test_get_by_name( + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_simple_load_balancers, + ): + request_mock.return_value = response_simple_load_balancers bound_load_balancer = load_balancers_client.get_by_name("Web Frontend") params = {"name": "Web Frontend"} - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers", method="GET", params=params ) @@ -536,16 +546,19 @@ def test_get_by_name(self, load_balancers_client, response_simple_load_balancers assert bound_load_balancer.id == 4711 assert bound_load_balancer.name == "Web Frontend" - def test_create(self, load_balancers_client, response_create_load_balancer): - load_balancers_client._client.request.return_value = ( - response_create_load_balancer - ) + def test_create( + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_create_load_balancer, + ): + request_mock.return_value = response_create_load_balancer response = load_balancers_client.create( "my-balancer", load_balancer_type=LoadBalancerType(name="lb11"), location=Location(id=1), ) - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers", method="POST", json={"name": "my-balancer", "load_balancer_type": "lb11", "location": 1}, @@ -562,13 +575,17 @@ def test_create(self, load_balancers_client, response_create_load_balancer): [LoadBalancer(id=1), BoundLoadBalancer(mock.MagicMock(), dict(id=1))], ) def test_change_type_with_load_balancer_type_name( - self, load_balancers_client, load_balancer, generic_action + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + load_balancer, + generic_action, ): - load_balancers_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = load_balancers_client.change_type( load_balancer, LoadBalancerType(name="lb11") ) - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers/1/actions/change_type", method="POST", json={"load_balancer_type": "lb11"}, @@ -582,13 +599,17 @@ def test_change_type_with_load_balancer_type_name( [LoadBalancer(id=1), BoundLoadBalancer(mock.MagicMock(), dict(id=1))], ) def test_change_type_with_load_balancer_type_id( - self, load_balancers_client, load_balancer, generic_action + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + load_balancer, + generic_action, ): - load_balancers_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = load_balancers_client.change_type( load_balancer, LoadBalancerType(id=1) ) - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers/1/actions/change_type", method="POST", json={"load_balancer_type": 1}, @@ -597,26 +618,32 @@ def test_change_type_with_load_balancer_type_id( assert action.id == 1 assert action.progress == 0 - def test_actions_get_by_id(self, load_balancers_client, response_get_actions): - load_balancers_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = load_balancers_client.actions.get_by_id(13) - load_balancers_client._client.request.assert_called_with( - url="/load_balancers/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/load_balancers/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == load_balancers_client._client.actions assert action.id == 13 assert action.command == "change_protection" - def test_actions_get_list(self, load_balancers_client, response_get_actions): - load_balancers_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = load_balancers_client.actions.get_list() - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers/actions", method="GET", params={}, @@ -631,11 +658,16 @@ def test_actions_get_list(self, load_balancers_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "change_protection" - def test_actions_get_all(self, load_balancers_client, response_get_actions): - load_balancers_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + load_balancers_client: LoadBalancersClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = load_balancers_client.actions.get_all() - load_balancers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/load_balancers/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/locations/test_client.py b/tests/unit/locations/test_client.py index c288230a..9b1b643b 100644 --- a/tests/unit/locations/test_client.py +++ b/tests/unit/locations/test_client.py @@ -1,23 +1,27 @@ from __future__ import annotations -from unittest import mock # noqa: F401 +from unittest import mock import pytest # noqa: F401 +from hcloud import Client from hcloud.locations import LocationsClient class TestLocationsClient: @pytest.fixture() - def locations_client(self): - return LocationsClient(client=mock.MagicMock()) - - def test_get_by_id(self, locations_client, location_response): - locations_client._client.request.return_value = location_response + def locations_client(self, client: Client): + return LocationsClient(client) + + def test_get_by_id( + self, + request_mock: mock.MagicMock, + locations_client: LocationsClient, + location_response, + ): + request_mock.return_value = location_response location = locations_client.get_by_id(1) - locations_client._client.request.assert_called_with( - url="/locations/1", method="GET" - ) + request_mock.assert_called_with(url="/locations/1", method="GET") assert location._client is locations_client assert location.id == 1 assert location.name == "fsn1" @@ -26,12 +30,16 @@ def test_get_by_id(self, locations_client, location_response): @pytest.mark.parametrize( "params", [{"name": "fsn1", "page": 1, "per_page": 10}, {"name": ""}, {}] ) - def test_get_list(self, locations_client, two_locations_response, params): - locations_client._client.request.return_value = two_locations_response + def test_get_list( + self, + request_mock: mock.MagicMock, + locations_client: LocationsClient, + two_locations_response, + params, + ): + request_mock.return_value = two_locations_response result = locations_client.get_list(**params) - locations_client._client.request.assert_called_with( - url="/locations", method="GET", params=params - ) + request_mock.assert_called_with(url="/locations", method="GET", params=params) locations = result.locations assert result.meta is not None @@ -52,15 +60,19 @@ def test_get_list(self, locations_client, two_locations_response, params): assert location2.network_zone == "eu-central" @pytest.mark.parametrize("params", [{"name": "fsn1"}, {}]) - def test_get_all(self, locations_client, two_locations_response, params): - locations_client._client.request.return_value = two_locations_response + def test_get_all( + self, + request_mock: mock.MagicMock, + locations_client: LocationsClient, + two_locations_response, + params, + ): + request_mock.return_value = two_locations_response locations = locations_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - locations_client._client.request.assert_called_with( - url="/locations", method="GET", params=params - ) + request_mock.assert_called_with(url="/locations", method="GET", params=params) assert len(locations) == 2 @@ -77,15 +89,18 @@ def test_get_all(self, locations_client, two_locations_response, params): assert location2.name == "nbg1" assert location2.network_zone == "eu-central" - def test_get_by_name(self, locations_client, one_locations_response): - locations_client._client.request.return_value = one_locations_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + locations_client: LocationsClient, + one_locations_response, + ): + request_mock.return_value = one_locations_response location = locations_client.get_by_name("fsn1") params = {"name": "fsn1"} - locations_client._client.request.assert_called_with( - url="/locations", method="GET", params=params - ) + request_mock.assert_called_with(url="/locations", method="GET", params=params) assert location._client is locations_client assert location.id == 1 diff --git a/tests/unit/networks/test_client.py b/tests/unit/networks/test_client.py index 8e365695..a80f87b1 100644 --- a/tests/unit/networks/test_client.py +++ b/tests/unit/networks/test_client.py @@ -215,8 +215,8 @@ def test_change_ip( class TestNetworksClient: @pytest.fixture() - def networks_client(self): - return NetworksClient(client=mock.MagicMock()) + def networks_client(self, client: Client): + return NetworksClient(client) @pytest.fixture() def network_subnet(self): @@ -239,12 +239,15 @@ def network_vswitch_subnet(self): def network_route(self): return NetworkRoute(destination="10.100.1.0/24", gateway="10.0.1.1") - def test_get_by_id(self, networks_client, network_response): - networks_client._client.request.return_value = network_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_response, + ): + request_mock.return_value = network_response bound_network = networks_client.get_by_id(1) - networks_client._client.request.assert_called_with( - url="/networks/1", method="GET" - ) + request_mock.assert_called_with(url="/networks/1", method="GET") assert bound_network._client is networks_client assert bound_network.id == 1 assert bound_network.name == "mynet" @@ -253,12 +256,16 @@ def test_get_by_id(self, networks_client, network_response): "params", [{"label_selector": "label1", "page": 1, "per_page": 10}, {"name": ""}, {}], ) - def test_get_list(self, networks_client, two_networks_response, params): - networks_client._client.request.return_value = two_networks_response + def test_get_list( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + two_networks_response, + params, + ): + request_mock.return_value = two_networks_response result = networks_client.get_list(**params) - networks_client._client.request.assert_called_with( - url="/networks", method="GET", params=params - ) + request_mock.assert_called_with(url="/networks", method="GET", params=params) bound_networks = result.networks assert result.meta is not None @@ -277,15 +284,19 @@ def test_get_list(self, networks_client, two_networks_response, params): assert bound_network2.name == "myanothernet" @pytest.mark.parametrize("params", [{"label_selector": "label1"}]) - def test_get_all(self, networks_client, two_networks_response, params): - networks_client._client.request.return_value = two_networks_response + def test_get_all( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + two_networks_response, + params, + ): + request_mock.return_value = two_networks_response bound_networks = networks_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - networks_client._client.request.assert_called_with( - url="/networks", method="GET", params=params - ) + request_mock.assert_called_with(url="/networks", method="GET", params=params) assert len(bound_networks) == 2 @@ -300,39 +311,50 @@ def test_get_all(self, networks_client, two_networks_response, params): assert bound_network2.id == 2 assert bound_network2.name == "myanothernet" - def test_get_by_name(self, networks_client, one_network_response): - networks_client._client.request.return_value = one_network_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + one_network_response, + ): + request_mock.return_value = one_network_response bound_network = networks_client.get_by_name("mynet") params = {"name": "mynet"} - networks_client._client.request.assert_called_with( - url="/networks", method="GET", params=params - ) + request_mock.assert_called_with(url="/networks", method="GET", params=params) assert bound_network._client is networks_client assert bound_network.id == 1 assert bound_network.name == "mynet" - def test_create(self, networks_client, network_create_response): - networks_client._client.request.return_value = network_create_response + def test_create( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_create_response, + ): + request_mock.return_value = network_create_response networks_client.create(name="mynet", ip_range="10.0.0.0/8") - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={"name": "mynet", "ip_range": "10.0.0.0/8"}, ) def test_create_with_expose_routes_to_vswitch( - self, networks_client, network_create_response_with_expose_routes_to_vswitch + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_create_response_with_expose_routes_to_vswitch, ): - networks_client._client.request.return_value = ( + request_mock.return_value = ( network_create_response_with_expose_routes_to_vswitch ) networks_client.create( name="mynet", ip_range="10.0.0.0/8", expose_routes_to_vswitch=True ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={ @@ -343,13 +365,17 @@ def test_create_with_expose_routes_to_vswitch( ) def test_create_with_subnet( - self, networks_client, network_subnet, network_create_response + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_subnet, + network_create_response, ): - networks_client._client.request.return_value = network_create_response + request_mock.return_value = network_create_response networks_client.create( name="mynet", ip_range="10.0.0.0/8", subnets=[network_subnet] ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={ @@ -366,15 +392,19 @@ def test_create_with_subnet( ) def test_create_with_subnet_vswitch( - self, networks_client, network_subnet, network_create_response + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_subnet, + network_create_response, ): - networks_client._client.request.return_value = network_create_response + request_mock.return_value = network_create_response network_subnet.type = NetworkSubnet.TYPE_VSWITCH network_subnet.vswitch_id = 1000 networks_client.create( name="mynet", ip_range="10.0.0.0/8", subnets=[network_subnet] ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={ @@ -392,13 +422,17 @@ def test_create_with_subnet_vswitch( ) def test_create_with_route( - self, networks_client, network_route, network_create_response + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_route, + network_create_response, ): - networks_client._client.request.return_value = network_create_response + request_mock.return_value = network_create_response networks_client.create( name="mynet", ip_range="10.0.0.0/8", routes=[network_route] ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={ @@ -410,11 +444,12 @@ def test_create_with_route( def test_create_with_route_and_expose_routes_to_vswitch( self, + request_mock: mock.MagicMock, networks_client, network_route, network_create_response_with_expose_routes_to_vswitch, ): - networks_client._client.request.return_value = ( + request_mock.return_value = ( network_create_response_with_expose_routes_to_vswitch ) networks_client.create( @@ -423,7 +458,7 @@ def test_create_with_route_and_expose_routes_to_vswitch( routes=[network_route], expose_routes_to_vswitch=True, ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={ @@ -435,16 +470,21 @@ def test_create_with_route_and_expose_routes_to_vswitch( ) def test_create_with_route_and_subnet( - self, networks_client, network_subnet, network_route, network_create_response + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network_subnet, + network_route, + network_create_response, ): - networks_client._client.request.return_value = network_create_response + request_mock.return_value = network_create_response networks_client.create( name="mynet", ip_range="10.0.0.0/8", subnets=[network_subnet], routes=[network_route], ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks", method="POST", json={ @@ -464,10 +504,16 @@ def test_create_with_route_and_subnet( @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_get_actions_list(self, networks_client, network, response_get_actions): - networks_client._client.request.return_value = response_get_actions + def test_get_actions_list( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = networks_client.get_actions_list(network, sort="id") - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions", method="GET", params={"sort": "id"} ) @@ -482,12 +528,18 @@ def test_get_actions_list(self, networks_client, network, response_get_actions): @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_update(self, networks_client, network, response_update_network): - networks_client._client.request.return_value = response_update_network + def test_update( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + response_update_network, + ): + request_mock.return_value = response_update_network network = networks_client.update( network, name="new-name", expose_routes_to_vswitch=True ) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1", method="PUT", json={"name": "new-name", "expose_routes_to_vswitch": True}, @@ -500,10 +552,16 @@ def test_update(self, networks_client, network, response_update_network): @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_change_protection(self, networks_client, network, generic_action): - networks_client._client.request.return_value = generic_action + def test_change_protection( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + ): + request_mock.return_value = generic_action action = networks_client.change_protection(network, True) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/change_protection", method="POST", json={"delete": True}, @@ -515,23 +573,34 @@ def test_change_protection(self, networks_client, network, generic_action): @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, networks_client, network, generic_action): - networks_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + ): + request_mock.return_value = generic_action delete_success = networks_client.delete(network) - networks_client._client.request.assert_called_with( - url="/networks/1", method="DELETE" - ) + request_mock.assert_called_with(url="/networks/1", method="DELETE") assert delete_success is True @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_add_subnet(self, networks_client, network, generic_action, network_subnet): - networks_client._client.request.return_value = generic_action + def test_add_subnet( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + network_subnet, + ): + request_mock.return_value = generic_action action = networks_client.add_subnet(network, network_subnet) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/add_subnet", method="POST", json={ @@ -548,12 +617,17 @@ def test_add_subnet(self, networks_client, network, generic_action, network_subn "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) def test_add_subnet_vswitch( - self, networks_client, network, generic_action, network_vswitch_subnet + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + network_vswitch_subnet, ): - networks_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = networks_client.add_subnet(network, network_vswitch_subnet) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/add_subnet", method="POST", json={ @@ -571,12 +645,17 @@ def test_add_subnet_vswitch( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) def test_delete_subnet( - self, networks_client, network, generic_action, network_subnet + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + network_subnet, ): - networks_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = networks_client.delete_subnet(network, network_subnet) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/delete_subnet", method="POST", json={"ip_range": "10.0.1.0/24"}, @@ -588,11 +667,18 @@ def test_delete_subnet( @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_add_route(self, networks_client, network, generic_action, network_route): - networks_client._client.request.return_value = generic_action + def test_add_route( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + network_route, + ): + request_mock.return_value = generic_action action = networks_client.add_route(network, network_route) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/add_route", method="POST", json={"destination": "10.100.1.0/24", "gateway": "10.0.1.1"}, @@ -605,12 +691,17 @@ def test_add_route(self, networks_client, network, generic_action, network_route "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) def test_delete_route( - self, networks_client, network, generic_action, network_route + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + network_route, ): - networks_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = networks_client.delete_route(network, network_route) - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/delete_route", method="POST", json={"destination": "10.100.1.0/24", "gateway": "10.0.1.1"}, @@ -622,10 +713,16 @@ def test_delete_route( @pytest.mark.parametrize( "network", [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=1))] ) - def test_change_ip_range(self, networks_client, network, generic_action): - networks_client._client.request.return_value = generic_action + def test_change_ip_range( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + network, + generic_action, + ): + request_mock.return_value = generic_action action = networks_client.change_ip_range(network, "10.0.0.0/12") - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/1/actions/change_ip_range", method="POST", json={"ip_range": "10.0.0.0/12"}, @@ -634,26 +731,32 @@ def test_change_ip_range(self, networks_client, network, generic_action): assert action.id == 1 assert action.progress == 0 - def test_actions_get_by_id(self, networks_client, response_get_actions): - networks_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = networks_client.actions.get_by_id(13) - networks_client._client.request.assert_called_with( - url="/networks/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/networks/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == networks_client._client.actions assert action.id == 13 assert action.command == "add_subnet" - def test_actions_get_list(self, networks_client, response_get_actions): - networks_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = networks_client.actions.get_list() - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/actions", method="GET", params={}, @@ -668,11 +771,16 @@ def test_actions_get_list(self, networks_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "add_subnet" - def test_actions_get_all(self, networks_client, response_get_actions): - networks_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + networks_client: NetworksClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = networks_client.actions.get_all() - networks_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/networks/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/placement_groups/test_client.py b/tests/unit/placement_groups/test_client.py index 58abd31d..824c50bd 100644 --- a/tests/unit/placement_groups/test_client.py +++ b/tests/unit/placement_groups/test_client.py @@ -67,15 +67,20 @@ def test_delete( class TestPlacementGroupsClient: @pytest.fixture() - def placement_groups_client(self): - return PlacementGroupsClient(client=mock.MagicMock()) + def placement_groups_client(self, client: Client): + return PlacementGroupsClient(client) - def test_get_by_id(self, placement_groups_client, placement_group_response): - placement_groups_client._client.request.return_value = placement_group_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + placement_groups_client: PlacementGroupsClient, + placement_group_response, + ): + request_mock.return_value = placement_group_response placement_group = placement_groups_client.get_by_id( placement_group_response["placement_group"]["id"] ) - placement_groups_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/placement_groups/{placement_group_id}".format( placement_group_id=placement_group_response["placement_group"]["id"] ), @@ -101,13 +106,15 @@ def test_get_by_id(self, placement_groups_client, placement_group_response): ], ) def test_get_list( - self, placement_groups_client, two_placement_groups_response, params + self, + request_mock: mock.MagicMock, + placement_groups_client: PlacementGroupsClient, + two_placement_groups_response, + params, ): - placement_groups_client._client.request.return_value = ( - two_placement_groups_response - ) + request_mock.return_value = two_placement_groups_response result = placement_groups_client.get_list(**params) - placement_groups_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/placement_groups", method="GET", params=params ) @@ -137,15 +144,17 @@ def test_get_list( ], ) def test_get_all( - self, placement_groups_client, two_placement_groups_response, params + self, + request_mock: mock.MagicMock, + placement_groups_client: PlacementGroupsClient, + two_placement_groups_response, + params, ): - placement_groups_client._client.request.return_value = ( - two_placement_groups_response - ) + request_mock.return_value = two_placement_groups_response placement_groups = placement_groups_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - placement_groups_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/placement_groups", method="GET", params=params ) @@ -160,16 +169,19 @@ def test_get_all( check_variables(placement_group, expected) - def test_get_by_name(self, placement_groups_client, one_placement_group_response): - placement_groups_client._client.request.return_value = ( - one_placement_group_response - ) + def test_get_by_name( + self, + request_mock: mock.MagicMock, + placement_groups_client: PlacementGroupsClient, + one_placement_group_response, + ): + request_mock.return_value = one_placement_group_response placement_group = placement_groups_client.get_by_name( one_placement_group_response["placement_groups"][0]["name"] ) params = {"name": one_placement_group_response["placement_groups"][0]["name"]} - placement_groups_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/placement_groups", method="GET", params=params ) @@ -177,10 +189,13 @@ def test_get_by_name(self, placement_groups_client, one_placement_group_response placement_group, one_placement_group_response["placement_groups"][0] ) - def test_create(self, placement_groups_client, response_create_placement_group): - placement_groups_client._client.request.return_value = ( - response_create_placement_group - ) + def test_create( + self, + request_mock: mock.MagicMock, + placement_groups_client: PlacementGroupsClient, + response_create_placement_group, + ): + request_mock.return_value = response_create_placement_group response = placement_groups_client.create( name=response_create_placement_group["placement_group"]["name"], type=response_create_placement_group["placement_group"]["type"], @@ -192,7 +207,7 @@ def test_create(self, placement_groups_client, response_create_placement_group): "labels": response_create_placement_group["placement_group"]["labels"], "type": response_create_placement_group["placement_group"]["type"], } - placement_groups_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/placement_groups", method="POST", json=json ) diff --git a/tests/unit/primary_ips/test_client.py b/tests/unit/primary_ips/test_client.py index 4e57e144..d3809e48 100644 --- a/tests/unit/primary_ips/test_client.py +++ b/tests/unit/primary_ips/test_client.py @@ -135,22 +135,30 @@ def test_change_dns_ptr( class TestPrimaryIPsClient: @pytest.fixture() - def primary_ips_client(self): - return PrimaryIPsClient(client=mock.MagicMock()) + def primary_ips_client(self, client: Client): + return PrimaryIPsClient(client) - def test_get_by_id(self, primary_ips_client, primary_ip_response): - primary_ips_client._client.request.return_value = primary_ip_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip_response, + ): + request_mock.return_value = primary_ip_response bound_primary_ip = primary_ips_client.get_by_id(1) - primary_ips_client._client.request.assert_called_with( - url="/primary_ips/1", method="GET" - ) + request_mock.assert_called_with(url="/primary_ips/1", method="GET") assert bound_primary_ip._client is primary_ips_client assert bound_primary_ip.id == 42 - def test_get_by_name(self, primary_ips_client, one_primary_ips_response): - primary_ips_client._client.request.return_value = one_primary_ips_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + one_primary_ips_response, + ): + request_mock.return_value = one_primary_ips_response bound_primary_ip = primary_ips_client.get_by_name("my-resource") - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips", method="GET", params={"name": "my-resource"} ) assert bound_primary_ip._client is primary_ips_client @@ -158,15 +166,19 @@ def test_get_by_name(self, primary_ips_client, one_primary_ips_response): assert bound_primary_ip.name == "my-resource" @pytest.mark.parametrize("params", [{"label_selector": "label1"}]) - def test_get_all(self, primary_ips_client, all_primary_ips_response, params): - primary_ips_client._client.request.return_value = all_primary_ips_response + def test_get_all( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + all_primary_ips_response, + params, + ): + request_mock.return_value = all_primary_ips_response bound_primary_ips = primary_ips_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - primary_ips_client._client.request.assert_called_with( - url="/primary_ips", method="GET", params=params - ) + request_mock.assert_called_with(url="/primary_ips", method="GET", params=params) assert len(bound_primary_ips) == 1 @@ -176,12 +188,17 @@ def test_get_all(self, primary_ips_client, all_primary_ips_response, params): assert bound_primary_ip1.id == 42 assert bound_primary_ip1.name == "my-resource" - def test_create_with_datacenter(self, primary_ips_client, primary_ip_response): - primary_ips_client._client.request.return_value = primary_ip_response + def test_create_with_datacenter( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip_response, + ): + request_mock.return_value = primary_ip_response response = primary_ips_client.create( type="ipv6", name="my-resource", datacenter=Datacenter(name="datacenter") ) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips", method="POST", json={ @@ -202,16 +219,19 @@ def test_create_with_datacenter(self, primary_ips_client, primary_ip_response): assert action is None def test_create_with_assignee_id( - self, primary_ips_client, primary_ip_create_response + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip_create_response, ): - primary_ips_client._client.request.return_value = primary_ip_create_response + request_mock.return_value = primary_ip_create_response response = primary_ips_client.create( type="ipv6", name="my-ip", assignee_id=17, assignee_type="server", ) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips", method="POST", json={ @@ -234,12 +254,18 @@ def test_create_with_assignee_id( @pytest.mark.parametrize( "primary_ip", [PrimaryIP(id=1), BoundPrimaryIP(mock.MagicMock(), dict(id=1))] ) - def test_update(self, primary_ips_client, primary_ip, response_update_primary_ip): - primary_ips_client._client.request.return_value = response_update_primary_ip + def test_update( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip, + response_update_primary_ip, + ): + request_mock.return_value = response_update_primary_ip primary_ip = primary_ips_client.update( primary_ip, auto_delete=True, name="my-resource" ) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/1", method="PUT", json={"auto_delete": True, "name": "my-resource"}, @@ -252,10 +278,16 @@ def test_update(self, primary_ips_client, primary_ip, response_update_primary_ip @pytest.mark.parametrize( "primary_ip", [PrimaryIP(id=1), BoundPrimaryIP(mock.MagicMock(), dict(id=1))] ) - def test_change_protection(self, primary_ips_client, primary_ip, generic_action): - primary_ips_client._client.request.return_value = generic_action + def test_change_protection( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip, + generic_action, + ): + request_mock.return_value = generic_action action = primary_ips_client.change_protection(primary_ip, True) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/1/actions/change_protection", method="POST", json={"delete": True}, @@ -267,12 +299,16 @@ def test_change_protection(self, primary_ips_client, primary_ip, generic_action) @pytest.mark.parametrize( "primary_ip", [PrimaryIP(id=1), BoundPrimaryIP(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, primary_ips_client, primary_ip, generic_action): - primary_ips_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip, + generic_action, + ): + request_mock.return_value = generic_action delete_success = primary_ips_client.delete(primary_ip) - primary_ips_client._client.request.assert_called_with( - url="/primary_ips/1", method="DELETE" - ) + request_mock.assert_called_with(url="/primary_ips/1", method="DELETE") assert delete_success is True @@ -284,11 +320,17 @@ def test_delete(self, primary_ips_client, primary_ip, generic_action): ], ) def test_assign( - self, primary_ips_client, assignee_id, assignee_type, primary_ip, generic_action + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + assignee_id, + assignee_type, + primary_ip, + generic_action, ): - primary_ips_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = primary_ips_client.assign(primary_ip, assignee_id, assignee_type) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/12/actions/assign", method="POST", json={"assignee_id": 1, "assignee_type": "server"}, @@ -299,10 +341,16 @@ def test_assign( @pytest.mark.parametrize( "primary_ip", [PrimaryIP(id=12), BoundPrimaryIP(mock.MagicMock(), dict(id=12))] ) - def test_unassign(self, primary_ips_client, primary_ip, generic_action): - primary_ips_client._client.request.return_value = generic_action + def test_unassign( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip, + generic_action, + ): + request_mock.return_value = generic_action action = primary_ips_client.unassign(primary_ip) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/12/actions/unassign", method="POST" ) assert action.id == 1 @@ -311,12 +359,18 @@ def test_unassign(self, primary_ips_client, primary_ip, generic_action): @pytest.mark.parametrize( "primary_ip", [PrimaryIP(id=12), BoundPrimaryIP(mock.MagicMock(), dict(id=12))] ) - def test_change_dns_ptr(self, primary_ips_client, primary_ip, generic_action): - primary_ips_client._client.request.return_value = generic_action + def test_change_dns_ptr( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + primary_ip, + generic_action, + ): + request_mock.return_value = generic_action action = primary_ips_client.change_dns_ptr( primary_ip, "1.2.3.4", "server02.example.com" ) - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/12/actions/change_dns_ptr", method="POST", json={"ip": "1.2.3.4", "dns_ptr": "server02.example.com"}, @@ -324,26 +378,32 @@ def test_change_dns_ptr(self, primary_ips_client, primary_ip, generic_action): assert action.id == 1 assert action.progress == 0 - def test_actions_get_by_id(self, primary_ips_client, response_get_actions): - primary_ips_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = primary_ips_client.actions.get_by_id(13) - primary_ips_client._client.request.assert_called_with( - url="/primary_ips/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/primary_ips/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == primary_ips_client._client.actions assert action.id == 13 assert action.command == "assign_primary_ip" - def test_actions_get_list(self, primary_ips_client, response_get_actions): - primary_ips_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = primary_ips_client.actions.get_list() - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/actions", method="GET", params={}, @@ -358,11 +418,16 @@ def test_actions_get_list(self, primary_ips_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "assign_primary_ip" - def test_actions_get_all(self, primary_ips_client, response_get_actions): - primary_ips_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + primary_ips_client: PrimaryIPsClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = primary_ips_client.actions.get_all() - primary_ips_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/primary_ips/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/server_types/test_client.py b/tests/unit/server_types/test_client.py index 633f67d9..92c9bef7 100644 --- a/tests/unit/server_types/test_client.py +++ b/tests/unit/server_types/test_client.py @@ -42,15 +42,18 @@ def test_bound_server_type_init(self, server_type_response): class TestServerTypesClient: @pytest.fixture() - def server_types_client(self): - return ServerTypesClient(client=mock.MagicMock()) - - def test_get_by_id(self, server_types_client, server_type_response): - server_types_client._client.request.return_value = server_type_response + def server_types_client(self, client: Client): + return ServerTypesClient(client) + + def test_get_by_id( + self, + request_mock: mock.MagicMock, + server_types_client: ServerTypesClient, + server_type_response, + ): + request_mock.return_value = server_type_response server_type = server_types_client.get_by_id(1) - server_types_client._client.request.assert_called_with( - url="/server_types/1", method="GET" - ) + request_mock.assert_called_with(url="/server_types/1", method="GET") assert server_type._client is server_types_client assert server_type.id == 1 assert server_type.name == "cx11" @@ -58,10 +61,16 @@ def test_get_by_id(self, server_types_client, server_type_response): @pytest.mark.parametrize( "params", [{"name": "cx11", "page": 1, "per_page": 10}, {"name": ""}, {}] ) - def test_get_list(self, server_types_client, two_server_types_response, params): - server_types_client._client.request.return_value = two_server_types_response + def test_get_list( + self, + request_mock: mock.MagicMock, + server_types_client: ServerTypesClient, + two_server_types_response, + params, + ): + request_mock.return_value = two_server_types_response result = server_types_client.get_list(**params) - server_types_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/server_types", method="GET", params=params ) @@ -82,13 +91,19 @@ def test_get_list(self, server_types_client, two_server_types_response, params): assert server_types2.name == "cx21" @pytest.mark.parametrize("params", [{"name": "cx11"}]) - def test_get_all(self, server_types_client, two_server_types_response, params): - server_types_client._client.request.return_value = two_server_types_response + def test_get_all( + self, + request_mock: mock.MagicMock, + server_types_client: ServerTypesClient, + two_server_types_response, + params, + ): + request_mock.return_value = two_server_types_response server_types = server_types_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - server_types_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/server_types", method="GET", params=params ) @@ -105,13 +120,18 @@ def test_get_all(self, server_types_client, two_server_types_response, params): assert server_types2.id == 2 assert server_types2.name == "cx21" - def test_get_by_name(self, server_types_client, one_server_types_response): - server_types_client._client.request.return_value = one_server_types_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + server_types_client: ServerTypesClient, + one_server_types_response, + ): + request_mock.return_value = one_server_types_response server_type = server_types_client.get_by_name("cx11") params = {"name": "cx11"} - server_types_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/server_types", method="GET", params=params ) diff --git a/tests/unit/servers/test_client.py b/tests/unit/servers/test_client.py index 214de3f0..7f2cd2c1 100644 --- a/tests/unit/servers/test_client.py +++ b/tests/unit/servers/test_client.py @@ -643,15 +643,18 @@ def test_remove_from_placement_group( class TestServersClient: @pytest.fixture() - def servers_client(self): - return ServersClient(client=mock.MagicMock()) + def servers_client(self, client: Client): + return ServersClient(client) - def test_get_by_id(self, servers_client, response_simple_server): - servers_client._client.request.return_value = response_simple_server + def test_get_by_id( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_simple_server, + ): + request_mock.return_value = response_simple_server bound_server = servers_client.get_by_id(1) - servers_client._client.request.assert_called_with( - url="/servers/1", method="GET" - ) + request_mock.assert_called_with(url="/servers/1", method="GET") assert bound_server._client is servers_client assert bound_server.id == 1 assert bound_server.name == "my-server" @@ -664,12 +667,16 @@ def test_get_by_id(self, servers_client, response_simple_server): {}, ], ) - def test_get_list(self, servers_client, response_simple_servers, params): - servers_client._client.request.return_value = response_simple_servers + def test_get_list( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_simple_servers, + params, + ): + request_mock.return_value = response_simple_servers result = servers_client.get_list(**params) - servers_client._client.request.assert_called_with( - url="/servers", method="GET", params=params - ) + request_mock.assert_called_with(url="/servers", method="GET", params=params) bound_servers = result.servers assert result.meta is not None @@ -690,15 +697,19 @@ def test_get_list(self, servers_client, response_simple_servers, params): @pytest.mark.parametrize( "params", [{"name": "server1", "label_selector": "label1"}, {}] ) - def test_get_all(self, servers_client, response_simple_servers, params): - servers_client._client.request.return_value = response_simple_servers + def test_get_all( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_simple_servers, + params, + ): + request_mock.return_value = response_simple_servers bound_servers = servers_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - servers_client._client.request.assert_called_with( - url="/servers", method="GET", params=params - ) + request_mock.assert_called_with(url="/servers", method="GET", params=params) assert len(bound_servers) == 2 @@ -713,31 +724,37 @@ def test_get_all(self, servers_client, response_simple_servers, params): assert bound_server2.id == 2 assert bound_server2.name == "my-server2" - def test_get_by_name(self, servers_client, response_simple_servers): - servers_client._client.request.return_value = response_simple_servers + def test_get_by_name( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_simple_servers, + ): + request_mock.return_value = response_simple_servers bound_server = servers_client.get_by_name("my-server") params = {"name": "my-server"} - servers_client._client.request.assert_called_with( - url="/servers", method="GET", params=params - ) + request_mock.assert_called_with(url="/servers", method="GET", params=params) assert bound_server._client is servers_client assert bound_server.id == 1 assert bound_server.name == "my-server" def test_create_with_datacenter( - self, servers_client, response_create_simple_server + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_create_simple_server, ): - servers_client._client.request.return_value = response_create_simple_server + request_mock.return_value = response_create_simple_server response = servers_client.create( "my-server", server_type=ServerType(name="cx11"), image=Image(id=4711), datacenter=Datacenter(id=1), ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers", method="POST", json={ @@ -761,15 +778,20 @@ def test_create_with_datacenter( assert bound_action.id == 1 assert bound_action.command == "create_server" - def test_create_with_location(self, servers_client, response_create_simple_server): - servers_client._client.request.return_value = response_create_simple_server + def test_create_with_location( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_create_simple_server, + ): + request_mock.return_value = response_create_simple_server response = servers_client.create( "my-server", server_type=ServerType(name="cx11"), image=Image(name="ubuntu-20.04"), location=Location(name="fsn1"), ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers", method="POST", json={ @@ -793,8 +815,13 @@ def test_create_with_location(self, servers_client, response_create_simple_serve assert bound_action.id == 1 assert bound_action.command == "create_server" - def test_create_with_volumes(self, servers_client, response_create_simple_server): - servers_client._client.request.return_value = response_create_simple_server + def test_create_with_volumes( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_create_simple_server, + ): + request_mock.return_value = response_create_simple_server volumes = [Volume(id=1), BoundVolume(mock.MagicMock(), dict(id=2))] response = servers_client.create( "my-server", @@ -803,7 +830,7 @@ def test_create_with_volumes(self, servers_client, response_create_simple_server volumes=volumes, start_after_create=False, ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers", method="POST", json={ @@ -833,8 +860,13 @@ def test_create_with_volumes(self, servers_client, response_create_simple_server assert next_actions[0].id == 13 - def test_create_with_networks(self, servers_client, response_create_simple_server): - servers_client._client.request.return_value = response_create_simple_server + def test_create_with_networks( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_create_simple_server, + ): + request_mock.return_value = response_create_simple_server networks = [Network(id=1), BoundNetwork(mock.MagicMock(), dict(id=2))] response = servers_client.create( "my-server", @@ -843,7 +875,7 @@ def test_create_with_networks(self, servers_client, response_create_simple_serve networks=networks, start_after_create=False, ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers", method="POST", json={ @@ -873,8 +905,13 @@ def test_create_with_networks(self, servers_client, response_create_simple_serve assert next_actions[0].id == 13 - def test_create_with_firewalls(self, servers_client, response_create_simple_server): - servers_client._client.request.return_value = response_create_simple_server + def test_create_with_firewalls( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_create_simple_server, + ): + request_mock.return_value = response_create_simple_server firewalls = [Firewall(id=1), BoundFirewall(mock.MagicMock(), dict(id=2))] response = servers_client.create( "my-server", @@ -883,7 +920,7 @@ def test_create_with_firewalls(self, servers_client, response_create_simple_serv firewalls=firewalls, start_after_create=False, ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers", method="POST", json={ @@ -914,9 +951,12 @@ def test_create_with_firewalls(self, servers_client, response_create_simple_serv assert next_actions[0].id == 13 def test_create_with_placement_group( - self, servers_client, response_create_simple_server + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_create_simple_server, ): - servers_client._client.request.return_value = response_create_simple_server + request_mock.return_value = response_create_simple_server placement_group = PlacementGroup(id=1) response = servers_client.create( "my-server", @@ -926,7 +966,7 @@ def test_create_with_placement_group( placement_group=placement_group, ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers", method="POST", json={ @@ -959,10 +999,16 @@ def test_create_with_placement_group( @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_get_actions_list(self, servers_client, server, response_get_actions): - servers_client._client.request.return_value = response_get_actions + def test_get_actions_list( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = servers_client.get_actions_list(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions", method="GET", params={} ) @@ -979,10 +1025,16 @@ def test_get_actions_list(self, servers_client, server, response_get_actions): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_update(self, servers_client, server, response_update_server): - servers_client._client.request.return_value = response_update_server + def test_update( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + response_update_server, + ): + request_mock.return_value = response_update_server server = servers_client.update(server, name="new-name", labels={}) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1", method="PUT", json={"name": "new-name", "labels": {}} ) @@ -992,12 +1044,16 @@ def test_update(self, servers_client, server, response_update_server): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.delete(server) - servers_client._client.request.assert_called_with( - url="/servers/1", method="DELETE" - ) + request_mock.assert_called_with(url="/servers/1", method="DELETE") assert action.id == 1 assert action.progress == 0 @@ -1005,10 +1061,16 @@ def test_delete(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_power_off(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_power_off( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.power_off(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/poweroff", method="POST" ) @@ -1018,12 +1080,16 @@ def test_power_off(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_power_on(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_power_on( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.power_on(server) - servers_client._client.request.assert_called_with( - url="/servers/1/actions/poweron", method="POST" - ) + request_mock.assert_called_with(url="/servers/1/actions/poweron", method="POST") assert action.id == 1 assert action.progress == 0 @@ -1031,12 +1097,16 @@ def test_power_on(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_reboot(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_reboot( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.reboot(server) - servers_client._client.request.assert_called_with( - url="/servers/1/actions/reboot", method="POST" - ) + request_mock.assert_called_with(url="/servers/1/actions/reboot", method="POST") assert action.id == 1 assert action.progress == 0 @@ -1044,12 +1114,16 @@ def test_reboot(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_reset(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_reset( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.reset(server) - servers_client._client.request.assert_called_with( - url="/servers/1/actions/reset", method="POST" - ) + request_mock.assert_called_with(url="/servers/1/actions/reset", method="POST") assert action.id == 1 assert action.progress == 0 @@ -1057,10 +1131,16 @@ def test_reset(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_shutdown(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_shutdown( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.shutdown(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/shutdown", method="POST" ) @@ -1071,11 +1151,15 @@ def test_shutdown(self, servers_client, server, generic_action): "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) def test_reset_password( - self, servers_client, server, response_server_reset_password + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + response_server_reset_password, ): - servers_client._client.request.return_value = response_server_reset_password + request_mock.return_value = response_server_reset_password response = servers_client.reset_password(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/reset_password", method="POST" ) @@ -1087,13 +1171,17 @@ def test_reset_password( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) def test_change_type_with_server_type_name( - self, servers_client, server, generic_action + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, ): - servers_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = servers_client.change_type( server, ServerType(name="cx11"), upgrade_disk=True ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/change_type", method="POST", json={"server_type": "cx11", "upgrade_disk": True}, @@ -1106,11 +1194,15 @@ def test_change_type_with_server_type_name( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) def test_change_type_with_server_type_id( - self, servers_client, server, generic_action + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, ): - servers_client._client.request.return_value = generic_action + request_mock.return_value = generic_action action = servers_client.change_type(server, ServerType(id=1), upgrade_disk=True) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/change_type", method="POST", json={"server_type": 1, "upgrade_disk": True}, @@ -1122,19 +1214,30 @@ def test_change_type_with_server_type_id( @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_change_type_with_blank_server_type(self, servers_client, server): + def test_change_type_with_blank_server_type( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + ): with pytest.raises(ValueError) as e: servers_client.change_type(server, ServerType(), upgrade_disk=True) assert str(e.value) == "id or name must be set" - servers_client._client.request.assert_not_called() + request_mock.assert_not_called() @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_enable_rescue(self, servers_client, server, response_server_enable_rescue): - servers_client._client.request.return_value = response_server_enable_rescue + def test_enable_rescue( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + response_server_enable_rescue, + ): + request_mock.return_value = response_server_enable_rescue response = servers_client.enable_rescue(server, "linux64", [2323]) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/enable_rescue", method="POST", json={"type": "linux64", "ssh_keys": [2323]}, @@ -1147,10 +1250,16 @@ def test_enable_rescue(self, servers_client, server, response_server_enable_resc @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_disable_rescue(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_disable_rescue( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.disable_rescue(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/disable_rescue", method="POST" ) @@ -1160,12 +1269,18 @@ def test_disable_rescue(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_create_image(self, servers_client, server, response_server_create_image): - servers_client._client.request.return_value = response_server_create_image + def test_create_image( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + response_server_create_image, + ): + request_mock.return_value = response_server_create_image response = servers_client.create_image( server, description="my image", type="snapshot", labels={"key": "value"} ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/create_image", method="POST", json={ @@ -1182,14 +1297,20 @@ def test_create_image(self, servers_client, server, response_server_create_image @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_rebuild(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_rebuild( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action response = servers_client.rebuild( server, Image(name="ubuntu-20.04"), return_response=True, ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/rebuild", method="POST", json={"image": "ubuntu-20.04"}, @@ -1202,10 +1323,16 @@ def test_rebuild(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_enable_backup(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_enable_backup( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.enable_backup(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/enable_backup", method="POST" ) @@ -1215,10 +1342,16 @@ def test_enable_backup(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_disable_backup(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_disable_backup( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.disable_backup(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/disable_backup", method="POST" ) @@ -1228,12 +1361,18 @@ def test_disable_backup(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_attach_iso(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_attach_iso( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.attach_iso( server, Iso(name="FreeBSD-11.0-RELEASE-amd64-dvd1") ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/attach_iso", method="POST", json={"iso": "FreeBSD-11.0-RELEASE-amd64-dvd1"}, @@ -1245,10 +1384,16 @@ def test_attach_iso(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_detach_iso(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_detach_iso( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.detach_iso(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/detach_iso", method="POST" ) @@ -1258,10 +1403,16 @@ def test_detach_iso(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_change_dns_ptr(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_change_dns_ptr( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.change_dns_ptr(server, "1.2.3.4", "example.com") - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/change_dns_ptr", method="POST", json={"ip": "1.2.3.4", "dns_ptr": "example.com"}, @@ -1273,10 +1424,16 @@ def test_change_dns_ptr(self, servers_client, server, generic_action): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_change_protection(self, servers_client, server, generic_action): - servers_client._client.request.return_value = generic_action + def test_change_protection( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + generic_action, + ): + request_mock.return_value = generic_action action = servers_client.change_protection(server, True, True) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/change_protection", method="POST", json={"delete": True, "rebuild": True}, @@ -1289,11 +1446,15 @@ def test_change_protection(self, servers_client, server, generic_action): "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) def test_request_console( - self, servers_client, server, response_server_request_console + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + response_server_request_console, ): - servers_client._client.request.return_value = response_server_request_console + request_mock.return_value = response_server_request_console response = servers_client.request_console(server) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/request_console", method="POST" ) @@ -1312,13 +1473,18 @@ def test_request_console( "network", [Network(id=4711), BoundNetwork(mock.MagicMock(), dict(id=4711))] ) def test_attach_to_network( - self, servers_client, server, network, response_attach_to_network + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + network, + response_attach_to_network, ): - servers_client._client.request.return_value = response_attach_to_network + request_mock.return_value = response_attach_to_network action = servers_client.attach_to_network( server, network, "10.0.1.1", ["10.0.1.2", "10.0.1.3"] ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/attach_to_network", method="POST", json={ @@ -1339,11 +1505,16 @@ def test_attach_to_network( "network", [Network(id=4711), BoundNetwork(mock.MagicMock(), dict(id=4711))] ) def test_detach_from_network( - self, servers_client, server, network, response_detach_from_network + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + network, + response_detach_from_network, ): - servers_client._client.request.return_value = response_detach_from_network + request_mock.return_value = response_detach_from_network action = servers_client.detach_from_network(server, network) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/detach_from_network", method="POST", json={"network": 4711}, @@ -1360,13 +1531,18 @@ def test_detach_from_network( "network", [Network(id=4711), BoundNetwork(mock.MagicMock(), dict(id=4711))] ) def test_change_alias_ips( - self, servers_client, server, network, response_change_alias_ips + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + server, + network, + response_change_alias_ips, ): - servers_client._client.request.return_value = response_change_alias_ips + request_mock.return_value = response_change_alias_ips action = servers_client.change_alias_ips( server, network, ["10.0.1.2", "10.0.1.3"] ) - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/1/actions/change_alias_ips", method="POST", json={"network": 4711, "alias_ips": ["10.0.1.2", "10.0.1.3"]}, @@ -1376,26 +1552,32 @@ def test_change_alias_ips( assert action.progress == 0 assert action.command == "change_alias_ips" - def test_actions_get_by_id(self, servers_client, response_get_actions): - servers_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = servers_client.actions.get_by_id(13) - servers_client._client.request.assert_called_with( - url="/servers/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/servers/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == servers_client._client.actions assert action.id == 13 assert action.command == "start_server" - def test_actions_get_list(self, servers_client, response_get_actions): - servers_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = servers_client.actions.get_list() - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/actions", method="GET", params={}, @@ -1410,11 +1592,16 @@ def test_actions_get_list(self, servers_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "start_server" - def test_actions_get_all(self, servers_client, response_get_actions): - servers_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + servers_client: ServersClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = servers_client.actions.get_all() - servers_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/servers/actions", method="GET", params={"page": 1, "per_page": 50}, diff --git a/tests/unit/ssh_keys/test_client.py b/tests/unit/ssh_keys/test_client.py index e11f5205..5bc90aee 100644 --- a/tests/unit/ssh_keys/test_client.py +++ b/tests/unit/ssh_keys/test_client.py @@ -56,15 +56,18 @@ def test_delete( class TestSSHKeysClient: @pytest.fixture() - def ssh_keys_client(self): - return SSHKeysClient(client=mock.MagicMock()) + def ssh_keys_client(self, client: Client): + return SSHKeysClient(client) - def test_get_by_id(self, ssh_keys_client, ssh_key_response): - ssh_keys_client._client.request.return_value = ssh_key_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + ssh_key_response, + ): + request_mock.return_value = ssh_key_response ssh_key = ssh_keys_client.get_by_id(1) - ssh_keys_client._client.request.assert_called_with( - url="/ssh_keys/1", method="GET" - ) + request_mock.assert_called_with(url="/ssh_keys/1", method="GET") assert ssh_key._client is ssh_keys_client assert ssh_key.id == 2323 assert ssh_key.name == "My ssh key" @@ -83,12 +86,16 @@ def test_get_by_id(self, ssh_keys_client, ssh_key_response): {}, ], ) - def test_get_list(self, ssh_keys_client, two_ssh_keys_response, params): - ssh_keys_client._client.request.return_value = two_ssh_keys_response + def test_get_list( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + two_ssh_keys_response, + params, + ): + request_mock.return_value = two_ssh_keys_response result = ssh_keys_client.get_list(**params) - ssh_keys_client._client.request.assert_called_with( - url="/ssh_keys", method="GET", params=params - ) + request_mock.assert_called_with(url="/ssh_keys", method="GET", params=params) ssh_keys = result.ssh_keys assert len(ssh_keys) == 2 @@ -107,14 +114,18 @@ def test_get_list(self, ssh_keys_client, two_ssh_keys_response, params): @pytest.mark.parametrize( "params", [{"name": "My ssh key", "label_selector": "label1"}, {}] ) - def test_get_all(self, ssh_keys_client, two_ssh_keys_response, params): - ssh_keys_client._client.request.return_value = two_ssh_keys_response + def test_get_all( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + two_ssh_keys_response, + params, + ): + request_mock.return_value = two_ssh_keys_response ssh_keys = ssh_keys_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - ssh_keys_client._client.request.assert_called_with( - url="/ssh_keys", method="GET", params=params - ) + request_mock.assert_called_with(url="/ssh_keys", method="GET", params=params) assert len(ssh_keys) == 2 @@ -129,40 +140,51 @@ def test_get_all(self, ssh_keys_client, two_ssh_keys_response, params): assert ssh_keys2.id == 2324 assert ssh_keys2.name == "SSH-Key" - def test_get_by_name(self, ssh_keys_client, one_ssh_keys_response): - ssh_keys_client._client.request.return_value = one_ssh_keys_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + one_ssh_keys_response, + ): + request_mock.return_value = one_ssh_keys_response ssh_keys = ssh_keys_client.get_by_name("SSH-Key") params = {"name": "SSH-Key"} - ssh_keys_client._client.request.assert_called_with( - url="/ssh_keys", method="GET", params=params - ) + request_mock.assert_called_with(url="/ssh_keys", method="GET", params=params) assert ssh_keys._client is ssh_keys_client assert ssh_keys.id == 2323 assert ssh_keys.name == "SSH-Key" - def test_get_by_fingerprint(self, ssh_keys_client, one_ssh_keys_response): - ssh_keys_client._client.request.return_value = one_ssh_keys_response + def test_get_by_fingerprint( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + one_ssh_keys_response, + ): + request_mock.return_value = one_ssh_keys_response ssh_keys = ssh_keys_client.get_by_fingerprint( "b7:2f:30:a0:2f:6c:58:6c:21:04:58:61:ba:06:3b:2f" ) params = {"fingerprint": "b7:2f:30:a0:2f:6c:58:6c:21:04:58:61:ba:06:3b:2f"} - ssh_keys_client._client.request.assert_called_with( - url="/ssh_keys", method="GET", params=params - ) + request_mock.assert_called_with(url="/ssh_keys", method="GET", params=params) assert ssh_keys._client is ssh_keys_client assert ssh_keys.id == 2323 assert ssh_keys.name == "SSH-Key" - def test_create(self, ssh_keys_client, ssh_key_response): - ssh_keys_client._client.request.return_value = ssh_key_response + def test_create( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + ssh_key_response, + ): + request_mock.return_value = ssh_key_response ssh_key = ssh_keys_client.create( name="My ssh key", public_key="ssh-rsa AAAjjk76kgf...Xt" ) - ssh_keys_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/ssh_keys", method="POST", json={"name": "My ssh key", "public_key": "ssh-rsa AAAjjk76kgf...Xt"}, @@ -174,10 +196,16 @@ def test_create(self, ssh_keys_client, ssh_key_response): @pytest.mark.parametrize( "ssh_key", [SSHKey(id=1), BoundSSHKey(mock.MagicMock(), dict(id=1))] ) - def test_update(self, ssh_keys_client, ssh_key, response_update_ssh_key): - ssh_keys_client._client.request.return_value = response_update_ssh_key + def test_update( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + ssh_key, + response_update_ssh_key, + ): + request_mock.return_value = response_update_ssh_key ssh_key = ssh_keys_client.update(ssh_key, name="New name") - ssh_keys_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/ssh_keys/1", method="PUT", json={"name": "New name"} ) @@ -187,11 +215,15 @@ def test_update(self, ssh_keys_client, ssh_key, response_update_ssh_key): @pytest.mark.parametrize( "ssh_key", [SSHKey(id=1), BoundSSHKey(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, ssh_keys_client, ssh_key, generic_action): - ssh_keys_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + ssh_keys_client: SSHKeysClient, + ssh_key, + generic_action, + ): + request_mock.return_value = generic_action delete_success = ssh_keys_client.delete(ssh_key) - ssh_keys_client._client.request.assert_called_with( - url="/ssh_keys/1", method="DELETE" - ) + request_mock.assert_called_with(url="/ssh_keys/1", method="DELETE") assert delete_success is True diff --git a/tests/unit/volumes/test_client.py b/tests/unit/volumes/test_client.py index 5662d23e..3f5865ab 100644 --- a/tests/unit/volumes/test_client.py +++ b/tests/unit/volumes/test_client.py @@ -174,15 +174,18 @@ def test_resize( class TestVolumesClient: @pytest.fixture() - def volumes_client(self): - return VolumesClient(client=mock.MagicMock()) + def volumes_client(self, client: Client): + return VolumesClient(client) - def test_get_by_id(self, volumes_client, volume_response): - volumes_client._client.request.return_value = volume_response + def test_get_by_id( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume_response, + ): + request_mock.return_value = volume_response bound_volume = volumes_client.get_by_id(1) - volumes_client._client.request.assert_called_with( - url="/volumes/1", method="GET" - ) + request_mock.assert_called_with(url="/volumes/1", method="GET") assert bound_volume._client is volumes_client assert bound_volume.id == 1 assert bound_volume.name == "database-storage" @@ -191,12 +194,16 @@ def test_get_by_id(self, volumes_client, volume_response): "params", [{"label_selector": "label1", "page": 1, "per_page": 10}, {"name": ""}, {}], ) - def test_get_list(self, volumes_client, two_volumes_response, params): - volumes_client._client.request.return_value = two_volumes_response + def test_get_list( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + two_volumes_response, + params, + ): + request_mock.return_value = two_volumes_response result = volumes_client.get_list(**params) - volumes_client._client.request.assert_called_with( - url="/volumes", method="GET", params=params - ) + request_mock.assert_called_with(url="/volumes", method="GET", params=params) bound_volumes = result.volumes assert result.meta is not None @@ -215,15 +222,19 @@ def test_get_list(self, volumes_client, two_volumes_response, params): assert bound_volume2.name == "vault-storage" @pytest.mark.parametrize("params", [{"label_selector": "label1"}]) - def test_get_all(self, volumes_client, two_volumes_response, params): - volumes_client._client.request.return_value = two_volumes_response + def test_get_all( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + two_volumes_response, + params, + ): + request_mock.return_value = two_volumes_response bound_volumes = volumes_client.get_all(**params) params.update({"page": 1, "per_page": 50}) - volumes_client._client.request.assert_called_with( - url="/volumes", method="GET", params=params - ) + request_mock.assert_called_with(url="/volumes", method="GET", params=params) assert len(bound_volumes) == 2 @@ -238,22 +249,30 @@ def test_get_all(self, volumes_client, two_volumes_response, params): assert bound_volume2.id == 2 assert bound_volume2.name == "vault-storage" - def test_get_by_name(self, volumes_client, one_volumes_response): - volumes_client._client.request.return_value = one_volumes_response + def test_get_by_name( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + one_volumes_response, + ): + request_mock.return_value = one_volumes_response bound_volume = volumes_client.get_by_name("database-storage") params = {"name": "database-storage"} - volumes_client._client.request.assert_called_with( - url="/volumes", method="GET", params=params - ) + request_mock.assert_called_with(url="/volumes", method="GET", params=params) assert bound_volume._client is volumes_client assert bound_volume.id == 1 assert bound_volume.name == "database-storage" - def test_create_with_location(self, volumes_client, volume_create_response): - volumes_client._client.request.return_value = volume_create_response + def test_create_with_location( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume_create_response, + ): + request_mock.return_value = volume_create_response response = volumes_client.create( 100, "database-storage", @@ -261,7 +280,7 @@ def test_create_with_location(self, volumes_client, volume_create_response): automount=False, format="xfs", ) - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes", method="POST", json={ @@ -287,12 +306,18 @@ def test_create_with_location(self, volumes_client, volume_create_response): @pytest.mark.parametrize( "server", [Server(id=1), BoundServer(mock.MagicMock(), dict(id=1))] ) - def test_create_with_server(self, volumes_client, server, volume_create_response): - volumes_client._client.request.return_value = volume_create_response + def test_create_with_server( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + server, + volume_create_response, + ): + request_mock.return_value = volume_create_response volumes_client.create( 100, "database-storage", server=server, automount=False, format="xfs" ) - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes", method="POST", json={ @@ -304,34 +329,48 @@ def test_create_with_server(self, volumes_client, server, volume_create_response }, ) - def test_create_negative_size(self, volumes_client): + def test_create_negative_size( + self, + request_mock: mock.MagicMock, + volumes_client, + ): with pytest.raises(ValueError) as e: volumes_client.create( -100, "database-storage", location=Location(name="location") ) assert str(e.value) == "size must be greater than 0" - volumes_client._client.request.assert_not_called() + request_mock.assert_not_called() @pytest.mark.parametrize( "location,server", [(None, None), ("location", Server(id=1))] ) def test_create_wrong_location_server_combination( - self, volumes_client, location, server + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + location, + server, ): with pytest.raises(ValueError) as e: volumes_client.create( 100, "database-storage", location=location, server=server ) assert str(e.value) == "only one of server or location must be provided" - volumes_client._client.request.assert_not_called() + request_mock.assert_not_called() @pytest.mark.parametrize( "volume", [Volume(id=1), BoundVolume(mock.MagicMock(), dict(id=1))] ) - def test_get_actions_list(self, volumes_client, volume, response_get_actions): - volumes_client._client.request.return_value = response_get_actions + def test_get_actions_list( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = volumes_client.get_actions_list(volume, sort="id") - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/1/actions", method="GET", params={"sort": "id"} ) @@ -346,10 +385,16 @@ def test_get_actions_list(self, volumes_client, volume, response_get_actions): @pytest.mark.parametrize( "volume", [Volume(id=1), BoundVolume(mock.MagicMock(), dict(id=1))] ) - def test_update(self, volumes_client, volume, response_update_volume): - volumes_client._client.request.return_value = response_update_volume + def test_update( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume, + response_update_volume, + ): + request_mock.return_value = response_update_volume volume = volumes_client.update(volume, name="new-name") - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/1", method="PUT", json={"name": "new-name"} ) @@ -359,10 +404,16 @@ def test_update(self, volumes_client, volume, response_update_volume): @pytest.mark.parametrize( "volume", [Volume(id=1), BoundVolume(mock.MagicMock(), dict(id=1))] ) - def test_change_protection(self, volumes_client, volume, generic_action): - volumes_client._client.request.return_value = generic_action + def test_change_protection( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume, + generic_action, + ): + request_mock.return_value = generic_action action = volumes_client.change_protection(volume, True) - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/1/actions/change_protection", method="POST", json={"delete": True}, @@ -374,12 +425,16 @@ def test_change_protection(self, volumes_client, volume, generic_action): @pytest.mark.parametrize( "volume", [Volume(id=1), BoundVolume(mock.MagicMock(), dict(id=1))] ) - def test_delete(self, volumes_client, volume, generic_action): - volumes_client._client.request.return_value = generic_action + def test_delete( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume, + generic_action, + ): + request_mock.return_value = generic_action delete_success = volumes_client.delete(volume) - volumes_client._client.request.assert_called_with( - url="/volumes/1", method="DELETE" - ) + request_mock.assert_called_with(url="/volumes/1", method="DELETE") assert delete_success is True @@ -393,10 +448,17 @@ def test_delete(self, volumes_client, volume, generic_action): ), ], ) - def test_attach(self, volumes_client, server, volume, generic_action): - volumes_client._client.request.return_value = generic_action + def test_attach( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + server, + volume, + generic_action, + ): + request_mock.return_value = generic_action action = volumes_client.attach(volume, server) - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/12/actions/attach", method="POST", json={"server": 1} ) assert action.id == 1 @@ -405,47 +467,63 @@ def test_attach(self, volumes_client, server, volume, generic_action): @pytest.mark.parametrize( "volume", [Volume(id=12), BoundVolume(mock.MagicMock(), dict(id=12))] ) - def test_detach(self, volumes_client, volume, generic_action): - volumes_client._client.request.return_value = generic_action + def test_detach( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume, + generic_action, + ): + request_mock.return_value = generic_action action = volumes_client.detach(volume) - volumes_client._client.request.assert_called_with( - url="/volumes/12/actions/detach", method="POST" - ) + request_mock.assert_called_with(url="/volumes/12/actions/detach", method="POST") assert action.id == 1 assert action.progress == 0 @pytest.mark.parametrize( "volume", [Volume(id=12), BoundVolume(mock.MagicMock(), dict(id=12))] ) - def test_resize(self, volumes_client, volume, generic_action): - volumes_client._client.request.return_value = generic_action + def test_resize( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + volume, + generic_action, + ): + request_mock.return_value = generic_action action = volumes_client.resize(volume, 50) - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/12/actions/resize", method="POST", json={"size": 50} ) assert action.id == 1 assert action.progress == 0 - def test_actions_get_by_id(self, volumes_client, response_get_actions): - volumes_client._client.request.return_value = { - "action": response_get_actions["actions"][0] - } + def test_actions_get_by_id( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + response_get_actions, + ): + request_mock.return_value = {"action": response_get_actions["actions"][0]} action = volumes_client.actions.get_by_id(13) - volumes_client._client.request.assert_called_with( - url="/volumes/actions/13", method="GET" - ) + request_mock.assert_called_with(url="/volumes/actions/13", method="GET") assert isinstance(action, BoundAction) assert action._client == volumes_client._client.actions assert action.id == 13 assert action.command == "attach_volume" - def test_actions_get_list(self, volumes_client, response_get_actions): - volumes_client._client.request.return_value = response_get_actions + def test_actions_get_list( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions result = volumes_client.actions.get_list() - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/actions", method="GET", params={}, @@ -460,11 +538,16 @@ def test_actions_get_list(self, volumes_client, response_get_actions): assert actions[0].id == 13 assert actions[0].command == "attach_volume" - def test_actions_get_all(self, volumes_client, response_get_actions): - volumes_client._client.request.return_value = response_get_actions + def test_actions_get_all( + self, + request_mock: mock.MagicMock, + volumes_client: VolumesClient, + response_get_actions, + ): + request_mock.return_value = response_get_actions actions = volumes_client.actions.get_all() - volumes_client._client.request.assert_called_with( + request_mock.assert_called_with( url="/volumes/actions", method="GET", params={"page": 1, "per_page": 50},