sarj-python-lint 0.21.0__tar.gz → 0.24.0__tar.gz

{sarj_python_lint-0.21.0 → sarj_python_lint-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sarj-python-lint
-Version: 0.21.0
+Version: 0.24.0
 Summary: Custom Python lint rules — AST-based, pre-commit-friendly, hypermodern defaults
 Project-URL: Homepage, https://github.com/sarj-ai/standards/tree/main/packages/python
 Project-URL: Repository, https://github.com/sarj-ai/standards
@@ -28,7 +28,7 @@ uv tool install sarj-python-lint
 
 ```yaml
 - repo: https://github.com/sarj-ai/standards
-  rev: python-v0.2.0
+  rev: python-v0.24.0
   hooks:
     - id: sarj-no-sequential-await
     - id: sarj-inefficient-string-concat-in-loop
@@ -146,6 +146,37 @@ decisions into one unreviewable one and pre-authorizes every mock added later.
 Scoped exemptions for mechanical codes (`E501`, `F401`, `UP035`) are never
 flagged — measured across five repos those are the entire population.
 
+
+### Mock-quality and real-dependency rules (0.24.0)
+
+The second test-quality wave. Where the 0.15.0 family asks "does this test assert
+anything?", this one asks "does it exercise anything real?" — it pushes suites off
+hand-rolled doubles and onto the real store, the real database and a maintained fake
+library. Measured against bulbul, noura-be, five other first-party repos and fourteen
+OSS corpora; two candidates were dropped outright when the corpus showed they only
+duplicated ruff.
+
+```yaml
+    - id: sarj-prefer-real-store-in-tests          # SARJ058
+    - id: sarj-prefer-library-fake                 # SARJ059
+    - id: sarj-tautological-mock-assertion         # SARJ060
+    - id: sarj-no-patching-system-under-test       # SARJ061
+    - id: sarj-over-mocked-test                    # SARJ062
+    - id: sarj-interaction-only-test               # SARJ063
+    - id: sarj-trivially-true-assertion            # SARJ064
+    - id: sarj-conditional-assertion-in-test       # SARJ065
+    - id: sarj-duplicate-test-body                 # SARJ066
+    - id: sarj-unused-mock-setup                   # SARJ067
+```
+
+### Expressiveness rules (0.24.0)
+
+```yaml
+    - id: sarj-prefer-fstring-over-concat          # SARJ068
+    - id: sarj-prefer-match-pattern-destructuring  # SARJ069
+    - id: sarj-prefer-or-pattern                   # SARJ070
+    - id: sarj-require-port-for-service            # SARJ071
+```
 ### Suppression ratchet (`sarj-ratchet`, 0.21.0)
 
 ```yaml
@@ -196,6 +227,92 @@ sarj-python-lint check --rule mock-without-spec --update-baseline test-quality-b
 sarj-python-lint check --rule mock-without-spec --baseline test-quality-baseline.json python/
 ```
 
+### Multi-tenant scoping (0.24.0)
+
+```yaml
+    - id: sarj-no-optional-tenant-predicate        # SARJ056
+```
+
+`SARJ056` fires when every WHERE-fragment mentioning a tenant column
+(`organization_id` and friends) sits inside a conditional, so the predicate
+disappears — and the query still runs — whenever the filter is empty:
+
+```python
+where_conditions = []
+if args.organization_ids:                                    # ← optional
+    where_conditions.append(SQL("organization_id = ANY(%s::uuid[])"))
+...
+where_clause = SQL(" AND ").join(where_conditions) if where_conditions else SQL("1=1")
+```
+
+The safe idiom seeds the list, so scoping always applies and the rule stays
+quiet:
+
+```python
+conditions: list[Composable] = [SQL("organization_id = %s")]
+```
+
+A function with **no** tenant predicate at all never fires — an intentionally
+cross-tenant admin query is out of scope; only *attempted-but-optional* scoping
+is a finding. Where a caller genuinely wants the all-tenant query, that
+intent belongs in an explicit method (or an inline `sarj-noqa`) rather than in
+an omitted filter.
+
+Measured before shipping: **0 findings across 26,345 files** of pydantic, trio,
+attrs, Airflow and Home Assistant — single-tenant codebases have no tenant
+column, so the rule is silent by construction — and 0 in noura-be, ai, kpi-hub
+and demo-gateway. In bulbul it finds 10 sites, all genuine fail-open
+compositions, two of which were reachable cross-tenant reads at the time of
+writing (`POST /v1/calls/list` and `POST /v1/calls/batch/list`, both of which
+composed `WHERE 1=1` for a user whose `organization_id` was NULL).
+
+### Assertions that can never fail (0.23.0)
+
+```yaml
+    - id: sarj-no-tautological-expect              # SARJ057
+```
+
+`SARJ057` fires when an assertion's operands are all literals, so its outcome is
+fixed before the code runs. `SARJ043` already catches the test with *no*
+assertion; this is the test whose assertion is decorative.
+
+The placeholder spelling (`assert True`) is the obvious half. The expensive half
+is the assertion whose real condition slid out of the condition slot, because it
+was a working assertion when it was typed:
+
+```python
+assert {                                              # ← braces, not parentheses
+    "referencing a non existing `via_device` " in caplog.text
+}                                                     # one-element SET, always truthy
+
+assert [f"No logs found on hdfs for ti={ti}"]         # the `== messages` was lost
+assert True, cover_result_json[0]["success"][...]     # slid into the MESSAGE slot
+```
+
+**The narrowness is the rule.** The obvious generalisation — "flag a comparison
+of a thing with itself" — measures ~95% false positives: `assert i == i`,
+`assert x is x`, `expect(hash([o])).toEqual(hash([o]))` are reflexivity,
+determinism and memoization tests, and for a type with custom `__eq__`/`__hash__`
+they can genuinely fail. So an identifier, attribute or call operand is never
+enough; both sides must be literals, and textually identical ones. `assert True`
+as the sole statement of an `except` handler is exempt — it asserts *which branch
+ran* — as is anything inside a pytest-benchmark test.
+
+Measured before shipping: **4 findings across 28,608 files** — 26,346 of
+pydantic, trio, attrs, Airflow and Home Assistant plus 2,262 first-party files
+in bulbul, noura-be, kpi-hub, ai and demo-gateway. All 4 are true positives
+(Home Assistant `tests/helpers/test_device_registry.py:3711` and `:3777`,
+`tests/components/emulated_hue/test_hue_api.py:1078`, Airflow
+`providers/apache/hdfs/.../log/test_hdfs_task_handler.py:170`); 0 false
+positives. The two `except ...: assert True` markers that a carve-out-free
+version does flag — `pydantic-core/tests/benchmarks/test_micro_benchmarks.py:716`
+and `core/tests/components/mqtt/test_client.py:1353` — were verified silent.
+
+The TypeScript half of the same rule ships as `@sarj/no-tautological-expect` in
+`@sarj/eslint-plugin` ≥ 2.14.0; until now there was no TS counterpart at all,
+which is how `expect(true).toBe(true); // placeholder` survived in a suite named
+for the behaviour it was supposed to check.
+
 ## CLI
 
 ```bash

{sarj_python_lint-0.21.0 → sarj_python_lint-0.24.0}/README.md

@@ -10,7 +10,7 @@ uv tool install sarj-python-lint
 
 ```yaml
 - repo: https://github.com/sarj-ai/standards
-  rev: python-v0.2.0
+  rev: python-v0.24.0
   hooks:
     - id: sarj-no-sequential-await
     - id: sarj-inefficient-string-concat-in-loop
@@ -128,6 +128,37 @@ decisions into one unreviewable one and pre-authorizes every mock added later.
 Scoped exemptions for mechanical codes (`E501`, `F401`, `UP035`) are never
 flagged — measured across five repos those are the entire population.
 
+
+### Mock-quality and real-dependency rules (0.24.0)
+
+The second test-quality wave. Where the 0.15.0 family asks "does this test assert
+anything?", this one asks "does it exercise anything real?" — it pushes suites off
+hand-rolled doubles and onto the real store, the real database and a maintained fake
+library. Measured against bulbul, noura-be, five other first-party repos and fourteen
+OSS corpora; two candidates were dropped outright when the corpus showed they only
+duplicated ruff.
+
+```yaml
+    - id: sarj-prefer-real-store-in-tests          # SARJ058
+    - id: sarj-prefer-library-fake                 # SARJ059
+    - id: sarj-tautological-mock-assertion         # SARJ060
+    - id: sarj-no-patching-system-under-test       # SARJ061
+    - id: sarj-over-mocked-test                    # SARJ062
+    - id: sarj-interaction-only-test               # SARJ063
+    - id: sarj-trivially-true-assertion            # SARJ064
+    - id: sarj-conditional-assertion-in-test       # SARJ065
+    - id: sarj-duplicate-test-body                 # SARJ066
+    - id: sarj-unused-mock-setup                   # SARJ067
+```
+
+### Expressiveness rules (0.24.0)
+
+```yaml
+    - id: sarj-prefer-fstring-over-concat          # SARJ068
+    - id: sarj-prefer-match-pattern-destructuring  # SARJ069
+    - id: sarj-prefer-or-pattern                   # SARJ070
+    - id: sarj-require-port-for-service            # SARJ071
+```
 ### Suppression ratchet (`sarj-ratchet`, 0.21.0)
 
 ```yaml
@@ -178,6 +209,92 @@ sarj-python-lint check --rule mock-without-spec --update-baseline test-quality-b
 sarj-python-lint check --rule mock-without-spec --baseline test-quality-baseline.json python/
 ```
 
+### Multi-tenant scoping (0.24.0)
+
+```yaml
+    - id: sarj-no-optional-tenant-predicate        # SARJ056
+```
+
+`SARJ056` fires when every WHERE-fragment mentioning a tenant column
+(`organization_id` and friends) sits inside a conditional, so the predicate
+disappears — and the query still runs — whenever the filter is empty:
+
+```python
+where_conditions = []
+if args.organization_ids:                                    # ← optional
+    where_conditions.append(SQL("organization_id = ANY(%s::uuid[])"))
+...
+where_clause = SQL(" AND ").join(where_conditions) if where_conditions else SQL("1=1")
+```
+
+The safe idiom seeds the list, so scoping always applies and the rule stays
+quiet:
+
+```python
+conditions: list[Composable] = [SQL("organization_id = %s")]
+```
+
+A function with **no** tenant predicate at all never fires — an intentionally
+cross-tenant admin query is out of scope; only *attempted-but-optional* scoping
+is a finding. Where a caller genuinely wants the all-tenant query, that
+intent belongs in an explicit method (or an inline `sarj-noqa`) rather than in
+an omitted filter.
+
+Measured before shipping: **0 findings across 26,345 files** of pydantic, trio,
+attrs, Airflow and Home Assistant — single-tenant codebases have no tenant
+column, so the rule is silent by construction — and 0 in noura-be, ai, kpi-hub
+and demo-gateway. In bulbul it finds 10 sites, all genuine fail-open
+compositions, two of which were reachable cross-tenant reads at the time of
+writing (`POST /v1/calls/list` and `POST /v1/calls/batch/list`, both of which
+composed `WHERE 1=1` for a user whose `organization_id` was NULL).
+
+### Assertions that can never fail (0.23.0)
+
+```yaml
+    - id: sarj-no-tautological-expect              # SARJ057
+```
+
+`SARJ057` fires when an assertion's operands are all literals, so its outcome is
+fixed before the code runs. `SARJ043` already catches the test with *no*
+assertion; this is the test whose assertion is decorative.
+
+The placeholder spelling (`assert True`) is the obvious half. The expensive half
+is the assertion whose real condition slid out of the condition slot, because it
+was a working assertion when it was typed:
+
+```python
+assert {                                              # ← braces, not parentheses
+    "referencing a non existing `via_device` " in caplog.text
+}                                                     # one-element SET, always truthy
+
+assert [f"No logs found on hdfs for ti={ti}"]         # the `== messages` was lost
+assert True, cover_result_json[0]["success"][...]     # slid into the MESSAGE slot
+```
+
+**The narrowness is the rule.** The obvious generalisation — "flag a comparison
+of a thing with itself" — measures ~95% false positives: `assert i == i`,
+`assert x is x`, `expect(hash([o])).toEqual(hash([o]))` are reflexivity,
+determinism and memoization tests, and for a type with custom `__eq__`/`__hash__`
+they can genuinely fail. So an identifier, attribute or call operand is never
+enough; both sides must be literals, and textually identical ones. `assert True`
+as the sole statement of an `except` handler is exempt — it asserts *which branch
+ran* — as is anything inside a pytest-benchmark test.
+
+Measured before shipping: **4 findings across 28,608 files** — 26,346 of
+pydantic, trio, attrs, Airflow and Home Assistant plus 2,262 first-party files
+in bulbul, noura-be, kpi-hub, ai and demo-gateway. All 4 are true positives
+(Home Assistant `tests/helpers/test_device_registry.py:3711` and `:3777`,
+`tests/components/emulated_hue/test_hue_api.py:1078`, Airflow
+`providers/apache/hdfs/.../log/test_hdfs_task_handler.py:170`); 0 false
+positives. The two `except ...: assert True` markers that a carve-out-free
+version does flag — `pydantic-core/tests/benchmarks/test_micro_benchmarks.py:716`
+and `core/tests/components/mqtt/test_client.py:1353` — were verified silent.
+
+The TypeScript half of the same rule ships as `@sarj/no-tautological-expect` in
+`@sarj/eslint-plugin` ≥ 2.14.0; until now there was no TS counterpart at all,
+which is how `expect(true).toBe(true); // placeholder` survived in a suite named
+for the behaviour it was supposed to check.
+
 ## CLI
 
 ```bash

{sarj_python_lint-0.21.0 → sarj_python_lint-0.24.0}/pyproject.toml

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

sarj_python_lint-0.24.0/src/sarj_python_lint/rules/_pytest.py

@@ -0,0 +1,61 @@
+"""Shared pytest-shape predicates for the assertion-quality rules.
+
+A pytest-benchmark test measures wall-clock time; verifying is not its job, and
+every rule that judges a test's assertions needs the same carve-out for it —
+SARJ043 (`zero-assertion-test`) because a benchmark asserts nothing, SARJ057
+(`no-tautological-expect`) because the idiomatic way to benchmark a *failing*
+path is `try: ...; assert False; except Err: assert True` inside the timed
+callable. Keeping the predicate in one module is what stops the two copies from
+drifting apart.
+"""
+
+from __future__ import annotations
+
+import ast
+
+
+# The pytest-benchmark fixture: the test measures time, it does not verify.
+_BENCHMARK = "benchmark"
+
+
+def uses_benchmark_fixture(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Report whether `node` both declares and uses the pytest-benchmark fixture.
+
+    `def test_x(benchmark)` then `benchmark(fn, arg)` or `@benchmark` on a nested
+    function. The fixture times the callable; a benchmark that asserted on the
+    result would be measuring the assertion. Requiring the name to be *used*, not
+    just declared, keeps an unrelated parameter that happens to be called
+    `benchmark` from silencing the rule.
+
+    Returns:
+        True when the function is a pytest-benchmark test.
+
+    """
+    args = node.args
+    declared = any(arg.arg == _BENCHMARK for arg in (*args.posonlyargs, *args.args, *args.kwonlyargs))
+    return declared and any(isinstance(child, ast.Name) and child.id == _BENCHMARK for child in ast.walk(node))
+
+
+def has_benchmark_marker(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Report whether `node` carries `@pytest.mark.benchmark`, called or bare.
+
+    The marker form is the other half of pytest-benchmark's surface: a test can
+    take the fixture, wear the marker, or both.
+
+    Returns:
+        True when a `pytest.mark.benchmark` decorator is present.
+
+    """
+    return any(_decorator_attr(dec) == _BENCHMARK for dec in node.decorator_list)
+
+
+def _decorator_attr(dec: ast.expr) -> str | None:
+    target = dec.func if isinstance(dec, ast.Call) else dec
+    if not isinstance(target, ast.Attribute):
+        return None
+    # Only `*.mark.<name>`, so a `@benchmark.something` helper is not mistaken
+    # for a pytest marker.
+    parent = target.value
+    if isinstance(parent, ast.Attribute) and parent.attr == "mark":
+        return target.attr
+    return None

{sarj_python_lint-0.21.0 → sarj_python_lint-0.24.0}/src/sarj_python_lint/rules/_registry.py

@@ -2,10 +2,13 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from sarj_python_lint.rules.conditional_assertion_in_test import ConditionalAssertionInTest
+from sarj_python_lint.rules.duplicate_test_body import DuplicateTestBody
 from sarj_python_lint.rules.fixture_returns_bare_tuple import FixtureReturnsBareTuple
 from sarj_python_lint.rules.inefficient_string_concat_in_loop import (
     InefficientStringConcatInLoop,
 )
+from sarj_python_lint.rules.interaction_only_test import InteractionOnlyTest
 from sarj_python_lint.rules.kwarg_heavy_construction_in_test import KwargHeavyConstructionInTest
 from sarj_python_lint.rules.kwonly_same_type_params import KwonlySameTypeParams
 from sarj_python_lint.rules.mock_without_spec import MockWithoutSpec
@@ -26,6 +29,10 @@ from sarj_python_lint.rules.no_fstring_in_log import NoFstringInLog
 from sarj_python_lint.rules.no_gen_random_uuid_in_sql import NoGenRandomUuidInSql
 from sarj_python_lint.rules.no_isinstance_union_chain import NoIsinstanceUnionChain
 from sarj_python_lint.rules.no_offset_pagination import NoOffsetPagination
+from sarj_python_lint.rules.no_optional_tenant_predicate import (
+    NoOptionalTenantPredicate,
+)
+from sarj_python_lint.rules.no_patching_system_under_test import NoPatchingSystemUnderTest
 from sarj_python_lint.rules.no_query_with_many_joins import NoQueryWithManyJoins
 from sarj_python_lint.rules.no_raw_sql_in_tests import NoRawSqlInTests
 from sarj_python_lint.rules.no_repeated_string_literal import NoRepeatedStringLiteral
@@ -36,21 +43,28 @@ from sarj_python_lint.rules.no_sentinel_return_on_except import NoSentinelReturn
 from sarj_python_lint.rules.no_sequential_await import NoSequentialAwait
 from sarj_python_lint.rules.no_sleep_in_test_body import NoSleepInTestBody
 from sarj_python_lint.rules.no_stdlib_logging import NoStdlibLogging
+from sarj_python_lint.rules.no_tautological_expect import NoTautologicalExpect
 from sarj_python_lint.rules.no_unreachable_after_terminal import (
     NoUnreachableAfterTerminal,
 )
+from sarj_python_lint.rules.over_mocked_test import OverMockedTest
 from sarj_python_lint.rules.parametrize_case_needs_id import ParametrizeCaseNeedsId
 from sarj_python_lint.rules.prefer_class_row import PreferClassRow
 from sarj_python_lint.rules.prefer_constant_time_secret_compare import (
     PreferConstantTimeSecretCompare,
 )
+from sarj_python_lint.rules.prefer_fstring_over_concat import PreferFstringOverConcat
+from sarj_python_lint.rules.prefer_library_fake import PreferLibraryFake
 from sarj_python_lint.rules.prefer_match_assert_never import PreferMatchAssertNever
+from sarj_python_lint.rules.prefer_match_pattern_destructuring import PreferMatchPatternDestructuring
 from sarj_python_lint.rules.prefer_module_level_constant import (
     PreferModuleLevelConstant,
 )
 from sarj_python_lint.rules.prefer_namedtuple_over_tuple_return import (
     PreferNamedtupleOverTupleReturn,
 )
+from sarj_python_lint.rules.prefer_or_pattern import PreferOrPattern
+from sarj_python_lint.rules.prefer_real_store_in_tests import PreferRealStoreInTests
 from sarj_python_lint.rules.prefer_str_enum import PreferStrEnum
 from sarj_python_lint.rules.prefer_struct_over_namedtuple import (
     PreferStructOverNamedtuple,
@@ -60,16 +74,20 @@ from sarj_python_lint.rules.prefer_timedelta_for_durations import (
 )
 from sarj_python_lint.rules.pydantic_at_boundaries import PydanticAtBoundaries
 from sarj_python_lint.rules.redundant_docstring import RedundantDocstring
+from sarj_python_lint.rules.require_port_for_service import RequirePortForService
 from sarj_python_lint.rules.single_public_export import SinglePublicExport
 from sarj_python_lint.rules.sleep_with_computed_arg_in_test import SleepWithComputedArgInTest
 from sarj_python_lint.rules.stepdown import Stepdown
 from sarj_python_lint.rules.store_insert_requires_on_conflict import (
     StoreInsertRequiresOnConflict,
 )
+from sarj_python_lint.rules.tautological_mock_assertion import TautologicalMockAssertion
 from sarj_python_lint.rules.test_loops_over_literal_cases import (
     TestLoopsOverLiteralCases,
 )
 from sarj_python_lint.rules.trailing_value_narration import TrailingValueNarration
+from sarj_python_lint.rules.trivially_true_assertion import TriviallyTrueAssertion
+from sarj_python_lint.rules.unused_mock_setup import UnusedMockSetup
 from sarj_python_lint.rules.xfail_requires_strict import XfailRequiresStrict
 from sarj_python_lint.rules.zero_assertion_test import ZeroAssertionTest
 
@@ -83,8 +101,28 @@ if TYPE_CHECKING:
 #   SARJ027, SARJ029, SARJ030 (dropped in 0.11.1 as too noisy),
 #   SARJ033 httpx-client-requires-timeout, SARJ035 no-import-time-settings
 #   (dropped by user veto after the 0.13.x mined-rules review),
+#   SARJ055 no-filler-success-adverb (built and corpus-validated, then dropped
+#   — but not for the reason first recorded. The headline "4.7% of Airflow's
+#   info/debug logs" is a composition artifact: 237 of those 248 hits are in
+#   `providers/` (contributed vendor operators, heavily copy-pasted — the
+#   template "%s completed successfully." appears 22 times verbatim). Airflow's
+#   maintainer-owned `airflow-core/` sits at 1.15% and Home Assistant at 1.24%,
+#   so the real external baseline is ~1.2%, not 4.7%. The rule was re-measured
+#   and dropped on a stronger basis: the narrow variant — fire only when the
+#   adverb is the sole content beyond a bare verb — has 12 external hits and
+#   ZERO internal ones across all six repos, so it would govern nothing we
+#   write. The broad rule remains opt-in house style, not a defect check.
+#   (Noted for any future revisit: noura-be measures 7.92%, a genuine outlier
+#   against every corpus; that, not the narrow variant, is the case to make.),
 #   SARJ037 no-trivial-single-use-helper (prototyped and dropped for FP rate;
 #   see the 0.13.1 inlining commit for the corpus analysis).
+#   SARJ072 unbound-mock-assertion and SARJ073 raises-needs-specific-error
+#   (built, corpus-measured and dropped before ever being registered, in the
+#   wave that added SARJ058-071). SARJ072 found 0 hits across 16,130 files in
+#   9 repos, including 0 against 8,322 real mock-assertion API uses; ruff B018
+#   covers its bare-statement shape. SARJ073 was a strict superset of ruff
+#   PT011, which this standard already enables — its one real gap,
+#   RuntimeError, is closed by `lint.flake8-pytest-style.raises-require-match-for`.
 REGISTRY: dict[str, type[Rule]] = {
     NoSequentialAwait.id: NoSequentialAwait,
     InefficientStringConcatInLoop.id: InefficientStringConcatInLoop,
@@ -132,6 +170,22 @@ REGISTRY: dict[str, type[Rule]] = {
     NoStdlibLogging.id: NoStdlibLogging,
     NoGenRandomUuidInSql.id: NoGenRandomUuidInSql,
     NoFileLevelEscapeHatchNoqa.id: NoFileLevelEscapeHatchNoqa,
+    NoOptionalTenantPredicate.id: NoOptionalTenantPredicate,
+    NoTautologicalExpect.id: NoTautologicalExpect,
+    PreferRealStoreInTests.id: PreferRealStoreInTests,
+    PreferLibraryFake.id: PreferLibraryFake,
+    TautologicalMockAssertion.id: TautologicalMockAssertion,
+    NoPatchingSystemUnderTest.id: NoPatchingSystemUnderTest,
+    OverMockedTest.id: OverMockedTest,
+    InteractionOnlyTest.id: InteractionOnlyTest,
+    TriviallyTrueAssertion.id: TriviallyTrueAssertion,
+    ConditionalAssertionInTest.id: ConditionalAssertionInTest,
+    DuplicateTestBody.id: DuplicateTestBody,
+    UnusedMockSetup.id: UnusedMockSetup,
+    PreferFstringOverConcat.id: PreferFstringOverConcat,
+    PreferMatchPatternDestructuring.id: PreferMatchPatternDestructuring,
+    PreferOrPattern.id: PreferOrPattern,
+    RequirePortForService.id: RequirePortForService,
 }
 
 __all__ = ["REGISTRY"]