sarj-python-lint 1.2.6__tar.gz → 1.2.7__tar.gz

{sarj_python_lint-1.2.6 → sarj_python_lint-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sarj-python-lint
-Version: 1.2.6
+Version: 1.2.7
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://code-standards.sarj.ai/rules/python/
 Project-URL: Documentation, https://code-standards.sarj.ai/rules/python/

{sarj_python_lint-1.2.6 → sarj_python_lint-1.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sarj-python-lint"
-version = "1.2.6"
+version = "1.2.7"
 description = "Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults"
 readme = "README.md"
 authors = [{ name = "sarj-ai" }]

{sarj_python_lint-1.2.6 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/_test_composition.py

@@ -189,16 +189,27 @@ def local_names(function: Function) -> set[str]:
     return names
 
 
-def changed_before(function: Function, call: ast.Call) -> set[str]:
+def changed_before(function: Function, call: ast.Call, aliases: dict[str, ast.expr]) -> set[str]:
     changed: set[str] = set()
     for node in direct_nodes(function):
-        if not isinstance(node, (ast.Call, ast.Attribute)) or node.lineno >= call.lineno:
+        if not isinstance(node, (ast.Call, ast.Attribute, ast.Subscript)) or (node.lineno, node.col_offset) >= (
+            call.lineno,
+            call.col_offset,
+        ):
             continue
         target = node.func.value if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) else None
-        if isinstance(node, ast.Attribute) and isinstance(node.ctx, (ast.Store, ast.Del)):
+        if isinstance(node, (ast.Attribute, ast.Subscript)) and isinstance(node.ctx, (ast.Store, ast.Del)):
             target = node.value
-        if isinstance(target, ast.Name):
+        while isinstance(target, (ast.Attribute, ast.Subscript)):
+            target = target.value
+        seen: set[str] = set()
+        while isinstance(target, ast.Name) and target.id not in seen:
+            seen.add(target.id)
             changed.add(target.id)
+            value = aliases.get(target.id)
+            if value is None or (value.lineno, value.col_offset) >= (node.lineno, node.col_offset):
+                break
+            target = value
     return changed
 
 

{sarj_python_lint-1.2.6 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/async_mock_call_without_await_assertion.py

@@ -41,6 +41,7 @@ _AWAIT_ASSERTIONS: Final = frozenset(
     }
 )
 _AWAIT_STATE: Final = frozenset({"await_count", "await_args", "await_args_list"})
+_CALL_STATE: Final = frozenset({"called", "call_count"})
 _CONSTRUCTOR_KEYWORDS: Final = frozenset({"return_value", "side_effect", "name", "wraps", "unsafe", "spec", "spec_set"})
 _MUTATORS: Final = frozenset({"reset_mock", "configure_mock", "attach_mock", "mock_add_spec"})
 _IMMEDIATE_CHILD_PARTS: Final = 2
@@ -86,10 +87,25 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
             "Only direct statements in collected test functions and methods are inspected; fixtures, helpers, nested blocks, and generated files are excluded.",
             "Requires a fresh local unittest.mock.AsyncMock constructor with unshadowed imports; aliases, reassignment, reset, and ambiguous configuration are excluded.",
             "Only the mock itself and unchanged immediate children of unspecced, unwrapped mocks are inferred; spec children, return values, and deeper chains are excluded.",
-            "Any direct positive await assertion or explicit await-state assertion on the same mock is accepted; argument equality and assertion strength are not compared.",
+            "Positive call-count and called-state assertions are covered as well as call-assertion methods. Await-state assertions must prove at least one await; argument equality and exact call/await counts are not compared.",
+            "Boolean conjunctions combine evidence; disjunctions require evidence in every branch. Dynamic counts and call lists are not inferred.",
             "Custom assertion helpers and intentional scheduling contracts may require a reasoned local suppression.",
         ),
         examples=(
+            RuleExample(
+                example_id="numeric-call-with-vacuous-await-check",
+                title="A nonnegative await count does not prove execution",
+                outcome=ExampleOutcome.MATCH,
+                files=(
+                    ExampleFile.python(
+                        "tests/test_delivery.py",
+                        "from unittest.mock import AsyncMock\n\nasync def test_delivery():\n    send = AsyncMock()\n    await deliver(send)\n    assert send.call_count == 2\n    assert send.await_count >= 0\n",
+                    ),
+                ),
+                focus_path=PurePosixPath("tests/test_delivery.py"),
+                expected_count=1,
+                public=False,
+            ),
             RuleExample(
                 example_id="call-only-async-mock",
                 title="A call assertion does not prove awaiting",
@@ -129,7 +145,7 @@ class AsyncMockCallWithoutAwaitAssertion(Rule):
         if (
             path.suffix != ".py"
             or "AsyncMock" not in source
-            or "assert_called" not in source
+            or not any(token in source for token in ("assert_called", "call_count", ".called"))
             or not (path.stem.startswith("test_") or path.stem.endswith("_test"))
             or context.generated
         ):
@@ -186,30 +202,46 @@ def _test_imports(module: ImportIndex, test: _TestFunction) -> ImportIndex:
     return ImportIndex(MappingProxyType(bindings), module.shadowed_names | local.shadowed_names)
 
 
-def _uncovered_calls(imports: ImportIndex, test: _TestFunction, writes: set[_Reference]) -> Iterator[ast.Call]:
+def _uncovered_calls(
+    imports: ImportIndex, test: _TestFunction, writes: set[_Reference]
+) -> Iterator[ast.Call | ast.Attribute]:
     nodes = tuple(walk_ast(test))
     bindings = _mock_bindings(imports, test.body, writes)
     covered = _await_oracles(test.body)
     reported: set[_Reference] = set()
     for statement in test.body:
-        match statement:
-            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
-                method in _CALL_ASSERTIONS
+        for reference, oracle in _call_oracles(statement):
+            if not reference or reference in covered or reference in reported:
+                continue
+            binding = bindings.get(reference[0])
+            if (
+                binding is None
+                or not _is_async_reference(reference, binding[1])
+                or any(_invalidates_reference(node, reference, binding[0]) for node in nodes)
             ):
-                reference = _reference(receiver)
-                if not reference or reference in covered or reference in reported:
-                    continue
-                binding = bindings.get(reference[0])
-                if (
-                    binding is None
-                    or not _is_async_reference(reference, binding[1])
-                    or any(_invalidates_reference(node, reference, binding[0]) for node in nodes)
-                ):
-                    continue
-                reported.add(reference)
-                yield call
-            case _:
-                pass
+                continue
+            reported.add(reference)
+            yield oracle
+
+
+def _call_oracles(statement: ast.stmt) -> Iterator[tuple[_Reference, ast.Call | ast.Attribute]]:
+    match statement:
+        case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
+            method in _CALL_ASSERTIONS
+        ):
+            yield _reference(receiver), call
+        case ast.Assert(test=condition):
+            for reference in sorted(_positive_states(condition, _CALL_STATE)):
+                oracle = next(
+                    node
+                    for node in walk_ast(condition)
+                    if isinstance(node, ast.Attribute)
+                    and node.attr in _CALL_STATE
+                    and _reference(node.value) == reference
+                )
+                yield reference, oracle
+        case _:
+            pass
 
 
 def _mock_bindings(
@@ -269,21 +301,127 @@ def _await_oracles(statements: list[ast.stmt]) -> set[_Reference]:
     covered: set[_Reference] = set()
     for statement in statements:
         match statement:
-            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method))) if (
+            case ast.Expr(value=ast.Call(func=ast.Attribute(value=receiver, attr=method)) as call) if (
                 method in _AWAIT_ASSERTIONS
             ):
-                covered.add(_reference(receiver))
+                if method != "assert_has_awaits" or _has_nonempty_calls_argument(call):
+                    covered.add(_reference(receiver))
             case ast.Assert(test=condition):
-                covered.update(
-                    _reference(node.value)
-                    for node in walk_ast(condition)
-                    if isinstance(node, ast.Attribute) and node.attr in _AWAIT_STATE
-                )
+                covered.update(_positive_states(condition, _AWAIT_STATE))
             case _:
                 pass
     return covered
 
 
+def _has_nonempty_calls_argument(call: ast.Call) -> bool:
+    if call.args:
+        return _nonempty_sequence(call.args[0])
+    return any(item.arg == "calls" and _nonempty_sequence(item.value) for item in call.keywords)
+
+
+def _positive_states(condition: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    if isinstance(condition, ast.UnaryOp) and isinstance(condition.op, ast.Not):
+        operand = condition.operand
+        if isinstance(operand, ast.Compare) and len(operand.ops) == 1:
+            inverse = _negated_operator(operand.ops[0])
+            if inverse is not None:
+                return _comparison_states(operand.left, inverse, operand.comparators[0], states) | _comparison_states(
+                    operand.comparators[0], _reversed_operator(inverse), operand.left, states
+                )
+        return set()
+    if isinstance(condition, ast.BoolOp):
+        branches = [_positive_states(value, states) for value in condition.values]
+        return (
+            branches[0].union(*branches[1:])
+            if isinstance(condition.op, ast.And)
+            else branches[0].intersection(*branches[1:])
+        )
+    if isinstance(condition, ast.Attribute) and condition.attr in states:
+        return {_reference(condition.value)}
+    if isinstance(condition, ast.Compare):
+        result: set[_Reference] = set()
+        for left, operator, right in zip(
+            (condition.left, *condition.comparators[:-1]), condition.ops, condition.comparators, strict=True
+        ):
+            result.update(_comparison_states(left, operator, right, states))
+            result.update(_comparison_states(right, _reversed_operator(operator), left, states))
+        return result
+    return set()
+
+
+def _negated_operator(operator: ast.cmpop) -> ast.cmpop | None:
+    inverse: dict[type[ast.cmpop], type[ast.cmpop]] = {
+        ast.Eq: ast.NotEq,
+        ast.NotEq: ast.Eq,
+        ast.Is: ast.IsNot,
+        ast.IsNot: ast.Is,
+        ast.Lt: ast.GtE,
+        ast.LtE: ast.Gt,
+        ast.Gt: ast.LtE,
+        ast.GtE: ast.Lt,
+    }
+    factory = inverse.get(type(operator))
+    return factory() if factory is not None else None
+
+
+def _reversed_operator(operator: ast.cmpop) -> ast.cmpop:
+    match operator:
+        case ast.Lt():
+            return ast.Gt()
+        case ast.LtE():
+            return ast.GtE()
+        case ast.Gt():
+            return ast.Lt()
+        case ast.GtE():
+            return ast.LtE()
+        case _:
+            return operator
+
+
+def _comparison_states(left: ast.expr, operator: ast.cmpop, right: ast.expr, states: frozenset[str]) -> set[_Reference]:
+    if not isinstance(left, ast.Attribute):
+        return set()
+    if (
+        states == _AWAIT_STATE
+        and isinstance(left.value, ast.Attribute)
+        and left.value.attr == "await_args"
+        and left.attr in {"args", "kwargs"}
+    ):
+        return {_reference(left.value.value)}
+    if left.attr not in states:
+        return set()
+    positive = False
+    if left.attr in {"call_count", "await_count"} and isinstance(right, ast.Constant) and type(right.value) is int:
+        positive = _proves_positive_count(operator, right.value)
+    elif left.attr == "called" and isinstance(right, ast.Constant):
+        positive = (isinstance(operator, (ast.Eq, ast.Is)) and right.value is True) or (
+            isinstance(operator, (ast.NotEq, ast.IsNot)) and right.value is False
+        )
+    elif left.attr == "await_args" and isinstance(right, ast.Constant) and right.value is None:
+        positive = isinstance(operator, (ast.NotEq, ast.IsNot))
+    elif left.attr == "await_args_list":
+        positive = (isinstance(operator, ast.Eq) and _nonempty_sequence(right)) or (
+            isinstance(operator, ast.NotEq) and isinstance(right, ast.List) and not right.elts
+        )
+    return {_reference(left.value)} if positive else set()
+
+
+def _proves_positive_count(operator: ast.cmpop, value: int) -> bool:
+    match operator:
+        case ast.Eq() | ast.GtE():
+            return value > 0
+        case ast.NotEq():
+            return value == 0
+        case ast.Gt():
+            return value >= 0
+        case _:
+            return False
+
+
+def _nonempty_sequence(node: ast.expr) -> bool:
+    return isinstance(node, (ast.List, ast.Tuple)) and any(not isinstance(item, ast.Starred) for item in node.elts)
+
+
 def _invalidates_reference(node: ast.AST, reference: _Reference, binding: ast.Name) -> bool:
     match node:
         case ast.Name(id=name, ctx=ast.Store() | ast.Del()):
@@ -295,7 +433,11 @@ def _invalidates_reference(node: ast.AST, reference: _Reference, binding: ast.Na
         case ast.Attribute(ctx=ast.Store() | ast.Del()):
             changed = _reference(node)
             return bool(changed) and (
-                reference[: len(changed)] == changed or (changed[:-1] == reference and changed[-1].startswith("assert"))
+                reference[: len(changed)] == changed
+                or (
+                    changed[:-1] == reference
+                    and (changed[-1].startswith("assert") or changed[-1] in _CALL_STATE | _AWAIT_STATE)
+                )
             )
         case ast.Call(func=ast.Attribute(value=receiver, attr=method)) if method in _MUTATORS:
             changed = _reference(receiver)

{sarj_python_lint-1.2.6 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/mock_without_spec.py

@@ -789,7 +789,7 @@ def _keyword_supplies_contract(keyword: ast.keyword, names: _MockNames, symbol:
             return False
         return names.resolve(keyword.value) not in _UNSPECCED_FACTORIES
     return keyword.arg in _PATCH_CONTRACT_KEYWORDS and not (
-        isinstance(keyword.value, ast.Constant) and keyword.value.value is None
+        isinstance(keyword.value, ast.Constant) and (keyword.value.value is None or keyword.value.value is False)
     )
 
 

{sarj_python_lint-1.2.6 → sarj_python_lint-1.2.7}/src/sarj_python_lint/rules/repeated_test_composition.py

@@ -168,7 +168,7 @@ def _candidate(
     identity = f"{spec.symbol.module}.{spec.symbol.name}"
     if not _unconditional(context, node, function) or not _subject_called(context, function, node):
         return identity, None
-    blocked = (available.blocked - aliases.keys()) | changed_before(function, node)
+    blocked = (available.blocked - aliases.keys()) | changed_before(function, node, aliases)
     scope = WiringScope(available.parameters, aliases, frozenset(blocked))
     arguments = wiring(context, project, node, spec, scope)
     return identity, f"{identity}:{arguments!r}" if arguments is not None else None