fix typing and typecheck

Author: Laure-di

scaleway/scaleway/instance/tests/test_instance_sdk.py renamed to scaleway/scaleway/instance/v1/tests/__init__.py

@@ -0,0 +1,47 @@
+import uuid
+
+import pytest
+
+from scaleway.block.v1 import BlockV1API
+from scaleway.instance.v1 import InstanceV1API, VolumeServerTemplate, VolumeVolumeType, BootType
+from scaleway_core.client import Client
+from vcr_config import scw_vcr
+
+server_name = f"test-sdk-python-{uuid.uuid4().hex[:6]}"
+max_retry = 10
+interval = 0.01
+volume_size = 10000000000
+commercial_type = "DEV1-S"
+zone = "fr-par-1"
+image_id = "c00ae53c-1e29-4087-a384-47f3c5c1cd84"
+
+@pytest.fixture(scope="module")
+@scw_vcr.use_cassette
+def instance_api():
+    client = Client.from_config_file_and_env()
+    api = InstanceV1API(client)
+    return api, client.default_project_id, zone
+
+@pytest.fixture(scope="module")
+@scw_vcr.use_cassette
+def block_api():
+    client = Client.from_config_file_and_env()
+    api = BlockV1API(client)
+    return api, client.default_project_id, zone
+
+@scw_vcr.use_cassette
+def test_instance_create(instance_api):
+    api, project_id, zone = instance_api
+    volumes = {
+        "0": VolumeServerTemplate(
+            volume_type=VolumeVolumeType.L_SSD,
+            size=volume_size,
+            boot=False,
+        )
+    }
+    instance = api.create_instance(project_id=project_id, zone=zone, name=server_name, dynamic_ip_required=False, volume=volumes, protected=False, boot_type=BootType.LOCAL, image=image_id)
+    assert instance.name == server_name
+    assert instance.project_id == project_id
+    assert instance.zone == zone
+    assert instance.id is not None
+

scaleway/scaleway/instance/v1/tests/test_instance_sdk.py

@@ -1,6 +1,8 @@
+from typing import Generator
+
 import pytest
 
-from scaleway.vpc.v2 import VpcV2API
+from scaleway.vpc.v2 import VpcV2API, VPC, PrivateNetwork, ListVPCsResponse, ListPrivateNetworksResponse
 from scaleway_core.api import ScalewayException
 from scaleway_core.client import Client
 from scaleway_core.utils import random_name
@@ -13,16 +15,16 @@
 
 
 @pytest.fixture(scope="module")
-@scw_vcr.use_cassette
-def vpc_api():
+@scw_vcr.use_cassette # type: ignore[misc]
+def vpc_api() -> tuple[VpcV2API, str | None, str]:
         client = Client.from_config_file_and_env()
         api = VpcV2API(client)
         return api, client.default_project_id, region
 
 
 @pytest.fixture(scope="module")
-@scw_vcr.use_cassette
-def vpc(vpc_api):
+@scw_vcr.use_cassette # type: ignore[misc]
+def vpc(vpc_api: tuple[VpcV2API, str, str]) -> Generator[VPC, None, None]:
     api, project_id, region = vpc_api
     vpc = api.create_vpc(
         enable_routing=True,
@@ -35,19 +37,19 @@ def vpc(vpc_api):
 
 
 @pytest.fixture
-@scw_vcr.use_cassette
-def private_networks_to_cleanup(vpc_api):
+@scw_vcr.use_cassette # type: ignore[misc]
+def private_networks_to_cleanup(vpc_api: tuple[VpcV2API, str, str]) -> Generator[list[PrivateNetwork], None, None]:
     api, _, _ = vpc_api
-    items = []
+    items: list[PrivateNetwork] = []
     yield items
     for pn in items:
         api.delete_private_network(private_network_id=pn.id)
 
 
-@scw_vcr.use_cassette
-def test_vpc_delete(vpc_api):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_vpc_delete(vpc_api: tuple[VpcV2API, str, str]) -> None:
     api, project_id, region = vpc_api
-    vpc = api.create_vpc(
+    vpc: VPC = api.create_vpc(
         enable_routing=True,
         region=region,
         project_id=project_id,
@@ -63,19 +65,19 @@ def test_vpc_delete(vpc_api):
         api.get_vpc(vpc_id=vpc.id)
 
 
-@scw_vcr.use_cassette()
-def test_vpc_list(vpc_api):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_vpc_list(vpc_api: tuple[VpcV2API, str, str]) -> None:
     api, _, region = vpc_api
-    vpcs = api.list_vp_cs(region=region)
+    vpcs: ListVPCsResponse = api.list_vp_cs(region=region)
     assert isinstance(vpcs.vpcs, list)
     assert vpcs.total_count >= created_vpc_count
 
 
-@scw_vcr.use_cassette()
-def test_private_network_create(vpc_api, vpc, private_networks_to_cleanup):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_private_network_create(vpc_api: tuple[VpcV2API, str, str], vpc: VPC , private_networks_to_cleanup: list[PrivateNetwork]) -> None:
     api, project_id, _ = vpc_api
     for i in range(created_pn_count):
-        pn = api.create_private_network(
+        pn: PrivateNetwork = api.create_private_network(
             vpc_id=vpc.id,
             default_route_propagation_enabled=True,
             project_id=project_id,
@@ -85,32 +87,32 @@ def test_private_network_create(vpc_api, vpc, private_networks_to_cleanup):
         assert pn.vpc_id == vpc.id
 
 
-@scw_vcr.use_cassette()
-def test_private_network_list(vpc_api):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_private_network_list(vpc_api: tuple[VpcV2API, str, str]) -> None:
     api, _, region = vpc_api
-    networks = api.list_private_networks(region=region)
+    networks: ListPrivateNetworksResponse = api.list_private_networks(region=region)
     assert isinstance(networks.private_networks, list)
     assert networks.total_count >= created_pn_count
 
 
-@scw_vcr.use_cassette()
-def test_vpc_get(vpc_api, vpc):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_vpc_get(vpc_api: tuple[VpcV2API, str, str], vpc: VPC) -> None:
     api, _, region = vpc_api
-    fetched = api.get_vpc(vpc_id=vpc.id, region=region)
-    assert fetched is not None
-    assert fetched.id == vpc.id
+    fetched_vpc: VPC = api.get_vpc(vpc_id=vpc.id, region=region)
+    assert fetched_vpc is not None
+    assert fetched_vpc.id == vpc.id
 
 
-@scw_vcr.use_cassette()
-def test_vpc_update(vpc_api, vpc):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_vpc_update(vpc_api: tuple[VpcV2API, str, str], vpc: VPC) -> None:
     api, _, _ = vpc_api
     updated = api.update_vpc(vpc_id=vpc.id, tags=tags)
     assert updated.tags == tags
     assert updated.id == vpc.id
 
 
-@scw_vcr.use_cassette()
-def test_vpc_list_all(vpc_api):
+@scw_vcr.use_cassette # type: ignore[misc]
+def test_vpc_list_all(vpc_api: tuple[VpcV2API, str, str]) -> None:
     api, _, _ = vpc_api
     vpcs = api.list_vp_cs_all()
     assert isinstance(vpcs, list)

scaleway/scaleway/vpc/v2/tests/test_vpc_sdk.py

@@ -1,17 +1,16 @@
-import logging
 import os
-from typing import Optional
+from pathlib import Path
 
 import vcr
 import inspect
 
 PYTHON_UPDATE_CASSETTE = os.getenv("PYTHON_UPDATE_CASSETTE", "false").lower() in ("1", "true", "yes")
 
 def func_path(function):
-    path = os.path.join(os.path.dirname(inspect.getfile(function)), "cassettes")
-    os.makedirs(path, exist_ok=True)
+    path = Path(Path(inspect.getfile(function)).parent, "cassettes")
+    Path.mkdir(path, exist_ok=True)
     filename = function.__name__ + ".cassette.yaml"
-    return os.path.join(path, filename)
+    return Path(path, filename)
 
 scw_vcr = vcr.VCR(
     record_mode="all" if PYTHON_UPDATE_CASSETTE else "none",