Add type hints to the main plugin components as per #176

Author: vitalk

src/pytest_flask/_internal.py

@@ -1,8 +1,15 @@
 import functools
+from typing import Callable
+from typing import Literal
 import warnings
 
+from pytest import Config as _PytestConfig
 
-def deprecated(reason):
+
+_PytestScopeName = Literal["session", "package", "module", "class", "function"]
+
+
+def deprecated(reason: str) -> Callable:
     """Decorator which can be used to mark function or method as deprecated.
     It will result a warning being emitted when the function is called."""
 
@@ -19,15 +26,15 @@ def deprecated_call(*args, **kwargs):
     return decorator
 
 
-def _rewrite_server_name(server_name, new_port):
+def _rewrite_server_name(server_name: str, new_port: str) -> str:
     """Rewrite server port in ``server_name`` with ``new_port`` value."""
     sep = ":"
     if sep in server_name:
         server_name, _ = server_name.split(sep, 1)
     return sep.join((server_name, new_port))
 
 
-def _determine_scope(*, fixture_name, config):
+def _determine_scope(*, fixture_name: str, config: _PytestConfig) -> _PytestScopeName:
     return config.getini("live_server_scope")
 
 

src/pytest_flask/fixtures.py

@@ -1,6 +1,14 @@
 #!/usr/bin/env python
 import socket
-
+from typing import Any
+from typing import cast
+from typing import Generator
+
+from flask import Flask as _FlaskApp
+from flask.config import Config as _FlaskAppConfig
+from flask.testing import FlaskClient as _FlaskTestClient
+from pytest import Config as _PytestConfig
+from pytest import FixtureRequest as _PytestFixtureRequest
 import pytest
 
 from ._internal import _determine_scope
@@ -10,7 +18,7 @@
 
 
 @pytest.fixture
-def client(app):
+def client(app: _FlaskApp) -> Generator[_FlaskTestClient, Any, Any]:
     """A Flask test client. An instance of :class:`flask.testing.TestClient`
     by default.
     """
@@ -19,7 +27,7 @@ def client(app):
 
 
 @pytest.fixture
-def client_class(request, client):
+def client_class(request: _PytestFixtureRequest, client: _FlaskTestClient) -> None:
     """Uses to set a ``client`` class attribute to current Flask test client::
 
     @pytest.mark.usefixtures('client_class')
@@ -37,8 +45,10 @@ def test_login(self):
         request.cls.client = client
 
 
-@pytest.fixture(scope=_determine_scope)
-def live_server(request, app, pytestconfig):  # pragma: no cover
+@pytest.fixture(scope=_determine_scope)  # type: ignore[arg-type]
+def live_server(
+    request: _PytestFixtureRequest, app: _FlaskApp, pytestconfig: _PytestConfig
+) -> Generator[LiveServer, Any, Any]:  # pragma: no cover
     """Run application in a separate process.
 
     When the ``live_server`` fixture is applied, the ``url_for`` function
@@ -64,34 +74,36 @@ def test_server_is_up_and_running(live_server):
         port = s.getsockname()[1]
         s.close()
 
-    host = pytestconfig.getvalue("live_server_host")
+    host = cast(str, pytestconfig.getvalue("live_server_host"))
 
     # Explicitly set application ``SERVER_NAME`` for test suite
     original_server_name = app.config["SERVER_NAME"] or "localhost.localdomain"
     final_server_name = _rewrite_server_name(original_server_name, str(port))
     app.config["SERVER_NAME"] = final_server_name
 
-    wait = request.config.getvalue("live_server_wait")
-    clean_stop = request.config.getvalue("live_server_clean_stop")
+    wait = cast(int, request.config.getvalue("live_server_wait"))
+    clean_stop = cast(bool, request.config.getvalue("live_server_clean_stop"))
+
     server = LiveServer(app, host, port, wait, clean_stop)
     if request.config.getvalue("start_live_server"):
         server.start()
 
     request.addfinalizer(server.stop)
+
     yield server
 
     if original_server_name is not None:
         app.config["SERVER_NAME"] = original_server_name
 
 
 @pytest.fixture
-def config(app):
+def config(app: _FlaskApp) -> _FlaskAppConfig:
     """An application config."""
     return app.config
 
 
 @pytest.fixture(params=["application/json", "text/html"])
-def mimetype(request):
+def mimetype(request) -> str:
     return request.param
 
 

src/pytest_flask/live_server.py

@@ -1,17 +1,34 @@
 import logging
 import multiprocessing
+from multiprocessing import Process
 import os
 import platform
 import signal
 import socket
 import time
+from typing import Any
+from typing import cast
+from typing import Protocol
+from typing import Union
 
 import pytest
 
 
+class _SupportsFlaskAppRun(Protocol):
+    def run(
+        self,
+        host: str | None = None,
+        port: int | None = None,
+        debug: bool | None = None,
+        load_dotenv: bool = True,
+        **options: Any,
+    ) -> None:
+        ...
+
+
 # force 'fork' on macOS
 if platform.system() == "Darwin":
-    multiprocessing = multiprocessing.get_context("fork")
+    multiprocessing = multiprocessing.get_context("fork")  # type: ignore
 
 
 class LiveServer:  # pragma: no cover
@@ -25,27 +42,37 @@ class LiveServer:  # pragma: no cover
                  application is not started.
     """
 
-    def __init__(self, app, host, port, wait, clean_stop=False):
+    def __init__(
+        self,
+        app: _SupportsFlaskAppRun,
+        host: str,
+        port: int,
+        wait: int,
+        clean_stop: bool = False,
+    ):
         self.app = app
         self.port = port
         self.host = host
         self.wait = wait
         self.clean_stop = clean_stop
-        self._process = None
+        self._process: Union[Process, None] = None
 
-    def start(self):
+    def start(self) -> None:
         """Start application in a separate process."""
 
-        def worker(app, host, port):
+        def worker(app: _SupportsFlaskAppRun, host: str, port: int) -> None:
             app.run(host=host, port=port, use_reloader=False, threaded=True)
 
-        self._process = multiprocessing.Process(
-            target=worker, args=(self.app, self.host, self.port)
+        self._process = cast(
+            Process,
+            multiprocessing.Process(
+                target=worker, args=(self.app, self.host, self.port)
+            ),
         )
         self._process.daemon = True
         self._process.start()
 
-        keep_trying = True
+        keep_trying: bool = True
         start_time = time.time()
         while keep_trying:
             elapsed_time = time.time() - start_time
@@ -57,7 +84,7 @@ def worker(app, host, port):
             if self._is_ready():
                 keep_trying = False
 
-    def _is_ready(self):
+    def _is_ready(self) -> bool:
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         try:
             sock.connect((self.host, self.port))
@@ -69,13 +96,13 @@ def _is_ready(self):
             sock.close()
         return ret
 
-    def url(self, url=""):
+    def url(self, url: str = "") -> str:
         """Returns the complete url based on server options."""
         return "http://{host!s}:{port!s}{url!s}".format(
             host=self.host, port=self.port, url=url
         )
 
-    def stop(self):
+    def stop(self) -> None:
         """Stop application process."""
         if self._process:
             if self.clean_stop and self._stop_cleanly():
@@ -84,14 +111,17 @@ def stop(self):
                 # If it's still alive, kill it
                 self._process.terminate()
 
-    def _stop_cleanly(self, timeout=5):
+    def _stop_cleanly(self, timeout: int = 5) -> bool:
         """Attempts to stop the server cleanly by sending a SIGINT
         signal and waiting for ``timeout`` seconds.
 
         :return: True if the server was cleanly stopped, False otherwise.
         """
+        if not self._process:
+            return True
+
         try:
-            os.kill(self._process.pid, signal.SIGINT)
+            os.kill(cast(int, self._process.pid), signal.SIGINT)
             self._process.join(timeout)
             return True
         except Exception as ex:

src/pytest_flask/plugin.py

@@ -5,6 +5,12 @@
     :copyright: (c) by Vital Kudzelka
     :license: MIT
 """
+from typing import Any
+from typing import Protocol
+from typing import Type
+from typing import TypeVar
+
+from _pytest.config import Config as _PytestConfig
 import pytest
 
 from .fixtures import accept_any
@@ -18,19 +24,36 @@
 from .pytest_compat import getfixturevalue
 
 
+_Response = TypeVar("_Response")
+
+
+class _SupportsPytestFlaskEqual(Protocol):
+    status_code: int
+
+    def __eq__(self, other: Any) -> bool:
+        ...
+
+    def __ne__(self, other: Any) -> bool:
+        ...
+
+
 class JSONResponse:
     """Mixin with testing helper methods for JSON responses."""
 
-    def __eq__(self, other):
+    status_code: int
+
+    def __eq__(self, other) -> bool:
         if isinstance(other, int):
             return self.status_code == other
         return super().__eq__(other)
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         return not self == other
 
 
-def pytest_assertrepr_compare(op, left, right):
+def pytest_assertrepr_compare(
+    op: str, left: _SupportsPytestFlaskEqual, right: int
+) -> list[str] | None:
     if isinstance(left, JSONResponse) and op == "==" and isinstance(right, int):
         return [
             "Mismatch in status code for response: {} != {}".format(
@@ -42,7 +65,7 @@ def pytest_assertrepr_compare(op, left, right):
     return None
 
 
-def _make_test_response_class(response_class):
+def _make_test_response_class(response_class: Type[_Response]) -> Type[_Response]:
     """Extends the response class with special attribute to test JSON
     responses. Don't override user-defined `json` attribute if any.
 
@@ -186,7 +209,7 @@ def pytest_addoption(parser):
     )
 
 
-def pytest_configure(config):
+def pytest_configure(config: _PytestConfig) -> None:
     config.addinivalue_line(
         "markers", "app(options): pass options to your application factory"
     )