Switch mypy to pyproject.toml, use stricter config

Author: bluetech

pyproject.toml

@@ -8,3 +8,21 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
 write_to = "pytest_django/_version.py"
+
+[tool.mypy]
+strict = true
+disallow_incomplete_defs = false
+disallow_untyped_defs = false
+disallow_subclassing_any = false
+files = [
+    "pytest_django",
+    "pytest_django_test",
+    "tests",
+]
+[[tool.mypy.overrides]]
+module = [
+    "django.*",
+    "configurations.*",
+    "psycopg2cffi.*",
+]
+ignore_missing_imports = true

pytest_django/fixtures.py

@@ -89,12 +89,14 @@ def django_db_use_migrations(request: pytest.FixtureRequest) -> bool:
 
 @pytest.fixture(scope="session")
 def django_db_keepdb(request: pytest.FixtureRequest) -> bool:
-    return request.config.getvalue("reuse_db")
+    reuse_db: bool = request.config.getvalue("reuse_db")
+    return reuse_db
 
 
 @pytest.fixture(scope="session")
 def django_db_createdb(request: pytest.FixtureRequest) -> bool:
-    return request.config.getvalue("create_db")
+    create_db: bool = request.config.getvalue("create_db")
+    return create_db
 
 
 @pytest.fixture(scope="session")
@@ -407,7 +409,8 @@ def django_user_model(db: None):
 @pytest.fixture()
 def django_username_field(django_user_model) -> str:
     """The fieldname for the username used with Django's user model."""
-    return django_user_model.USERNAME_FIELD
+    field: str = django_user_model.USERNAME_FIELD
+    return field
 
 
 @pytest.fixture()

pytest_django/lazy_django.py

@@ -25,12 +25,13 @@ def django_settings_is_configured() -> bool:
 
     if not ret and "django.conf" in sys.modules:
         django_conf: Any = sys.modules["django.conf"]
-        return django_conf.settings.configured
+        ret = django_conf.settings.configured
 
     return ret
 
 
 def get_django_version() -> Tuple[int, int, int, str, int]:
     import django
 
-    return django.VERSION
+    version: Tuple[int, int, int, str, int] = django.VERSION
+    return version

pytest_django/plugin.py

@@ -491,14 +491,14 @@ def non_debugging_runtest(self) -> None:
         self._testcase(result=self)
 
     try:
-        TestCaseFunction.runtest = non_debugging_runtest  # type: ignore[assignment]
+        TestCaseFunction.runtest = non_debugging_runtest  # type: ignore[method-assign]
 
         request.getfixturevalue("django_db_setup")
 
         with django_db_blocker.unblock():
             yield
     finally:
-        TestCaseFunction.runtest = original_runtest  # type: ignore[assignment]
+        TestCaseFunction.runtest = original_runtest  # type: ignore[method-assign]
 
 
 @pytest.fixture(scope="function", autouse=True)
@@ -521,7 +521,7 @@ def mailoutbox(
 
     from django.core import mail
 
-    return mail.outbox
+    return mail.outbox  # type: ignore[no-any-return]
 
 
 @pytest.fixture(scope="function")
@@ -589,7 +589,7 @@ def __contains__(self, key: str) -> bool:
             return key == "%s"
 
         @staticmethod
-        def _get_origin():
+        def _get_origin() -> Optional[str]:
             stack = inspect.stack()
 
             # Try to use topmost `self.origin` first (Django 1.9+, and with
@@ -598,10 +598,11 @@ def _get_origin():
                 func = f[3]
                 if func == "render":
                     frame = f[0]
+                    origin: Optional[str]
                     try:
                         origin = frame.f_locals["self"].origin
                     except (AttributeError, KeyError):
-                        continue
+                        origin = None
                     if origin is not None:
                         return origin
 
@@ -620,7 +621,9 @@ def _get_origin():
             # ``django.template.base.Template``
             template = f_locals["self"]
             if isinstance(template, Template):
-                return template.name
+                name: str = template.name
+                return name
+            return None
 
         def __mod__(self, var: str) -> str:
             origin = self._get_origin()
@@ -704,8 +707,8 @@ class _DatabaseBlocker:
     This is the object returned by django_db_blocker.
     """
 
-    def __init__(self):
-        self._history = []
+    def __init__(self) -> None:
+        self._history = []  # type: ignore[var-annotated]
         self._real_ensure_connection = None
 
     @property

pytest_django_test/db_helpers.py

@@ -1,6 +1,7 @@
 import os
 import sqlite3
 import subprocess
+from typing import Mapping, Optional
 
 import pytest
 from django.conf import settings
@@ -10,8 +11,8 @@
 # Construct names for the "inner" database used in runpytest tests
 _settings = settings.DATABASES["default"]
 
-DB_NAME = _settings["NAME"]
-TEST_DB_NAME = _settings["TEST"]["NAME"]
+DB_NAME: str = _settings["NAME"]
+TEST_DB_NAME: str = _settings["TEST"]["NAME"]
 
 if _settings["ENGINE"] == "django.db.backends.sqlite3" and TEST_DB_NAME is None:
     TEST_DB_NAME = ":memory:"
@@ -31,18 +32,19 @@
     SECOND_TEST_DB_NAME = TEST_DB_NAME + '_second' if DB_NAME is not None else None
 
 
-def get_db_engine():
-    return _settings["ENGINE"].split(".")[-1]
+def get_db_engine() -> str:
+    db_engine: str = _settings["ENGINE"].split(".")[-1]
+    return db_engine
 
 
 class CmdResult:
-    def __init__(self, status_code, std_out, std_err):
+    def __init__(self, status_code: int, std_out: bytes, std_err: bytes) -> None:
         self.status_code = status_code
         self.std_out = std_out
         self.std_err = std_err
 
 
-def run_cmd(*args, env=None):
+def run_cmd(*args: str, env: Optional[Mapping[str, str]] = None) -> CmdResult:
     r = subprocess.Popen(
         args,
         stdout=subprocess.PIPE,
@@ -54,7 +56,7 @@ def run_cmd(*args, env=None):
     return CmdResult(ret, stdoutdata, stderrdata)
 
 
-def run_psql(*args):
+def run_psql(*args: str) -> CmdResult:
     env = {}
     user = _settings.get("USER")
     if user:  # pragma: no branch
@@ -68,7 +70,7 @@ def run_psql(*args):
     return run_cmd("psql", *args, env=env)
 
 
-def run_mysql(*args):
+def run_mysql(*args: str) -> CmdResult:
     user = _settings.get("USER")
     if user:  # pragma: no branch
         args = ("-u", user, *args)
@@ -82,22 +84,22 @@ def run_mysql(*args):
     return run_cmd("mysql", *args)
 
 
-def skip_if_sqlite_in_memory():
+def skip_if_sqlite_in_memory() -> None:
     if (
         _settings["ENGINE"] == "django.db.backends.sqlite3"
         and _settings["TEST"]["NAME"] is None
     ):
         pytest.skip("Do not test db reuse since database does not support it")
 
 
-def _get_db_name(db_suffix=None):
+def _get_db_name(db_suffix: Optional[str] = None) -> str:
     name = TEST_DB_NAME
     if db_suffix:
         name = f"{name}_{db_suffix}"
     return name
 
 
-def drop_database(db_suffix=None):
+def drop_database(db_suffix: Optional[str] = None) -> None:
     name = _get_db_name(db_suffix)
     db_engine = get_db_engine()
 
@@ -119,7 +121,7 @@ def drop_database(db_suffix=None):
         os.unlink(name)
 
 
-def db_exists(db_suffix=None):
+def db_exists(db_suffix: Optional[str] = None) -> bool:
     name = _get_db_name(db_suffix)
     db_engine = get_db_engine()
 
@@ -137,7 +139,7 @@ def db_exists(db_suffix=None):
     return os.path.exists(name)
 
 
-def mark_database():
+def mark_database() -> None:
     db_engine = get_db_engine()
 
     if db_engine == "postgresql":
@@ -162,7 +164,7 @@ def mark_database():
         conn.close()
 
 
-def mark_exists():
+def mark_exists() -> bool:
     db_engine = get_db_engine()
 
     if db_engine == "postgresql":

setup.cfg

@@ -75,21 +75,3 @@ line_length = 79
 multi_line_output = 5
 lines_after_imports = 2
 extend_skip = pytest_django/_version.py
-
-[mypy]
-check_untyped_defs = True
-disallow_any_generics = True
-no_implicit_optional = True
-show_error_codes = True
-strict_equality = True
-warn_redundant_casts = True
-warn_unreachable = True
-warn_unused_configs = True
-no_implicit_reexport = True
-
-[mypy-django.*]
-ignore_missing_imports = True
-[mypy-configurations.*]
-ignore_missing_imports = True
-[mypy-psycopg2cffi.*]
-ignore_missing_imports = True

tests/test_database.py

@@ -8,10 +8,11 @@
 
 def db_supports_reset_sequences() -> bool:
     """Return if the current db engine supports `reset_sequences`."""
-    return (
+    ret: bool = (
         connection.features.supports_transactions
         and connection.features.supports_sequence_reset
     )
+    return ret
 
 
 def test_noaccess() -> None:
@@ -57,13 +58,13 @@ class TestDatabaseFixtures:
     ])
     def all_dbs(self, request: pytest.FixtureRequest) -> None:
         if request.param == "django_db_reset_sequences":
-            return request.getfixturevalue("django_db_reset_sequences")
+            request.getfixturevalue("django_db_reset_sequences")
         elif request.param == "transactional_db":
-            return request.getfixturevalue("transactional_db")
+            request.getfixturevalue("transactional_db")
         elif request.param == "db":
-            return request.getfixturevalue("db")
+            request.getfixturevalue("db")
         elif request.param == "django_db_serialized_rollback":
-            return request.getfixturevalue("django_db_serialized_rollback")
+            request.getfixturevalue("django_db_serialized_rollback")
         else:
             assert False  # pragma: no cover
 

tests/test_fixtures.py

@@ -81,7 +81,7 @@ def test_admin_user_no_db_marker(admin_user, django_user_model) -> None:
     assert isinstance(admin_user, django_user_model)
 
 
-def test_rf(rf) -> None:
+def test_rf(rf: RequestFactory) -> None:
     assert isinstance(rf, RequestFactory)
 
 
@@ -336,7 +336,7 @@ def test_deleted_again(self, settings) -> None:
     def test_signals(self, settings) -> None:
         result = []
 
-        def assert_signal(signal, sender, setting, value, enter):
+        def assert_signal(signal, sender, setting, value, enter) -> None:
             result.append((setting, value, enter))
 
         from django.test.signals import setting_changed
@@ -463,25 +463,28 @@ def test_fixture_transactional_db(self, transactional_db: None, live_server) ->
         assert force_str(response_data) == "Item count: 1"
 
     @pytest.fixture
-    def item(self) -> None:
+    def item(self) -> Item:
         # This has not requested database access explicitly, but the
         # live_server fixture auto-uses the transactional_db fixture.
-        Item.objects.create(name="foo")
+        item: Item = Item.objects.create(name="foo")
+        return item
 
-    def test_item(self, item, live_server) -> None:
+    def test_item(self, item: Item, live_server) -> None:
         pass
 
     @pytest.fixture
     def item_db(self, db: None) -> Item:
-        return Item.objects.create(name="foo")
+        item: Item = Item.objects.create(name="foo")
+        return item
 
     def test_item_db(self, item_db: Item, live_server) -> None:
         response_data = urlopen(live_server + "/item_count/").read()
         assert force_str(response_data) == "Item count: 1"
 
     @pytest.fixture
     def item_transactional_db(self, transactional_db: None) -> Item:
-        return Item.objects.create(name="foo")
+        item: Item = Item.objects.create(name="foo")
+        return item
 
     def test_item_transactional_db(self, item_transactional_db: Item, live_server) -> None:
         response_data = urlopen(live_server + "/item_count/").read()
@@ -570,7 +573,7 @@ def test_with_live_server(live_server):
     ROOT_URLCONF = 'tpkg.app.urls'
     """
 )
-def test_custom_user_model(django_pytester: DjangoPytester, username_field) -> None:
+def test_custom_user_model(django_pytester: DjangoPytester, username_field: str) -> None:
     django_pytester.create_app_file(
         f"""
         from django.contrib.auth.models import AbstractBaseUser, BaseUserManager, PermissionsMixin