test: guard loops that would assert nothing over an empty collection (#3)

Completes the vacuity pass. 24 tests looped over a computed collection with no
check that it contained anything, so each would have reported success against
an implementation that returned nothing at all. Mutation-verified: emptying the
language registry now fails 17 of them, and suppressing orphan detection fails
two more. Both previously passed.

The remaining seven loop over locally-defined literals of four to six elements,
which cannot be empty by accident, and are left alone -- a guard there would be
noise rather than protection.

Also restores a test that had quietly shrunk.
`test_no_analyzer_declares_an_option_it_ignores` documents itself as checking
"across all analyzers at once" and was iterating a hardcoded one-element list,
so it verified a tenth of what it claimed while still passing. It reads the
registry again, asserts the registry is fully populated, and now fails when a
dead option is added to any analyzer.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Lumi-node

tests/test_analyzers.py

@@ -34,6 +34,8 @@ def test_orphan_ids_have_extensions(
         result = boundaries.run(ctx)
 
         orphans = result.get("orphans", [])
+        # A loop over an empty collection asserts nothing.
+        assert orphans, "nothing to check: orphans was empty"
         for orphan in orphans:
             # orphan should be a FileId (string with extension)
             assert isinstance(orphan, str)

tests/test_arch_analyzer.py

@@ -528,7 +528,14 @@ def test_no_analyzer_declares_an_option_it_ignores() -> None:
     """
     import inspect
 
-    for name, analyzer in [("architecture", ArchitectureAnalyzer())]:
+    from drydock.core.registry import available
+
+    analyzers = available()
+    assert len(analyzers) >= 8, (
+        f"expected the full analyzer registry, got {sorted(analyzers)}"
+    )
+
+    for name, analyzer in sorted(analyzers.items()):
         body = inspect.getsource(type(analyzer).__dict__["run"])
         dead = [
             o.name for o in analyzer.options

tests/test_arch_principles.py

@@ -459,5 +459,7 @@ def test_principle_registry_loads_all_builtins() -> None:
         "tests-use-public-surface"
     }
 
+    # A loop over an empty collection asserts nothing.
+    assert builtin_ids, "nothing to check: builtin_ids was empty"
     for principle_id in builtin_ids:
         assert principle_id in all_principles, f"Built-in principle {principle_id} not loaded"

tests/test_cli.py

@@ -30,6 +30,8 @@ class TestUniformCliVocabulary:
     def test_every_analyzer_accepts_markdown_flag(self) -> None:
         """All analyzers accept --markdown flag."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             parser = build_parser(analyzer)
             # Should not raise
@@ -39,6 +41,8 @@ def test_every_analyzer_accepts_markdown_flag(self) -> None:
     def test_every_analyzer_accepts_compact_flag(self) -> None:
         """All analyzers accept --compact flag."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             parser = build_parser(analyzer)
             args = parser.parse_args(["/tmp", "--compact"])
@@ -47,6 +51,8 @@ def test_every_analyzer_accepts_compact_flag(self) -> None:
     def test_every_analyzer_accepts_quiet_flag(self) -> None:
         """All analyzers accept --quiet flag."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             parser = build_parser(analyzer)
             args = parser.parse_args(["/tmp", "--quiet"])
@@ -55,6 +61,8 @@ def test_every_analyzer_accepts_quiet_flag(self) -> None:
     def test_every_analyzer_accepts_no_tests_flag(self) -> None:
         """All analyzers accept --no-tests flag."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             parser = build_parser(analyzer)
             args = parser.parse_args(["/tmp", "--no-tests"])
@@ -63,6 +71,8 @@ def test_every_analyzer_accepts_no_tests_flag(self) -> None:
     def test_every_analyzer_accepts_max_files_flag(self) -> None:
         """All analyzers accept --max-files N flag."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             parser = build_parser(analyzer)
             args = parser.parse_args(["/tmp", "--max-files", "100"])
@@ -71,6 +81,8 @@ def test_every_analyzer_accepts_max_files_flag(self) -> None:
     def test_every_analyzer_accepts_output_flag(self) -> None:
         """All analyzers accept --output/-o FILE flag."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             parser = build_parser(analyzer)
             args = parser.parse_args(["/tmp", "--output", "out.json"])

tests/test_diagram_mermaid.py

@@ -451,6 +451,8 @@ def test_layer_diagram_edges_reference_nodes():
     edges = _extract_edges(output)
 
     # All edge targets and sources must be in nodes (or be special nodes)
+    # A loop over an empty collection asserts nothing.
+    assert edges, "nothing to check: edges was empty"
     for src, tgt in edges:
         if src.startswith("layer") and src.endswith("_more"):
             continue  # Special node
@@ -480,6 +482,8 @@ def test_package_diagram_edges_reference_nodes():
     nodes = _extract_nodes(output)
     edges = _extract_edges(output)
 
+    # A loop over an empty collection asserts nothing.
+    assert edges, "nothing to check: edges was empty"
     for src, tgt in edges:
         if src == "note" or tgt == "note":
             continue  # Special node

tests/test_langs.py

@@ -343,6 +343,8 @@ def test_all_import_refs_no_spaces(self, realistic_rust_project: Path) -> None:
         ctx = AnalysisContext(realistic_rust_project)
 
         # Walk all source files and parse them
+        # A loop over an empty collection asserts nothing.
+        assert ctx.walk.files, "nothing to check: ctx.walk.files was empty"
         for sf in ctx.walk.files:
             if sf.lang is None:
                 continue
@@ -382,6 +384,8 @@ def test_language_support_matrix_complete(self) -> None:
         registry = language_registry()
         matrix = registry.support_matrix()
 
+        # A loop over an empty collection asserts nothing.
+        assert matrix, "nothing to check: matrix was empty"
         for row in matrix:
             assert "language" in row
             assert "fidelity" in row
@@ -401,6 +405,8 @@ def test_each_language_has_extensions(self) -> None:
         registry = language_registry()
         matrix = registry.support_matrix()
 
+        # A loop over an empty collection asserts nothing.
+        assert matrix, "nothing to check: matrix was empty"
         for row in matrix:
             assert len(row["extensions"]) > 0
             # Extensions should start with .
@@ -416,6 +422,8 @@ def test_parser_has_name(self, tmp_path: Path) -> None:
         """Each parser has a name attribute."""
         (tmp_path / "__init__.py").touch()  # Make it a valid project
         ctx = AnalysisContext(tmp_path)
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for name, parser in ctx.languages.all().items():
             assert hasattr(parser, "name")
             assert isinstance(parser.name, str)
@@ -424,6 +432,8 @@ def test_parser_has_extensions(self, tmp_path: Path) -> None:
         """Each parser declares extensions."""
         (tmp_path / "__init__.py").touch()
         ctx = AnalysisContext(tmp_path)
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for name, parser in ctx.languages.all().items():
             assert hasattr(parser, "extensions")
             assert isinstance(parser.extensions, (tuple, list))
@@ -432,6 +442,8 @@ def test_parser_has_fidelity(self, tmp_path: Path) -> None:
         """Each parser declares fidelity (ast or regex)."""
         (tmp_path / "__init__.py").touch()
         ctx = AnalysisContext(tmp_path)
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for name, parser in ctx.languages.all().items():
             assert hasattr(parser, "fidelity")
             assert parser.fidelity in ("ast", "regex")
@@ -440,20 +452,26 @@ def test_parser_implements_symbols(self, tmp_path: Path) -> None:
         """Each parser has symbols() method."""
         (tmp_path / "__init__.py").touch()
         ctx = AnalysisContext(tmp_path)
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for name, parser in ctx.languages.all().items():
             assert callable(getattr(parser, "symbols", None))
 
     def test_parser_implements_imports(self, tmp_path: Path) -> None:
         """Each parser has imports() method."""
         (tmp_path / "__init__.py").touch()
         ctx = AnalysisContext(tmp_path)
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for name, parser in ctx.languages.all().items():
             assert callable(getattr(parser, "imports", None))
 
     def test_parser_implements_interface(self, tmp_path: Path) -> None:
         """Each parser has interface() method."""
         (tmp_path / "__init__.py").touch()
         ctx = AnalysisContext(tmp_path)
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for name, parser in ctx.languages.all().items():
             assert callable(getattr(parser, "interface", None))
 

tests/test_paths.py

@@ -386,6 +386,8 @@ def test_rust_mod_declaration_no_prefix(
         imports = parser.imports(source, "src/main.rs")
 
         # All imports should have raw field without "mod " prefix
+        # A loop over an empty collection asserts nothing.
+        assert imports, "nothing to check: imports was empty"
         for imp in imports:
             assert not imp.raw.startswith("mod "), \
                 f"Import raw field should not start with 'mod ': {imp.raw}"

tests/test_plugin_api.py

@@ -210,6 +210,8 @@ def test_option_with_choices(self) -> None:
     def test_all_built_in_analyzers_have_options(self) -> None:
         """Every analyzer declares its options (even if empty)."""
         analyzers = available()
+        # A loop over an empty collection asserts nothing.
+        assert analyzers.items(), "nothing to check: analyzers.items() was empty"
         for name, analyzer in analyzers.items():
             assert hasattr(analyzer, "options")
             assert isinstance(analyzer.options, (list, tuple))
@@ -265,6 +267,8 @@ def test_each_language_has_at_least_one_extension(self) -> None:
         registry = language_registry()
         matrix = registry.support_matrix()
 
+        # A loop over an empty collection asserts nothing.
+        assert matrix, "nothing to check: matrix was empty"
         for row in matrix:
             exts = row["extensions"]
             # Should be a non-empty string with space-separated extensions
@@ -309,6 +313,8 @@ def test_context_all_parsers_implement_protocol(
         (tmp_path / "__init__.py").touch()
         ctx = AnalysisContext(tmp_path)
 
+        # A loop over an empty collection asserts nothing.
+        assert ctx.languages.all().items(), "nothing to check: ctx.languages.all().items() was empty"
         for lang_name, parser in ctx.languages.all().items():
             assert hasattr(parser, "symbols")
             assert hasattr(parser, "imports")

tests/test_security.py

@@ -733,6 +733,8 @@ def test_security_analyzer_max_paths_option() -> None:
     findings = result.get("findings", [])
     path_findings = [f for f in findings if "path" in f.get("id", "")]
 
+    # A loop over an empty collection asserts nothing.
+    assert path_findings, "nothing to check: path_findings was empty"
     for finding in path_findings:
         paths = finding.get("paths", [])
         assert len(paths) <= 2