chore(mypy): check tests

Author: branchv

pyproject.toml

@@ -41,14 +41,11 @@ lines_between_types = 1
 lines_after_imports = 2
 
 [tool.mypy]
-check_untyped_defs = true
 ignore_missing_imports = true
 show_error_codes = true
-warn_redundant_casts = true
-warn_unused_configs = true
-warn_unused_ignores = true
+strict = true
 enable_error_code = ["ignore-without-code"]
-files = "src"
+files = ["src", "tests"]
 
 [build-system]
 requires = ["poetry-core"]

src/poetry_plugin_bundle/bundlers/venv_bundler.py

@@ -153,7 +153,7 @@ def bundle(self, poetry: Poetry, io: IO) -> bool:
                     poetry.package.name,
                     poetry.package.version,
                     source_type="file",
-                    source_url=wheel,
+                    source_url=str(wheel),
                 )
                 installer.executor.execute([Install(package)])
             except ModuleOrPackageNotFound:
@@ -216,7 +216,7 @@ def _get_executable_info(self, executable: str) -> tuple[str, Version]:
             pass
 
         try:
-            python_version = subprocess.check_output(
+            python_version_str = subprocess.check_output(
                 list_to_shell_command(
                     [
                         executable,
@@ -232,6 +232,6 @@ def _get_executable_info(self, executable: str) -> tuple[str, Version]:
 
             raise EnvCommandError(e)
 
-        python_version = Version.parse(python_version.strip())
+        python_version = Version.parse(python_version_str.strip())
 
         return executable, python_version

tests/bundlers/test_bundler_manager.py

@@ -12,15 +12,15 @@ class MockBundler(Bundler):
     name = "mock"
 
 
-def test_bundler_returns_an_instance_of_the_correct_bundler_class():
+def test_bundler_returns_an_instance_of_the_correct_bundler_class() -> None:
     manager = BundlerManager()
 
     bundler = manager.bundler("venv")
     assert isinstance(bundler, Bundler)
     assert bundler.name == "venv"
 
 
-def test_bundler_raises_an_error_for_incorrect_bundler_classes():
+def test_bundler_raises_an_error_for_incorrect_bundler_classes() -> None:
     manager = BundlerManager()
 
     with pytest.raises(
@@ -29,7 +29,7 @@ def test_bundler_raises_an_error_for_incorrect_bundler_classes():
         manager.bundler("mock")
 
 
-def test_register_bundler_class_registers_new_bundler_classes():
+def test_register_bundler_class_registers_new_bundler_classes() -> None:
     manager = BundlerManager()
     manager.register_bundler_class(MockBundler)
 
@@ -38,7 +38,7 @@ def test_register_bundler_class_registers_new_bundler_classes():
     assert bundler.name == "mock"
 
 
-def test_register_bundler_class_cannot_register_existing_bundler_classes():
+def test_register_bundler_class_cannot_register_existing_bundler_classes() -> None:
     manager = BundlerManager()
     manager.register_bundler_class(MockBundler)
 

tests/bundlers/test_venv_bundler.py

@@ -53,7 +53,7 @@ def poetry(config: Config) -> Poetry:
 
 def test_bundler_should_build_a_new_venv_with_existing_python(
     io: BufferedIO, tmpdir: str, poetry: Poetry, mocker: MockerFixture
-):
+) -> None:
     shutil.rmtree(tmpdir)
     mocker.patch("poetry.installation.executor.Executor._execute_operation")
 
@@ -75,7 +75,7 @@ def test_bundler_should_build_a_new_venv_with_existing_python(
 
 def test_bundler_should_build_a_new_venv_with_given_executable(
     io: BufferedIO, tmpdir: str, poetry: Poetry, mocker: MockerFixture
-):
+) -> None:
     shutil.rmtree(tmpdir)
     mocker.patch("poetry.installation.executor.Executor._execute_operation")
 
@@ -98,7 +98,7 @@ def test_bundler_should_build_a_new_venv_with_given_executable(
 
 def test_bundler_should_build_a_new_venv_if_existing_venv_is_incompatible(
     io: BufferedIO, tmpdir: str, poetry: Poetry, mocker: MockerFixture
-):
+) -> None:
     mocker.patch("poetry.installation.executor.Executor._execute_operation")
 
     bundler = VenvBundler()
@@ -120,7 +120,7 @@ def test_bundler_should_build_a_new_venv_if_existing_venv_is_incompatible(
 
 def test_bundler_should_use_an_existing_venv_if_compatible(
     io: BufferedIO, tmp_venv: VirtualEnv, poetry: Poetry, mocker: MockerFixture
-):
+) -> None:
     mocker.patch("poetry.installation.executor.Executor._execute_operation")
 
     bundler = VenvBundler()
@@ -141,7 +141,7 @@ def test_bundler_should_use_an_existing_venv_if_compatible(
 
 def test_bundler_should_remove_an_existing_venv_if_forced(
     io: BufferedIO, tmp_venv: VirtualEnv, poetry: Poetry, mocker: MockerFixture
-):
+) -> None:
     mocker.patch("poetry.installation.executor.Executor._execute_operation")
 
     bundler = VenvBundler()
@@ -165,7 +165,7 @@ def test_bundler_should_remove_an_existing_venv_if_forced(
 
 def test_bundler_should_fail_when_installation_fails(
     io: BufferedIO, tmpdir: str, poetry: Poetry, mocker: MockerFixture
-):
+) -> None:
     mocker.patch(
         "poetry.installation.executor.Executor._do_execute_operation",
         side_effect=Exception(),
@@ -189,7 +189,7 @@ def test_bundler_should_fail_when_installation_fails(
 
 def test_bundler_should_display_a_warning_for_projects_with_no_module(
     io: BufferedIO, tmp_venv: VirtualEnv, mocker: MockerFixture, config: Config
-):
+) -> None:
     poetry = Factory().create_poetry(
         Path(__file__).parent.parent / "fixtures" / "simple_project_with_no_module"
     )

tests/conftest.py

@@ -56,7 +56,7 @@ def config(
 
     from keyring.backends.fail import Keyring
 
-    keyring.set_keyring(Keyring())
+    keyring.set_keyring(Keyring())  # type: ignore[no-untyped-call]
 
     c = Config()
     c.merge(config_source.config)

tests/console/commands/bundle/test_venv.py

@@ -11,7 +11,9 @@
     from pytest_mock import MockerFixture
 
 
-def test_venv_calls_venv_bundler(app_tester: ApplicationTester, mocker: MockerFixture):
+def test_venv_calls_venv_bundler(
+    app_tester: ApplicationTester, mocker: MockerFixture
+) -> None:
     mock = mocker.patch(
         "poetry_plugin_bundle.bundlers.venv_bundler.VenvBundler.bundle",
         side_effect=[True, False],

tests/helpers.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from typing import TYPE_CHECKING
+from typing import Any
 
 from poetry.console.application import Application
 from poetry.core.toml.file import TOMLFile
@@ -12,6 +13,7 @@
     from pathlib import Path
 
     from poetry.poetry import Poetry
+    from tomlkit.toml_document import TOMLDocument
 
 
 class TestApplication(Application):
@@ -21,7 +23,8 @@ def __init__(self, poetry: Poetry) -> None:
 
     def reset_poetry(self) -> None:
         poetry = self._poetry
-        self._poetry = Factory().create_poetry(self._poetry.file.path.parent)
+        assert poetry is not None
+        self._poetry = Factory().create_poetry(poetry.file.path.parent)
         self._poetry.set_pool(poetry.pool)
         self._poetry.set_config(poetry.config)
         self._poetry.set_locker(
@@ -30,13 +33,12 @@ def reset_poetry(self) -> None:
 
 
 class TestLocker(Locker):
-    def __init__(self, lock: str | Path, local_config: dict) -> None:
+    def __init__(self, lock: str | Path, local_config: dict[str, Any]) -> None:
         self._lock = TOMLFile(lock)
         self._local_config = local_config
-        self._lock_data: dict | None = None
+        self._lock_data: TOMLDocument | None = None
         self._content_hash = self._get_content_hash()
         self._locked = False
-        self._lock_data = None
         self._write = False
 
     def write(self, write: bool = True) -> None:
@@ -50,15 +52,15 @@ def locked(self, is_locked: bool = True) -> TestLocker:
 
         return self
 
-    def mock_lock_data(self, data: dict) -> None:
+    def mock_lock_data(self, data: TOMLDocument) -> None:
         self.locked()
 
         self._lock_data = data
 
     def is_fresh(self) -> bool:
         return True
 
-    def _write_lock_data(self, data: dict) -> None:
+    def _write_lock_data(self, data: TOMLDocument) -> None:
         if self._write:
             super()._write_lock_data(data)
             self._locked = True