Merge pull request #15 from George-Ogden/fixtures

Fixture Support

Author: George-Ogden

.github/workflows/test.yaml

@@ -9,9 +9,16 @@ on:
       - master
 
 jobs:
-  test:
+  unit_tests:
     uses: George-Ogden/actions/.github/workflows/python-test.yaml@v3.1.3
     with:
       python-versions: "['3.13']"
       timeout-minutes: 15
-      pytest-flags: -vv -n auto
+      pytest-flags: -vv -n auto mypy_pytest_plugin -m "not local_only"
+
+  integration_tests:
+    uses: George-Ogden/actions/.github/workflows/python-test.yaml@v3.1.3
+    with:
+      python-versions: "['3.13']"
+      timeout-minutes: 5
+      pytest-flags: -vv tests

.pre-commit-config.yaml

@@ -38,6 +38,6 @@ repos:
       - id: dbg-check
       - id: todo-check
       - id: mypy
-        args: [-r, requirements-dev.txt]
+        args: [-r, requirements-dev.txt, --show-traceback]
         exclude: ^test_samples/
       - id: spell-check-commit-msgs

mypy_pytest_plugin/argnames_parser.py

@@ -0,0 +1,104 @@
+from collections import Counter
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import cast
+
+from mypy.checker import TypeChecker
+from mypy.nodes import (
+    Context,
+    Expression,
+    ListExpr,
+    StrExpr,
+    TupleExpr,
+)
+
+from .error_codes import (
+    DUPLICATE_ARGNAME,
+    INVALID_ARGNAME,
+    UNREADABLE_ARGNAME,
+    UNREADABLE_ARGNAMES,
+)
+
+
+@dataclass(frozen=True)
+class ArgnamesParser:
+    checker: TypeChecker
+
+    def parse_names(self, expression: Expression) -> str | list[str] | None:
+        match expression:
+            case StrExpr():
+                argnames = self.parse_names_string(expression)
+            case ListExpr() | TupleExpr():
+                argnames = self.parse_names_sequence(expression)
+            case _:
+                self.checker.fail(
+                    "Unable to identify argnames. (Use a comma-separated string, list of strings or tuple of strings).",
+                    context=expression,
+                    code=UNREADABLE_ARGNAMES,
+                )
+                return None
+        argnames = self._check_duplicate_argnames(argnames, expression)
+        return argnames
+
+    def _check_valid_identifier(self, name: str, context: StrExpr) -> bool:
+        if not (valid_identifier := name.isidentifier()):
+            self.checker.fail(
+                f"Invalid identifier {name!r}.",
+                context=context,
+                code=INVALID_ARGNAME,
+            )
+        return valid_identifier
+
+    def parse_names_string(self, expression: StrExpr) -> str | list[str] | None:
+        individual_names = [name.strip() for name in expression.value.split(",")]
+        filtered_names = [name for name in individual_names if name]
+        if any([not self._check_valid_identifier(name, expression) for name in filtered_names]):
+            return None
+        if len(filtered_names) == 1:
+            [name] = filtered_names
+            return name
+        return filtered_names
+
+    def _parse_name(self, expression: Expression) -> str | None:
+        if isinstance(expression, StrExpr):
+            name = expression.value
+            if self._check_valid_identifier(name, expression):
+                return name
+        else:
+            self.checker.fail(
+                "Unable to read identifier. (Use a sequence of strings instead.)",
+                context=expression,
+                code=UNREADABLE_ARGNAME,
+            )
+        return None
+
+    def parse_names_sequence(self, node: TupleExpr | ListExpr) -> list[str] | None:
+        names = [self._parse_name(item) for item in node.items]
+        if all([isinstance(name, str) for name in names]):
+            return cast(list[str], names)
+        return None
+
+    def _check_duplicate_argnames(
+        self, argnames: str | list[str] | None, context: Context
+    ) -> str | list[str] | None:
+        if isinstance(argnames, list):
+            return self._check_duplicate_argnames_sequence(argnames, context)
+        return argnames
+
+    def _check_duplicate_argnames_sequence(
+        self, argnames: list[str], context: Context
+    ) -> None | list[str]:
+        argname_counts = Counter(argnames)
+        duplicates = [argname for argname, count in argname_counts.items() if count > 1]
+        if duplicates:
+            self._warn_duplicate_argnames(duplicates, context)
+            return None
+        return argnames
+
+    def _warn_duplicate_argnames(self, duplicates: Iterable[str], context: Context) -> None:
+        for argname in duplicates:
+            self.checker.fail(
+                f"Duplicated argname {argname!r}.",
+                context=context,
+                code=DUPLICATE_ARGNAME,
+            )

mypy_pytest_plugin/argnames_parser_test.py

@@ -0,0 +1,182 @@
+from collections.abc import Callable
+from typing import cast
+
+from mypy.nodes import (
+    Expression,
+)
+
+from .argnames_parser import ArgnamesParser
+from .test_utils import (
+    check_error_messages,
+    default_argnames_parser,
+    get_error_messages,
+    parse,
+)
+
+
+def _argnames_parser_parse_names_custom_test_body[T: Expression](
+    source: str,
+    names: str | list[str] | None,
+    errors: list[str] | None,
+    parse_names: Callable[[ArgnamesParser, T], str | list[str] | None],
+) -> None:
+    source = f"names = {source}"
+    parse_result = parse(source)
+    checker = parse_result.checker
+
+    names_node = cast(T, parse_result.defs["names"])
+
+    argnames_parser = default_argnames_parser(checker)
+
+    assert not checker.errors.is_errors()
+    assert parse_names(argnames_parser, names_node) == names
+
+    messages = get_error_messages(checker)
+    check_error_messages(messages, errors=errors)
+
+
+def _argnames_parser_parse_names_string_test_body(
+    source: str, names: str | list[str] | None, *, errors: list[str] | None = None
+) -> None:
+    _argnames_parser_parse_names_custom_test_body(
+        source, names, errors, ArgnamesParser.parse_names_string
+    )
+
+
+def test_argnames_parser_parse_names_string_empty() -> None:
+    _argnames_parser_parse_names_string_test_body("''", [])
+
+
+def test_argnames_parser_parse_names_string_noise_only() -> None:
+    _argnames_parser_parse_names_string_test_body("',, , , ,  '", [])
+
+
+def test_argnames_parser_parse_names_string_one_item() -> None:
+    _argnames_parser_parse_names_string_test_body("'bar'", "bar")
+
+
+def test_argnames_parser_parse_names_string_one_item_extra_noise() -> None:
+    _argnames_parser_parse_names_string_test_body("', foo_8,,, , '", "foo_8")
+
+
+def test_argnames_parser_parse_names_string_three_items() -> None:
+    _argnames_parser_parse_names_string_test_body("'a, b_, __c'", ["a", "b_", "__c"])
+
+
+def test_argnames_parser_parse_names_string_two_items_extra_noise() -> None:
+    _argnames_parser_parse_names_string_test_body(
+        "',  aa ,b,b,    ,,,,,,,,d  '", ["aa", "b", "b", "d"]
+    )
+
+
+def argnames_parser_parse_names_string_starting_with_number() -> None:
+    _argnames_parser_parse_names_string_test_body("'8ac'", None, errors=["invalid-argname"])
+
+
+def test_argnames_parser_parse_names_string_with_space() -> None:
+    _argnames_parser_parse_names_string_test_body("'aa b'", None, errors=["invalid-argname"])
+
+
+def test_argnames_parser_parse_names_string_with_invalid_name() -> None:
+    _argnames_parser_parse_names_string_test_body("'aaa, b b, c'", None, errors=["invalid-argname"])
+
+
+def test_argnames_parser_parse_names_string_with_multiple_invalid_names() -> None:
+    _argnames_parser_parse_names_string_test_body(
+        "'aaa, b b, c-d'", None, errors=["invalid-argname", "invalid-argname"]
+    )
+
+
+def _argnames_parser_parse_names_sequence_test_body(
+    source: str,
+    names: list[str] | None,
+    *,
+    errors: list[str] | None = None,
+) -> None:
+    _argnames_parser_parse_names_custom_test_body(
+        source, names, errors, ArgnamesParser.parse_names_sequence
+    )
+
+
+def test_argnames_parser_parse_names_sequence_empty() -> None:
+    _argnames_parser_parse_names_sequence_test_body("()", [])
+
+
+def test_argnames_parser_parse_names_sequence_integer_name() -> None:
+    _argnames_parser_parse_names_sequence_test_body("[5]", None, errors=["unreadable-argname"])
+
+
+def test_argnames_parser_parse_names_sequence_one_item() -> None:
+    _argnames_parser_parse_names_sequence_test_body("['bar']", ["bar"])
+
+
+def test_argnames_parser_parse_names_sequence_one_item_extra_space() -> None:
+    _argnames_parser_parse_names_sequence_test_body("['foo ']", None, errors=["invalid-argname"])
+
+
+def test_argnames_parser_parse_names_sequence_three_items() -> None:
+    _argnames_parser_parse_names_sequence_test_body("('a', 'b_', '__c_')", ["a", "b_", "__c_"])
+
+
+def test_argnames_parser_parse_names_sequence_one_starting_with_number() -> None:
+    _argnames_parser_parse_names_sequence_test_body("['8ac']", None, errors=["invalid-argname"])
+
+
+def test_argnames_parser_parse_names_sequence_multiple_errors() -> None:
+    _argnames_parser_parse_names_sequence_test_body(
+        "('a', 10, '28', f'{5}')",
+        None,
+        # unreadable argname message not repeated
+        errors=["unreadable-argname", "invalid-argname"],
+    )
+
+
+def test_argnames_parser_parse_names_sequence_one_int() -> None:
+    _argnames_parser_parse_names_sequence_test_body(
+        "('a', 10, 'c')", None, errors=["unreadable-argname"]
+    )
+
+
+def test_argnames_parser_parse_names_sequence_one_invalid() -> None:
+    _argnames_parser_parse_names_sequence_test_body(
+        "('a', '8ab', 'c')", None, errors=["invalid-argname"]
+    )
+
+
+def test_argnames_parser_parse_names_sequence_one_undeterminable() -> None:
+    _argnames_parser_parse_names_sequence_test_body(
+        "('a', 'ab'.upper(), 'c')", None, errors=["unreadable-argname"]
+    )
+
+
+def _argnames_parser_parse_names_test_body(
+    source: str,
+    names: list[str] | str | None,
+    *,
+    errors: list[str] | None = None,
+) -> None:
+    _argnames_parser_parse_names_custom_test_body(source, names, errors, ArgnamesParser.parse_names)
+
+
+def test_argnames_parser_parse_names_one_as_string() -> None:
+    _argnames_parser_parse_names_test_body("'abc'", "abc")
+
+
+def test_argnames_parser_parse_names_multiple_as_string() -> None:
+    _argnames_parser_parse_names_test_body("'a,b,c'", ["a", "b", "c"])
+
+
+def test_argnames_parser_parse_names_one_as_sequence() -> None:
+    _argnames_parser_parse_names_test_body("['foo']", ["foo"])
+
+
+def test_argnames_parser_parse_names_many_as_sequence() -> None:
+    _argnames_parser_parse_names_test_body("('foo', 'bar')", ["foo", "bar"])
+
+
+def test_argnames_parser_parse_names_duplicate_name() -> None:
+    _argnames_parser_parse_names_test_body("'a, b, a'", None, errors=["duplicate-argname"])
+
+
+def test_argnames_parser_parse_names_invalid_type() -> None:
+    _argnames_parser_parse_names_test_body("{'a', 'b'}", None, errors=["unreadable-argnames"])

mypy_pytest_plugin/decorator_wrapper.py

@@ -12,7 +12,7 @@
 
 @dataclass(frozen=True, slots=True)
 class DecoratorWrapper:
-    node: CallExpr
+    call: CallExpr
     checker: TypeChecker
 
     @classmethod
@@ -40,13 +40,13 @@ def _is_parametrized_decorator_node(
     def _get_arg_type(self, i: int) -> Type:
         # subtract one for self
         i -= 1
-        return self.node.args[i].accept(self.checker.expr_checker)
+        return self.call.args[i].accept(self.checker.expr_checker)
 
     @property
     def arg_names_and_arg_values(self) -> tuple[Expression, Expression] | None:
         mapping = map_actuals_to_formals(
-            actual_kinds=[ArgKind.ARG_POS, *self.node.arg_kinds],
-            actual_names=[None, *self.node.arg_names],
+            actual_kinds=[ArgKind.ARG_POS, *self.call.arg_kinds],
+            actual_names=[None, *self.call.arg_names],
             formal_kinds=self.fn_type.arg_kinds,
             formal_names=self.fn_type.arg_names,
             actual_arg_type=self._get_arg_type,
@@ -55,7 +55,7 @@ def arg_names_and_arg_values(self) -> tuple[Expression, Expression] | None:
 
     @property
     def fn_type(self) -> CallableType:
-        callee_type = self.node.callee.accept(self.checker.expr_checker)
+        callee_type = self.call.callee.accept(self.checker.expr_checker)
         assert isinstance(callee_type, Instance)
         fn_type = callee_type.type.names["__call__"].type
         assert isinstance(fn_type, CallableType)
@@ -66,13 +66,13 @@ def _check_actuals_formals_mapping(
     ) -> tuple[Expression, Expression] | None:
         arg_names_idx, arg_values_idx, *_ = self._clean_up_actuals_formals_mapping(mapping)
         if (
-            self.node.arg_kinds[arg_values_idx] in self.accepted_arg_kinds
-            and self.node.arg_kinds[arg_names_idx] in self.accepted_arg_kinds
+            self.call.arg_kinds[arg_values_idx] in self.accepted_arg_kinds
+            and self.call.arg_kinds[arg_names_idx] in self.accepted_arg_kinds
         ):
-            return self.node.args[arg_names_idx], self.node.args[arg_values_idx]
+            return self.call.args[arg_names_idx], self.call.args[arg_values_idx]
         self.checker.fail(
             "Unable to read argnames and argvalues in a variadic argument.",
-            context=self.node,
+            context=self.call,
             code=VARIADIC_ARGNAMES_ARGVALUES,
         )
         return None

mypy_pytest_plugin/defer.py

@@ -0,0 +1 @@
+class DeferralError(Exception): ...