style: apply ruff format to tests/test_scanner.py

Author: Coding-Dev-Tools

tests/test_scanner.py

@@ -14,6 +14,7 @@
 @pytest.fixture
 def runner():
     from click.testing import CliRunner
+
     return CliRunner()
 
 
@@ -24,8 +25,8 @@ def sample_project(tmp_path):
     utils = tmp_path / "src" / "utils.ts"
     utils.parent.mkdir(parents=True, exist_ok=True)
     utils.write_text(
-        'export function usedHelper() { return 1; }\n'
-        'export function unusedHelper() { return 2; }\n'
+        "export function usedHelper() { return 1; }\n"
+        "export function unusedHelper() { return 2; }\n"
         'export const USED_CONST = "used";\n'
         'export const UNUSED_CONST = "unused";\n'
     )
@@ -35,48 +36,39 @@ def sample_project(tmp_path):
     button.parent.mkdir(parents=True, exist_ok=True)
     button.write_text(
         'import { usedHelper, USED_CONST } from "../utils";\n'
-        'export function Button() {\n'
+        "export function Button() {\n"
         '  return <button className="btn-primary">{usedHelper()}</button>;\n'
-        '}\n'
+        "}\n"
     )
 
     # src/components/UnusedWidget.tsx - never imported
     widget = tmp_path / "src" / "components" / "UnusedWidget.tsx"
     widget.write_text(
-        'export function UnusedWidget() {\n'
-        '  return <div>Unused</div>;\n'
-        '}\n'
+        "export function UnusedWidget() {\n  return <div>Unused</div>;\n}\n"
     )
 
     # src/styles/main.css - with orphaned class
     css = tmp_path / "src" / "styles" / "main.css"
     css.parent.mkdir(parents=True, exist_ok=True)
     css.write_text(
-        '.btn-primary {\n'
-        '  background: blue;\n'
-        '}\n'
-        '.orphaned-class {\n'
-        '  color: red;\n'
-        '}\n'
+        ".btn-primary {\n  background: blue;\n}\n.orphaned-class {\n  color: red;\n}\n"
     )
 
     # src/app/page.tsx - Next.js page (entry point)
     page = tmp_path / "src" / "app" / "page.tsx"
     page.parent.mkdir(parents=True, exist_ok=True)
     page.write_text(
         'import { Button } from "../components/Button";\n'
-        'export default function Page() {\n'
-        '  return <Button />;\n'
-        '}\n'
+        "export default function Page() {\n"
+        "  return <Button />;\n"
+        "}\n"
     )
 
     # src/app/deadpage/page.tsx - dead route
     deadpage = tmp_path / "src" / "app" / "deadpage" / "page.tsx"
     deadpage.parent.mkdir(parents=True, exist_ok=True)
     deadpage.write_text(
-        'export default function DeadPage() {\n'
-        '  return <div>Dead</div>;\n'
-        '}\n'
+        "export default function DeadPage() {\n  return <div>Dead</div>;\n}\n"
     )
 
     return tmp_path
@@ -138,17 +130,22 @@ def test_scan_result_properties(self, sample_project):
         result = scanner.scan()
         # Verify all findings are categorized
         for f in result.findings:
-            assert f.category in ("unused_export", "dead_route", "orphaned_css", "unreferenced_component")
+            assert f.category in (
+                "unused_export",
+                "dead_route",
+                "orphaned_css",
+                "unreferenced_component",
+            )
 
 
 class TestExportParsing:
     def test_named_exports(self, tmp_path):
         f = tmp_path / "test.ts"
         f.write_text(
-            'export function foo() {}\n'
-            'export const bar = 1;\n'
-            'export type Baz = string;\n'
-            'export interface Qux {}\n'
+            "export function foo() {}\n"
+            "export const bar = 1;\n"
+            "export type Baz = string;\n"
+            "export interface Qux {}\n"
         )
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
@@ -161,11 +158,7 @@ def test_named_exports(self, tmp_path):
 
     def test_export_list(self, tmp_path):
         f = tmp_path / "test.ts"
-        f.write_text(
-            'const alpha = 1;\n'
-            'const beta = 2;\n'
-            'export { alpha, beta };\n'
-        )
+        f.write_text("const alpha = 1;\nconst beta = 2;\nexport { alpha, beta };\n")
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
 
@@ -175,7 +168,7 @@ def test_export_list(self, tmp_path):
 
     def test_used_exports_not_reported(self, tmp_path):
         mod = tmp_path / "mod.ts"
-        mod.write_text('export function myFunc() { return 1; }\n')
+        mod.write_text("export function myFunc() { return 1; }\n")
         app = tmp_path / "app.ts"
         app.write_text('import { myFunc } from "./mod";\nmyFunc();\n')
 
@@ -190,14 +183,13 @@ class TestCSSParsing:
     def test_orphaned_css_detection(self, tmp_path):
         css = tmp_path / "styles.css"
         css.write_text(
-            '.used-class { color: blue; }\n'
-            '.orphaned-class { color: red; }\n'
+            ".used-class { color: blue; }\n.orphaned-class { color: red; }\n"
         )
         component = tmp_path / "Component.tsx"
         component.write_text(
-            'export function Component() {\n'
+            "export function Component() {\n"
             '  return <div className="used-class">Hi</div>;\n'
-            '}\n'
+            "}\n"
         )
 
         scanner = DeadCodeScanner(tmp_path)
@@ -212,7 +204,9 @@ class TestRouteDetection:
     def test_nextjs_app_router_route(self, tmp_path):
         page = tmp_path / "app" / "about" / "page.tsx"
         page.parent.mkdir(parents=True, exist_ok=True)
-        page.write_text('export default function About() { return <div>About</div>; }\n')
+        page.write_text(
+            "export default function About() { return <div>About</div>; }\n"
+        )
 
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
@@ -223,7 +217,7 @@ def test_nextjs_app_router_route(self, tmp_path):
     def test_root_route_not_dead(self, tmp_path):
         page = tmp_path / "app" / "page.tsx"
         page.parent.mkdir(parents=True, exist_ok=True)
-        page.write_text('export default function Home() { return <div>Home</div>; }\n')
+        page.write_text("export default function Home() { return <div>Home</div>; }\n")
 
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
@@ -240,7 +234,9 @@ def test_linked_route_not_dead(self, tmp_path):
         )
         about = tmp_path / "app" / "about" / "page.tsx"
         about.parent.mkdir(parents=True, exist_ok=True)
-        about.write_text('export default function About() { return <div>About</div>; }\n')
+        about.write_text(
+            "export default function About() { return <div>About</div>; }\n"
+        )
 
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
@@ -268,14 +264,18 @@ def test_scan_command(self, runner, sample_project):
         assert "DeadCode Scan" in result.output
 
     def test_scan_json_output(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--json-output"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--json-output"]
+        )
         assert result.exit_code == 0
         data = json.loads(result.output, strict=False)
         assert "findings" in data
         assert "files_scanned" in data
 
     def test_scan_category_filter(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "-c", "orphaned_css"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "-c", "orphaned_css"]
+        )
         assert result.exit_code == 0
         # Text output should mention the category
         assert "Orphaned CSS" in result.output
@@ -287,7 +287,11 @@ def test_scan_nonexistent_dir(self, runner):
     def test_remove_dry_run(self, runner, sample_project):
         result = runner.invoke(cli, ["-p", str(sample_project), "remove", "--dry-run"])
         assert result.exit_code == 0
-        assert "WOULD REMOVE" in result.output or "Nothing removable" in result.output or result.exit_code == 0
+        assert (
+            "WOULD REMOVE" in result.output
+            or "Nothing removable" in result.output
+            or result.exit_code == 0
+        )
 
     def test_stats_command(self, runner, sample_project):
         result = runner.invoke(cli, ["-p", str(sample_project), "stats"])
@@ -299,24 +303,32 @@ def test_scan_ignore_option(self, runner, tmp_path):
         """--ignore option should exclude matching files from scan."""
         mod = tmp_path / "src" / "mod.ts"
         mod.parent.mkdir(parents=True, exist_ok=True)
-        mod.write_text('export function unusedFunc() { return 1; }\n')
+        mod.write_text("export function unusedFunc() { return 1; }\n")
 
-        result = runner.invoke(cli, ["-p", str(tmp_path), "-i", "src/", "scan", "--json-output"])
+        result = runner.invoke(
+            cli, ["-p", str(tmp_path), "-i", "src/", "scan", "--json-output"]
+        )
         assert result.exit_code == 0
         import json
+
         data = json.loads(result.output, strict=False)
         assert data["files_scanned"] == 0, "src/ ignored, should have 0 files"
 
     def test_remove_category_filter(self, runner, sample_project):
         """remove --dry-run --category should filter by category."""
-        result = runner.invoke(cli, ["-p", str(sample_project), "remove", "--dry-run", "-c", "orphaned_css"])
+        result = runner.invoke(
+            cli,
+            ["-p", str(sample_project), "remove", "--dry-run", "-c", "orphaned_css"],
+        )
         assert result.exit_code == 0
         # Should mention orphaned class
         assert "orphaned-class" in result.output or "Nothing removable" in result.output
 
     def test_remove_nonexistent_dir(self, runner):
         """remove should give graceful error for nonexistent project dir."""
-        result = runner.invoke(cli, ["-p", "/nonexistent/test/path", "remove", "--dry-run"])
+        result = runner.invoke(
+            cli, ["-p", "/nonexistent/test/path", "remove", "--dry-run"]
+        )
         assert result.exit_code != 0
         assert "not found" in result.output
 
@@ -331,9 +343,11 @@ def test_main_module_entry_point(self, runner):
         """Test that python -m deadcode works (__main__ entry point fix)."""
         import subprocess
         import sys
+
         result = subprocess.run(
             [sys.executable, "-m", "deadcode", "--help"],
-            capture_output=True, text=True,
+            capture_output=True,
+            text=True,
             cwd=str(Path(__file__).parent.parent / "src"),
         )
         assert result.returncode == 0
@@ -385,8 +399,12 @@ def test_multiline_export_list_used_not_reported(self, tmp_path):
 
         export_names = {f.name for f in result.unused_exports}
         # usedInApp appears in both an inline export and the export-list; it's imported so should be absent
-        assert "usedInApp" not in export_names, "usedInApp is imported — should not be reported"
-        assert "alsoUnused" in export_names, "alsoUnused is never imported — should be reported"
+        assert "usedInApp" not in export_names, (
+            "usedInApp is imported — should not be reported"
+        )
+        assert "alsoUnused" in export_names, (
+            "alsoUnused is never imported — should be reported"
+        )
 
     def test_multiline_export_list_with_aliases(self, tmp_path):
         """export { Foo as Bar } aliases: the local name Foo should be tracked, not the alias."""
@@ -412,11 +430,7 @@ def test_single_line_export_list_still_works(self, tmp_path):
         """Single-line export { Foo, Bar } should continue to work after the fix."""
         mod = tmp_path / "src" / "mod.ts"
         mod.parent.mkdir(parents=True, exist_ok=True)
-        mod.write_text(
-            "const alpha = 1;\n"
-            "const beta = 2;\n"
-            "export { alpha, beta };\n"
-        )
+        mod.write_text("const alpha = 1;\nconst beta = 2;\nexport { alpha, beta };\n")
 
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
@@ -454,11 +468,11 @@ def test_include_patterns_filters_files(self, tmp_path):
         # Create files in two dirs
         mod = tmp_path / "src" / "mod.ts"
         mod.parent.mkdir(parents=True, exist_ok=True)
-        mod.write_text('export function foo() { return 1; }\\n')
+        mod.write_text("export function foo() { return 1; }\\n")
 
         lib = tmp_path / "lib" / "helper.ts"
         lib.parent.mkdir(parents=True, exist_ok=True)
-        lib.write_text('export function bar() { return 2; }\\n')
+        lib.write_text("export function bar() { return 2; }\\n")
 
         scanner = DeadCodeScanner(tmp_path, include_patterns=["src/"])
         result = scanner.scan()
@@ -470,11 +484,11 @@ def test_include_patterns_allows_multiple(self, tmp_path):
         """include_patterns can specify multiple directories."""
         mod = tmp_path / "src" / "mod.ts"
         mod.parent.mkdir(parents=True, exist_ok=True)
-        mod.write_text('export function foo() { return 1; }\\n')
+        mod.write_text("export function foo() { return 1; }\\n")
 
         lib = tmp_path / "lib" / "helper.ts"
         lib.parent.mkdir(parents=True, exist_ok=True)
-        lib.write_text('export function bar() { return 2; }\\n')
+        lib.write_text("export function bar() { return 2; }\\n")
 
         scanner = DeadCodeScanner(tmp_path, include_patterns=["src/", "lib/"])
         result = scanner.scan()
@@ -484,45 +498,58 @@ def test_include_patterns_none_scans_all(self, tmp_path):
         """When include_patterns is None, all scannable files are included."""
         mod = tmp_path / "src" / "mod.ts"
         mod.parent.mkdir(parents=True, exist_ok=True)
-        mod.write_text('export function foo() { return 1; }\\n')
+        mod.write_text("export function foo() { return 1; }\\n")
 
         lib = tmp_path / "lib" / "helper.ts"
         lib.parent.mkdir(parents=True, exist_ok=True)
-        lib.write_text('export function bar() { return 2; }\\n')
+        lib.write_text("export function bar() { return 2; }\\n")
 
         scanner = DeadCodeScanner(tmp_path)
         result = scanner.scan()
         assert result.files_scanned == 2
 
+
 class TestScanFormat:
     """Tests for the new --format scan option."""
 
     def test_format_compact(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--format=compact"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--format=compact"]
+        )
         assert result.exit_code == 0
 
     def test_format_github(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--format=github"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--format=github"]
+        )
         assert result.exit_code == 0
 
     def test_format_compact_with_findings(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--format=compact"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--format=compact"]
+        )
         assert result.exit_code == 0
         assert "unusedHelper" in result.output or "No dead code" in result.output
 
     def test_format_github_with_findings(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--format=github"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--format=github"]
+        )
         assert result.exit_code == 0
         assert "::" in result.output or "No dead code" in result.output
 
     def test_format_json_legacy_alias(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--json-output"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--json-output"]
+        )
         assert result.exit_code == 0
         data = json.loads(result.output, strict=False)
         assert "findings" in data
 
     def test_format_json_explicit(self, runner, sample_project):
-        result = runner.invoke(cli, ["-p", str(sample_project), "scan", "--format=json"])
+        result = runner.invoke(
+            cli, ["-p", str(sample_project), "scan", "--format=json"]
+        )
         assert result.exit_code == 0
         data = json.loads(result.output, strict=False)
         assert "findings" in data