0.0.5-alpha.8

tests/test_rust_audits.py

@@ -1,7 +1,7 @@
 # file: tests/test_rust_audits.py
-# version: 1
+# version: 2
 
-"""Targeted contracts for the two optional Rust style audits."""
+"""Targeted contracts for the optional monotask Rust structure audits."""
 
 from __future__ import annotations
 
@@ -15,6 +15,10 @@ sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1] / "scripts"))
 
 from audit_rust_blank_lines import audit_file as audit_blanks  # noqa: E402
 from audit_rust_const_blocks import audit_file as audit_consts  # noqa: E402
+from audit_rust_item_spacing import audit_file as audit_item_spacing  # noqa: E402
+from audit_rust_module_order import audit_file as audit_module_order  # noqa: E402
+from audit_rust_reexport_blocks import audit_file as audit_reexports  # noqa: E402
+from audit_rust_trait_import_blocks import audit_file as audit_trait_imports  # noqa: E402
 from _rust_audit_common import selected_files  # noqa: E402
 
 
@@ -132,6 +136,125 @@ const ALPHA: u8 = 2;
         self.assertEqual(run(path).returncode, 1)
         self.assertEqual(run(self.root / "missing.rs").returncode, 2)
 
+    def test_item_spacing_between_distinct_items(self) -> None:
+        path = self.source("""struct Alpha {}
+struct Beta {}
+
+fn sample() {}
+""")
+        issues = audit_item_spacing(path)
+        self.assertTrue(any("exactly one blank line" in issue for issue in issues))
+
+    def test_item_spacing_delegates_compact_declaration_blocks(self) -> None:
+        path = self.source("""const ALPHA: u8 = 1;
+
+const BETA: u8 = 2;
+
+static CACHE: u8 = 0;
+static READY: u8 = 1;
+
+type First = u8;
+type Second = u16;
+""")
+        self.assertEqual(audit_item_spacing(path), [])
+
+    def test_item_spacing_inside_impl(self) -> None:
+        path = self.source("""struct Sample {}
+
+impl Sample {
+    fn alpha() {}
+    fn beta() {}
+}
+""")
+        self.assertTrue(any("exactly one blank line" in issue for issue in audit_item_spacing(path)))
+
+    def test_item_spacing_does_not_infer_across_macro(self) -> None:
+        path = self.source("""struct Alpha {}
+macro_rules! generated { () => {}; }
+struct Beta {}
+""")
+        self.assertEqual(audit_item_spacing(path), [])
+
+    def test_module_order_production_and_tests(self) -> None:
+        path = self.source("""mod beta;
+mod alpha;
+#[cfg(test)]
+mod tests;
+""")
+        issues = audit_module_order(path)
+        self.assertTrue(any("production" in issue for issue in issues))
+        path.write_text("#[cfg(test)]\nmod tests;\nmod alpha;\n", encoding="utf-8")
+        self.assertTrue(any("test modules must follow" in issue for issue in audit_module_order(path)))
+
+    def test_module_order_clean_with_path_attribute(self) -> None:
+        path = self.source("""mod alpha;
+mod beta;
+
+#[cfg(test)]
+#[path = "unit_tests/mod.rs"]
+mod unit_tests;
+""")
+        self.assertEqual(audit_module_order(path), [])
+
+    def test_reexport_blocks_visibility_and_spacing(self) -> None:
+        path = self.source("""pub(crate) use self::internal::Internal;
+
+pub use self::public::Public;
+""")
+        issues = audit_reexports(path)
+        self.assertTrue(any("must precede" in issue for issue in issues))
+        path.write_text("pub use self::public::Alpha;\n\npub use self::public::Beta;\n", encoding="utf-8")
+        self.assertTrue(any("contains an empty line" in issue for issue in audit_reexports(path)))
+
+    def test_reexport_blocks_clean_with_rustdocs(self) -> None:
+        path = self.source("""/// Alpha.
+pub use self::public::Alpha;
+/// Beta.
+pub use self::public::Beta;
+
+/// Internal.
+pub(crate) use self::internal::Internal;
+""")
+        self.assertEqual(audit_reexports(path), [])
+
+    def test_trait_import_block_layout(self) -> None:
+        path = self.source("""use alpha::AlphaTrait;
+
+use beta::BetaTrait;
+
+struct Sample {}
+""")
+        self.assertTrue(any("contains an empty line" in issue for issue in audit_trait_imports(path)))
+        path.write_text("struct Sample {}\n\nuse alpha::AlphaTrait;\n", encoding="utf-8")
+        self.assertTrue(any("must precede" in issue for issue in audit_trait_imports(path)))
+
+    def test_trait_import_block_clean_and_exports_ignored(self) -> None:
+        path = self.source("""mod alpha;
+
+use alpha::AlphaTrait;
+use beta::BetaTrait;
+
+struct Sample {}
+
+pub use self::alpha::Alpha;
+""")
+        self.assertEqual(audit_trait_imports(path), [])
+
+    def test_new_audit_cli_statuses(self) -> None:
+        path = self.source("mod alpha;\nmod beta;\n")
+        root = pathlib.Path(__file__).resolve().parents[1] / "scripts"
+        scripts = (
+            root / "audit_rust_item_spacing.py",
+            root / "audit_rust_module_order.py",
+            root / "audit_rust_reexport_blocks.py",
+            root / "audit_rust_trait_import_blocks.py",
+        )
+        for script in scripts:
+            result = subprocess.run([sys.executable, "-B", str(script), str(path)], capture_output=True, text=True, check=False)
+            self.assertEqual(result.returncode, 0, (script, result.stderr))
+            missing = subprocess.run([sys.executable, "-B", str(script), str(self.root / "missing.rs")], capture_output=True, text=True, check=False)
+            self.assertEqual(missing.returncode, 2, (script, missing.stderr))
+
 
 if __name__ == "__main__":
     unittest.main()