Merge ~adam-collard/maas-ci/+git/system-tests:strict-mypy into ~maas-committers/maas-ci/+git/system-tests:master

[Adam Collard]

Add strict mypy validation.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b strict-mypy lp:~adam-collard/maas-ci/+git/system-tests into -b master lp:~maas-committers/maas-ci/+git/system-tests

STATUS: SUCCESS
COMMIT: a91b80b938d188ca9c0eab2bd2b6d22b5b728540

review: Approve

[Alberto Donato (ack)]

+1

review: Approve

diff --git a/pyproject.toml b/pyproject.toml
index 0c84d1d..cf33498 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -13,8 +13,6 @@ log_file_date_format = "%Y-%m-%d %H:%M:%S"
 
 
 [tool.mypy]
-disallow_untyped_calls = true
-disallow_untyped_defs = true
-warn_unused_configs = true
 install_types = true
 non_interactive = true
+strict = true
diff --git a/systemtests/api.py b/systemtests/api.py
index 4aac548..a82fde4 100644
--- a/systemtests/api.py
+++ b/systemtests/api.py
@@ -29,10 +29,10 @@ class MAASAPIClient:
         self.pull_file = partial(lxd.pull_file, maas_container)
         self.push_file = partial(lxd.push_file, maas_container)
 
-    def execute(self, cmd: list[str]) -> CompletedProcess:
+    def execute(self, cmd: list[str]) -> CompletedProcess[str]:
         return self.lxd.execute(self.maas_container, ["maas"] + cmd)
 
-    def log_in(self, session: str, token: str) -> CompletedProcess:
+    def log_in(self, session: str, token: str) -> CompletedProcess[str]:
         return self.execute(["login", session, self.url, token])
 
 
@@ -44,7 +44,7 @@ class AuthenticatedAPIClient:
     def execute(
         self,
         cmd: list[str],
-        extra_params: dict[str, str] = None,
+        extra_params: Optional[dict[str, str]] = None,
         json_output: bool = True,
     ) -> Any:
         if extra_params:
@@ -52,31 +52,47 @@ class AuthenticatedAPIClient:
         result = self.api_client.execute([self.session] + cmd)
         return json.loads(result.stdout) if json_output else result.stdout
 
-    def list_subnets(self) -> list[dict]:
-        return self.execute(["subnets", "read"])
+    def list_subnets(self) -> list[dict[str, Any]]:
+        subnets: list[dict[str, Any]] = self.execute(["subnets", "read"])
+        return subnets
 
-    def create_subnet(self, name: str, cidr: str) -> dict:
-        return self.execute(["subnets", "create", "name=" + name, "cidr=" + cidr])
+    def create_subnet(self, name: str, cidr: str) -> dict[str, Any]:
+        subnet: dict[str, Any] = self.execute(
+            ["subnets", "create", "name=" + name, "cidr=" + cidr]
+        )
+        return subnet
 
     def delete_subnet(self, name: str) -> str:
-        return self.execute(["subnet", "delete", name], json_output=False)
+        result: str = self.execute(["subnet", "delete", name], json_output=False)
+        return result
 
-    def list_rack_controllers(self) -> list[dict]:
-        return self.execute(["rack-controllers", "read"])
+    def list_rack_controllers(self) -> list[dict[str, Any]]:
+        rack_controllers: list[dict[str, Any]] = self.execute(
+            ["rack-controllers", "read"]
+        )
+        return rack_controllers
 
-    def list_ip_ranges(self) -> list[dict]:
-        return self.execute(["ipranges", "read"])
+    def list_ip_ranges(self) -> list[dict[str, Any]]:
+        ip_ranges: list[dict[str, Any]] = self.execute(["ipranges", "read"])
+        return ip_ranges
 
     def delete_ip_range(self, range_id: Union[str, int]) -> str:
-        return self.execute(["iprange", "delete", str(range_id)], json_output=False)
+        result: str = self.execute(
+            ["iprange", "delete", str(range_id)], json_output=False
+        )
+        return result
 
-    def create_ip_range(self, start: str, end: str, range_type: str) -> dict:
-        return self.execute(
+    def create_ip_range(self, start: str, end: str, range_type: str) -> dict[str, Any]:
+        ip_range: dict[str, Any] = self.execute(
             ["ipranges", "create", "type=dynamic", f"start_ip={start}", f"end_ip={end}"]
         )
+        return ip_range
 
-    def enable_dhcp(self, fabric: str, vlan: str, primary_rack: dict[str, str]) -> dict:
-        return self.execute(
+    def enable_dhcp(
+        self, fabric: str, vlan: str, primary_rack: dict[str, str]
+    ) -> dict[str, Any]:
+
+        vlan_obj: dict[str, Any] = self.execute(
             [
                 "vlan",
                 "update",
@@ -86,9 +102,13 @@ class AuthenticatedAPIClient:
                 f"primary_rack={primary_rack['system_id']}",
             ]
         )
+        return vlan_obj
 
-    def disable_dhcp(self, fabric: str, vlan: str) -> Any:
-        return self.execute(["vlan", "update", fabric, vlan, "dhcp_on=False"])
+    def disable_dhcp(self, fabric: str, vlan: str) -> dict[str, Any]:
+        vlan_obj: dict[str, Any] = self.execute(
+            ["vlan", "update", fabric, vlan, "dhcp_on=False"]
+        )
+        return vlan_obj
 
     def import_boot_resources(self) -> str:
         LOG.debug("Getting latest debug event for watermark")
@@ -124,46 +144,55 @@ class AuthenticatedAPIClient:
         return result
 
     def is_importing_boot_resources(self) -> str:
-        return self.execute(["boot-resources", "is-importing"])
+        result: str = self.execute(["boot-resources", "is-importing"])
+        return result
 
     def list_machines(self, **kwargs: str) -> list[dict[str, Any]]:
         """
         machines read -h to know parameters available for kwargs
         """
-        cmd = ["machines", "read"]
-        return self.execute(cmd, extra_params=kwargs)
+        machines: list[dict[str, Any]] = self.execute(
+            ["machines", "read"], extra_params=kwargs
+        )
+        return machines
 
     def list_boot_images(self, rack_controller: dict[str, str]) -> dict[str, str]:
-        return self.execute(
+        boot_images: dict[str, str] = self.execute(
             ["rack-controller", "list-boot-images", rack_controller["system_id"]]
         )
+        return boot_images
 
     def import_boot_resources_in_rack(self, rack_controller: dict[str, str]) -> str:
-        return self.execute(
+        result: str = self.execute(
             ["rack-controller", "import-boot-images", rack_controller["system_id"]],
             json_output=False,
         )
+        return result
 
     def commission_machine(self, machine: dict[str, str]) -> dict[str, str]:
-        result = self.execute(["machine", "commission", machine["system_id"]])
+        result: dict[str, str] = self.execute(
+            ["machine", "commission", machine["system_id"]]
+        )
         assert result["status_name"] == "Commissioning"
         return result
 
     def deploy_machine(self, machine: dict[str, str], **kwargs: str) -> dict[str, str]:
-        result = self.execute(
+        result: dict[str, str] = self.execute(
             ["machine", "deploy", machine["system_id"]], extra_params=kwargs
         )
         assert result["status_name"] == "Deploying"
         return result
 
     def create_ssh_key(self, public_key: str) -> None:
-        result = self.execute(["sshkeys", "create", f"key={public_key}"])
+        result: dict[str, str] = self.execute(
+            ["sshkeys", "create", f"key={public_key}"]
+        )
         assert result["key"] == public_key
         return
 
     def release_machine(self, machine: dict[str, str]) -> None:
         system_id: str = machine["system_id"]
-        result: dict = self.execute(["machine", "release", system_id])
+        result: dict[str, Any] = self.execute(["machine", "release", system_id])
         assert result["status_name"] == "Releasing"
         wait_for_machines(
             self,
@@ -238,11 +267,13 @@ class AuthenticatedAPIClient:
             ["zones", "create", f"name={name}", f"description={description}"]
         )
 
-    def list_zones(self) -> list[dict]:
-        return self.execute(["zones", "read"])
+    def list_zones(self) -> list[dict[str, Any]]:
+        zones: list[dict[str, Any]] = self.execute(["zones", "read"])
+        return zones
 
     def read_zone(self, zone_name: str) -> Any:
-        return self.execute(["zone", "read", zone_name])
+        zone: dict[str, Any] = self.execute(["zone", "read", zone_name])
+        return zone
 
     def update_zone(
         self,
@@ -256,41 +287,49 @@ class AuthenticatedAPIClient:
         if new_description is not None:
             cmd.append(f"description={new_description}")
 
-        return self.execute(cmd)
+        zone: dict[str, Any] = self.execute(cmd)
+        return zone
 
     def delete_zone(self, zone_name: str) -> str:
         try:
-            return self.execute(["zone", "delete", zone_name], json_output=False)
+            result: str = self.execute(["zone", "delete", zone_name], json_output=False)
         except CalledProcessError as err:
             if "cannot be deleted" in err.stdout:
                 raise CannotDeleteError(err.stdout)
             else:
                 raise
+        else:
+            return result
 
     def create_pool(self, name: str, description: str) -> Any:
         return self.execute(
             ["resource-pools", "create", f"name={name}", f"description={description}"]
         )
 
-    def list_pools(self) -> list[dict]:
-        return self.execute(["resource-pools", "read"])
+    def list_pools(self) -> list[dict[str, Any]]:
+        resource_pools: list[dict[str, Any]] = self.execute(["resource-pools", "read"])
+        return resource_pools
 
-    def read_pool(self, pool: dict[str, Any]) -> dict:
-        return self.execute(["resource-pool", "read", str(pool["id"])])
+    def read_pool(self, pool: dict[str, Any]) -> dict[str, Any]:
+        resource_pool: dict[str, Any] = self.execute(
+            ["resource-pool", "read", str(pool["id"])]
+        )
+        return resource_pool
 
     def update_pool(
         self,
         pool: dict[str, Any],
         new_name: Optional[str] = None,
         new_description: Optional[str] = None,
-    ) -> Any:
+    ) -> dict[str, Any]:
         cmd = ["resource-pool", "update", str(pool["id"])]
         if new_name is not None:
             cmd.append(f"name={new_name}")
         if new_description is not None:
             cmd.append(f"description={new_description}")
 
-        return self.execute(cmd)
+        pool_obj: dict[str, Any] = self.execute(cmd)
+        return pool_obj
 
     def delete_pool(self, pool: dict[str, Any]) -> Any:
         try:
@@ -303,27 +342,31 @@ class AuthenticatedAPIClient:
             else:
                 raise
 
-    def create_space(self, name: str) -> Any:
-        return self.execute(["spaces", "create", f"name={name}"])
+    def create_space(self, name: str) -> dict[str, Any]:
+        space: dict[str, Any] = self.execute(["spaces", "create", f"name={name}"])
+        return space
 
-    def list_spaces(self) -> list[dict]:
-        return self.execute(["spaces", "read"])
+    def list_spaces(self) -> list[dict[str, Any]]:
+        spaces: list[dict[str, Any]] = self.execute(["spaces", "read"])
+        return spaces
 
-    def read_space(self, space: dict[str, Any]) -> Any:
-        return self.execute(["space", "read", str(space["id"])])
+    def read_space(self, space: dict[str, Any]) -> dict[str, Any]:
+        space_obj: dict[str, Any] = self.execute(["space", "read", str(space["id"])])
+        return space_obj
 
     def update_space(
         self, space: dict[str, Any], new_name: Optional[str] = None
-    ) -> Any:
+    ) -> dict[str, Any]:
         cmd = ["space", "update", str(space["id"])]
         if new_name is not None:
             cmd.append(f"name={new_name}")
 
-        return self.execute(cmd)
+        space_obj: dict[str, Any] = self.execute(cmd)
+        return space_obj
 
-    def delete_space(self, space: dict[str, Any]) -> Any:
+    def delete_space(self, space: dict[str, Any]) -> str:
         try:
-            return self.execute(
+            result: str = self.execute(
                 ["space", "delete", str(space["id"])], json_output=False
             )
         except CalledProcessError as err:
@@ -331,3 +374,5 @@ class AuthenticatedAPIClient:
                 raise CannotDeleteError(err.stdout)
             else:
                 raise
+        else:
+            return result
diff --git a/systemtests/fixtures.py b/systemtests/fixtures.py
index fa50527..70278a7 100644
--- a/systemtests/fixtures.py
+++ b/systemtests/fixtures.py
@@ -8,7 +8,7 @@ import tempfile
 from logging import StreamHandler, getLogger
 from pathlib import Path
 from textwrap import dedent
-from typing import IO, TYPE_CHECKING, Any, Iterator, Optional
+from typing import TYPE_CHECKING, Any, Iterator, Optional, TextIO
 
 import paramiko
 import pytest
@@ -137,7 +137,7 @@ def maas_deb_repo(
 
 
 def get_user_data(
-    devices: dict[str, dict[str, Any]], cloud_config: Optional[dict] = None
+    devices: dict[str, dict[str, Any]], cloud_config: Optional[dict[str, Any]] = None
 ) -> str:
     ethernets = {}
     for name, device in sorted(devices.items()):
@@ -160,7 +160,7 @@ def get_user_data(
         }
     )
 
-    user_data = "#cloud-config\n" + yaml.dump(cloud_config, default_style="|")
+    user_data: str = "#cloud-config\n" + yaml.dump(cloud_config, default_style="|")
     return user_data
 
 
@@ -325,12 +325,12 @@ def maas_api_client(maas_region: MAASRegion) -> Iterator[MAASAPIClient]:
 
 
 @pytest.fixture
-def logstream() -> Iterator[IO]:
+def logstream() -> Iterator[TextIO]:
     yield io.StringIO()
 
 
 @pytest.fixture(autouse=True)
-def testlog(logstream: IO) -> Iterator[Logger]:
+def testlog(logstream: TextIO) -> Iterator[Logger]:
     current_test = os.environ.get("PYTEST_CURRENT_TEST")
     logger = getLogger(f"systemtests.{current_test}")
     handler = StreamHandler(logstream)
diff --git a/systemtests/lxd.py b/systemtests/lxd.py
index a783f95..2c49809 100644
--- a/systemtests/lxd.py
+++ b/systemtests/lxd.py
@@ -35,7 +35,7 @@ class CLILXD:
         except subprocess.CalledProcessError:
             return False
 
-    def _run(self, cmd: Union[str, list[str]]) -> subprocess.CompletedProcess:
+    def _run(self, cmd: Union[str, list[str]]) -> subprocess.CompletedProcess[str]:
         return run_with_logging(cmd, self.logger)
 
     def create_container(
@@ -89,7 +89,7 @@ class CLILXD:
 
     def pull_file(
         self, container: str, file_path: str, local_path: str
-    ) -> subprocess.CompletedProcess:
+    ) -> subprocess.CompletedProcess[str]:
         return self._run(
             [
                 "lxc",
@@ -122,9 +122,9 @@ class CLILXD:
     def execute(
         self,
         container: str,
-        command: list,
+        command: list[str],
         environment: Optional[dict[str, str]] = None,
-    ) -> subprocess.CompletedProcess:
+    ) -> subprocess.CompletedProcess[str]:
         lxc_command = ["lxc", "exec", "--force-noninteractive", container]
         if environment is not None:
             for key, value in environment.items():
@@ -146,7 +146,8 @@ class CLILXD:
                 for address in entry["state"]["network"]["eth0"]["addresses"]:
                     self.logger.info(f"Considering address: {address}")
                     if address["family"] == "inet":
-                        return address["address"]
+                        ip: str = address["address"]
+                        return ip
             else:
                 raise RuntimeError("Couldn't find an IP address")
 
diff --git a/systemtests/region.py b/systemtests/region.py
index 4e96f81..5ca3901 100644
--- a/systemtests/region.py
+++ b/systemtests/region.py
@@ -21,7 +21,7 @@ class MAASRegion:
         self.maas_container = maas_container
         self.installed_from_snap = installed_from_snap
 
-    def execute(self, command: list[str]) -> subprocess.CompletedProcess:
+    def execute(self, command: list[str]) -> subprocess.CompletedProcess[str]:
         lxd = get_lxd(LOG)
         return lxd.execute(self.maas_container, command)
 
@@ -61,7 +61,9 @@ class MAASRegion:
             "enable_http_proxy": enable_http_proxy,
         }
 
-    def enable_dhcp(self, config: dict, client: api.AuthenticatedAPIClient) -> None:
+    def enable_dhcp(
+        self, config: dict[str, Any], client: api.AuthenticatedAPIClient
+    ) -> None:
         rack_controllers = get_rack_controllers(client)
         for network in config["networks"].values():
             primary_controller, link = get_dhcp_controller(
@@ -134,7 +136,9 @@ class MAASRegion:
             return self.set_config("debug", "True")
 
 
-def get_dhcp_controller(rack_controllers: list[dict], cidr: str) -> tuple[dict, dict]:
+def get_dhcp_controller(
+    rack_controllers: list[dict[str, Any]], cidr: str
+) -> tuple[dict[str, Any], dict[str, Any]]:
     for rack_controller in rack_controllers:
         for interface in rack_controller["interface_set"]:
             for link in interface["links"]:
@@ -143,7 +147,7 @@ def get_dhcp_controller(rack_controllers: list[dict], cidr: str) -> tuple[dict, 
     raise AssertionError(f"Couldn't find rack controller managing DHCP for {cidr}")
 
 
-def get_rack_controllers(client: api.AuthenticatedAPIClient) -> list[dict]:
+def get_rack_controllers(client: api.AuthenticatedAPIClient) -> list[dict[str, Any]]:
     """Repeatedly attempt to get rack controllers"""
     attempts = count(1)
     for elapsed, _ in retries(timeout=300, delay=10):
diff --git a/systemtests/subprocess.py b/systemtests/subprocess.py
index 2c34389..8e4219f 100644
--- a/systemtests/subprocess.py
+++ b/systemtests/subprocess.py
@@ -8,8 +8,10 @@ if TYPE_CHECKING:
 
 
 def run_with_logging(
-    cmd: Union[str, list[str]], logger: logging.Logger, env: Optional[dict] = None
-) -> subprocess.CompletedProcess:
+    cmd: Union[str, list[str]],
+    logger: logging.Logger,
+    env: Optional[dict[str, str]] = None,
+) -> subprocess.CompletedProcess[str]:
     logger.info("Running command: " + " ".join(cmd))
     process = subprocess.Popen(
         cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, env=env
diff --git a/systemtests/tests/conftest.py b/systemtests/tests/conftest.py
index 7fa063d..7b8163a 100644
--- a/systemtests/tests/conftest.py
+++ b/systemtests/tests/conftest.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import argparse
-from typing import TYPE_CHECKING, Any, Iterator
+from typing import TYPE_CHECKING, Any, Iterator, cast
 
 import pytest
 import yaml
@@ -52,14 +52,14 @@ def pytest_addoption(parser: Parser) -> None:
 
 
 @pytest.fixture(scope="session")
-def config(request: pytest.FixtureRequest) -> dict:
+def config(request: pytest.FixtureRequest) -> dict[str, Any]:
     config_file = request.config.getoption("--ss-config")
     if not config_file:
         config_file = open("config.yaml", "r")
-    return yaml.safe_load(config_file) if config_file else {}
+    return cast(dict[str, Any], yaml.safe_load(config_file)) if config_file else {}
 
 
[e-mail](tryfirst=True, hookwrapper=True)
[e-mail](tryfirst=True, hookwrapper=True)  # type: ignore
 def pytest_runtest_makereport(item: Any, call: Any) -> Iterator[Any]:
     # execute all other hooks to obtain the report object
     outcome: _Result
diff --git a/systemtests/tests/test_basic.py b/systemtests/tests/test_basic.py
index a94c69a..a653921 100644
--- a/systemtests/tests/test_basic.py
+++ b/systemtests/tests/test_basic.py
@@ -19,7 +19,9 @@ if TYPE_CHECKING:
 
 class TestSetup:
     @pytest.mark.skip_if_installed_from_snap("Prometheus is installed in the snap")
-    def test_setup_prometheus(self, maas_region: MAASRegion, config: dict) -> None:
+    def test_setup_prometheus(
+        self, maas_region: MAASRegion, config: dict[str, str]
+    ) -> None:
         result = maas_region.execute(
             ["apt", "install", "python3-prometheus-client", "-y"]
         )
diff --git a/systemtests/tests/test_crud.py b/systemtests/tests/test_crud.py
index 366f815..0cb76f8 100644
--- a/systemtests/tests/test_crud.py
+++ b/systemtests/tests/test_crud.py
@@ -11,7 +11,7 @@ if TYPE_CHECKING:
     from ..api import AuthenticatedAPIClient
 
 
-@test_steps("create", "update", "delete")
+@test_steps("create", "update", "delete")  # type: ignore
 def test_zone(authenticated_admin: AuthenticatedAPIClient) -> Iterator[None]:
     authenticated_admin.create_zone(
         name="test-zone", description="A zone created by system-tests"
@@ -48,7 +48,7 @@ def test_zone(authenticated_admin: AuthenticatedAPIClient) -> Iterator[None]:
     yield
 
 
-@test_steps("create", "update", "delete")
+@test_steps("create", "update", "delete")  # type: ignore
 def test_resource_pool(authenticated_admin: AuthenticatedAPIClient) -> Iterator[None]:
     authenticated_admin.create_pool(
         name="test-pool", description="A resource pool created by system-tests"
@@ -87,7 +87,7 @@ def test_resource_pool(authenticated_admin: AuthenticatedAPIClient) -> Iterator[
     yield
 
 
-@test_steps("create", "update", "delete")
+@test_steps("create", "update", "delete")  # type: ignore
 def test_spaces(authenticated_admin: AuthenticatedAPIClient) -> Iterator[None]:
     authenticated_admin.create_space(name="test-space")
     spaces = authenticated_admin.list_spaces()
diff --git a/systemtests/utils.py b/systemtests/utils.py
index 68e17e9..7959492 100644
--- a/systemtests/utils.py
+++ b/systemtests/utils.py
@@ -3,7 +3,7 @@ from __future__ import annotations
 import random
 import string
 import time
-from typing import TYPE_CHECKING, Any, Callable, Generator, Union
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Union
 
 import paramiko
 from retry.api import retry_call
@@ -42,7 +42,9 @@ def randomstring(length: int = 10) -> str:
     return "".join(random.choice(string.ascii_lowercase) for _ in range(length))
 
 
-def retries(timeout: Union[int, float] = 30, delay: Union[int, float] = 1) -> Generator:
+def retries(
+    timeout: Union[int, float] = 30, delay: Union[int, float] = 1
+) -> Iterator[tuple[float, float]]:
     """Helper for retrying something, sleeping between attempts.
 
     Yields ``(elapsed, remaining)`` tuples, giving times in seconds.