ploop/scripts/tests/test_check_frontend_architecture.py

526 lines
21 KiB
Python

from __future__ import annotations
import json
import runpy
import shutil
import subprocess
import sys
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import patch
REPOSITORY_ROOT = Path(__file__).resolve().parents[2]
CHECKER = REPOSITORY_ROOT / "scripts" / "check_frontend_architecture.py"
STATIC_PARSER = REPOSITORY_ROOT / "scripts" / "parse_static_module_specifiers.mjs"
FIXTURES = REPOSITORY_ROOT / "scripts" / "tests" / "fixtures" / "frontend-architecture"
def run_checker(fixture: str | Path) -> subprocess.CompletedProcess[str]:
return subprocess.run(
[sys.executable, str(CHECKER), str(FIXTURES / fixture)],
cwd=REPOSITORY_ROOT,
text=True,
capture_output=True,
check=False,
)
def run_static_parser(input_text: str) -> subprocess.CompletedProcess[str]:
return subprocess.run(
["node", str(STATIC_PARSER)],
cwd=REPOSITORY_ROOT,
input=input_text,
text=True,
capture_output=True,
check=False,
)
def violation_lines(result: subprocess.CompletedProcess[str]) -> list[str]:
return [line for line in result.stdout.splitlines() if line.startswith("FEND")]
def assert_expected_violations(
test_case: unittest.TestCase, result: subprocess.CompletedProcess[str], expected: set[str]
) -> None:
lines = violation_lines(result)
test_case.assertEqual(
{line.split(maxsplit=1)[0] for line in lines}, expected, result.stdout + result.stderr
)
for line in lines:
test_case.assertRegex(line, r"^FEND\d{3} .+\.(?:ts|tsx):\d+:")
def run_checker_source(source: str, filename: str = "bad.ts") -> subprocess.CompletedProcess[str]:
with TemporaryDirectory(prefix="ploop-frontend-check-") as directory:
root = Path(directory)
path = root / "shared" / "api" / filename
path.parent.mkdir(parents=True)
path.write_text(source, encoding="utf-8")
return run_checker(root)
def assert_shared_import_at_line(
test_case: unittest.TestCase, source: str, line: int, filename: str = "bad.ts"
) -> None:
result = run_checker_source(source, filename)
test_case.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(test_case, result, {"FEND001"})
test_case.assertEqual(
[entry.split(":", 2)[:2] for entry in violation_lines(result)],
[[f"FEND001 shared/api/{filename}", str(line)]],
)
class CheckFrontendArchitectureTest(unittest.TestCase):
def test_accepts_valid_fixture(self) -> None:
result = run_checker("valid")
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertIn("violations=0", result.stdout)
def test_allows_a_route_page_to_import_its_domain_shared_code(self) -> None:
result = run_checker("valid")
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertNotIn("FEND002", result.stdout)
def test_reports_shared_importing_a_page(self) -> None:
result = run_checker("violations/fend001")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND001"})
def test_ast_reports_static_import_after_an_asi_regexp_literal(self) -> None:
result = run_checker("violations/fend001-regexp")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND001"})
self.assertEqual(
[line.split(":", 2)[:2] for line in violation_lines(result)],
[["FEND001 shared/api/bad.ts", "3"]],
)
def test_ast_reports_static_import_after_export_default_division(self) -> None:
assert_shared_import_at_line(
self,
'export default {} / 2; const slash = "/";\n'
'import { Page } from "../../pages/datasets/list/page";',
2,
)
def test_ast_reports_static_import_after_a_labeled_regexp_block(self) -> None:
assert_shared_import_at_line(
self,
'label: {} /"/.test(text);\nimport { Page } from "../../pages/datasets/list/page";',
2,
)
def test_ast_reports_static_import_after_a_case_regexp_block(self) -> None:
assert_shared_import_at_line(
self,
'switch (value) { case 1: {} /"/.test(text); }\n'
'import { Page } from "../../pages/datasets/list/page";',
2,
)
def test_ast_reports_export_from_after_a_labeled_regexp_block(self) -> None:
assert_shared_import_at_line(
self,
'label: {} /"/.test(text);\n'
'export {\n Page,\n} from "../../pages/datasets/list/page";',
2,
)
def test_ast_reports_side_effect_import_after_a_labeled_regexp_block(self) -> None:
assert_shared_import_at_line(
self,
'label: {} /"/.test(text);\nimport "../../pages/datasets/list/page";',
2,
)
def test_ast_ignores_nested_declarations_and_dynamic_imports(self) -> None:
result = run_checker_source(
'declare module "fixture" {\n'
' export { Page } from "../../pages/datasets/list/page";\n'
'}\nconst loaded = import("../../pages/datasets/list/page");\n'
)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertEqual(violation_lines(result), [])
def test_ast_uses_tsx_script_kind_for_jsx_import_text(self) -> None:
assert_shared_import_at_line(
self,
'const view = <span>import Page from "../../pages/datasets/list/page";</span>;\n'
'import { Page } from "../../pages/datasets/list/page";',
2,
filename="bad.tsx",
)
def test_ast_missing_local_compiler_names_the_frozen_install_command(self) -> None:
with TemporaryDirectory(prefix="ploop-missing-compiler-") as directory:
root = Path(directory)
shutil.copytree(
CHECKER.parent,
root / "scripts",
ignore=shutil.ignore_patterns("tests", "__pycache__"),
)
source_root = root / "source"
source_root.mkdir()
(source_root / "valid.ts").write_text("export const value = 1;\n", encoding="utf-8")
result = subprocess.run(
[sys.executable, str(root / "scripts" / CHECKER.name), str(source_root)],
cwd=root,
text=True,
capture_output=True,
check=False,
)
self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
self.assertIn("pnpm --dir frontend install --frozen-lockfile", result.stderr)
self.assertNotIn("violations=0", result.stdout)
def test_ast_checker_starts_one_parser_for_all_source_files_in_a_root(self) -> None:
checker = runpy.run_path(str(CHECKER))
with TemporaryDirectory(prefix="ploop-batched-parser-") as directory:
root = Path(directory)
shared = root / "shared"
shared.mkdir()
for name in ("first.ts", "second.tsx"):
(shared / name).write_text(
'import { Page } from "../pages/datasets/list/page";\n', encoding="utf-8"
)
with patch.object(subprocess, "run", wraps=subprocess.run) as calls:
violations = checker["check_trees"]((root,))
self.assertEqual([(item.rule_id, item.line) for item in violations], [("FEND001", 1)] * 2)
self.assertEqual(calls.call_count, 1)
def test_regexp_quotes_escapes_and_character_classes_do_not_hide_static_imports(self) -> None:
expressions = (
r"""/'"'/""",
r"/\//",
r"""/"\/'/g""",
r"""/[/"]/""",
r"/[\]/]/",
r"""/[\]/"]/""",
r"""/\\['"]/giu""",
r"""/[import Page from "../../pages/datasets/list/page";]/""",
)
for expression in expressions:
with self.subTest(expression=expression):
assert_shared_import_at_line(
self,
f"const pattern = {expression};\n"
'import { Page } from "../../pages/datasets/list/page";\n',
2,
)
def test_regexp_is_recognized_after_expression_start_tokens(self) -> None:
preludes = (
'/"/.test(text);',
'consume(/"/);',
'const patterns = [/"/];',
'function match() { /"/.test(text); }',
'const patterns = [1, /"/];',
'const patterns = { pattern: /"/ };',
'void 0; /"/.test(text);',
'const result = !/"/.test(text);',
'const result = !!/"/.test(text);',
'const result = value != /"/;',
'const result = value !== /"/;',
'const pattern = condition ? /"/ : false;',
'function match() { return /"/; }',
'function match() { throw /"/; }',
'switch (value) { case /"/: break; }',
'delete /"/.lastIndex;',
'void /"/;',
'typeof /"/;',
'value instanceof /"/;',
'value in /"/;',
'for (const pattern of /"/) {}',
'function* match() { yield /"/; }',
'const pattern = await /"/;',
'const pattern = () => /"/;',
'const pattern = /* ignored */ /"/;',
)
for prelude in preludes:
with self.subTest(prelude=prelude):
assert_shared_import_at_line(
self,
prelude + '\nimport { Page } from "../../pages/datasets/list/page";\n',
2,
)
def test_division_does_not_expose_import_text_in_a_following_string(self) -> None:
expressions = (
"6 / 2",
"total / count / 2",
"total() / 2",
"values[0] / 2",
"total.return / 2",
"total?.return / 2",
'"12" / 2',
"`12` / 2",
"total++ / 2",
"total-- / 2",
"/1/ / 2",
"/./.source.length / 2",
)
for expression in expressions:
with self.subTest(expression=expression):
assert_shared_import_at_line(
self,
f"const ratio = {expression}; "
"const example = 'import { Page } from \"../../pages/datasets/list/page\";';\n"
'import { Page } from "../../pages/datasets/list/page";\n',
2,
)
def test_non_null_assertion_preserves_division_before_a_static_import(self) -> None:
expressions = ("total! / 2", "(total!) / 2", "total!! / 2", "[total][0]! / 2")
for expression in expressions:
for separator, line in (("\n", 2), (" ", 1)):
with self.subTest(expression=expression, separator=separator):
assert_shared_import_at_line(
self,
f"const total: number | null = 6; const ratio = {expression}; "
'const slash = "/";'
+ separator
+ 'import { Page } from "../../pages/datasets/list/page";',
line,
)
def test_identifier_of_preserves_division_before_a_static_import(self) -> None:
preludes = (
'const of = 6; const ratio = of / 2; const slash = "/";',
'const of = 6; for (let ratio = of / 2; ratio < 4; ratio++) {} const slash = "/";',
'for (let of = 6; of > 0; of--) { const ratio = of / 2; const slash = "/"; }',
'const of = 6; for (const value of of / 2) {} const slash = "/";',
'const of = class {}; for (new of / 2; condition; step()) {} const slash = "/";',
)
for prelude in preludes:
for separator, line in (("\n", 2), (" ", 1)):
with self.subTest(prelude=prelude, separator=separator):
assert_shared_import_at_line(
self,
prelude
+ separator
+ 'import { Page } from "../../pages/datasets/list/page";',
line,
)
def test_control_statement_regexp_literals_preserve_static_imports(self) -> None:
preludes = (
'if (condition) /"/.test(text);',
'if ((condition && match(text))) /"/.test(text);',
'while (condition) /"/.test(text);',
'for (let index = 0; index < 2; index++) /"/.test(text);',
'if (condition) {} /"/.test(text);',
'{} /"/.test(text);',
'if (condition) {} else /"/.test(text);',
'if (condition) check(); else /"/.test(text);',
'do /"/.test(text); while (condition);',
'try {} finally {} /"/.test(text);',
'function match() {} /"/.test(text);',
'class Pattern {} /"/.test(text);',
)
for prelude in preludes:
for separator, line in (("\n", 2), (" ", 1)):
with self.subTest(prelude=prelude, separator=separator):
assert_shared_import_at_line(
self,
prelude
+ separator
+ 'import { Page } from "../../pages/datasets/list/page";',
line,
)
def test_for_of_regexp_separator_is_limited_to_the_loop_binding(self) -> None:
preludes = (
'for (const pattern of /"/) {}',
'for (const of of /"/) {}',
'for (pattern of /"/) {}',
'for (const [pattern] of /"/) {}',
'for (const {pattern} of /"/) {}',
'for (state.pattern of /"/) {}',
'for (state.in of /"/) {}',
'for await (const pattern of /"/) {}',
)
for prelude in preludes:
with self.subTest(prelude=prelude):
assert_shared_import_at_line(
self,
prelude + '\nimport { Page } from "../../pages/datasets/list/page";',
2,
)
def test_expression_closures_preserve_division_before_a_static_import(self) -> None:
expressions = (
"({}) / 2",
"(function () {}) / 2",
"function () {} / 2",
"class {} / 2",
"(() => {}) / 2",
"factory() / 2",
"object.if() / 2",
)
for expression in expressions:
with self.subTest(expression=expression):
assert_shared_import_at_line(
self,
f'const ratio = {expression}; const slash = "/";\n'
'import { Page } from "../../pages/datasets/list/page";',
2,
)
def test_regexp_preserves_multiline_static_import_export_and_side_effect_declarations(
self,
) -> None:
declarations = (
'import {\n Page,\n} from "../../pages/datasets/list/page";',
'import type {\n PageState,\n} from "../../pages/datasets/list/page";',
'export {\n Page,\n} from "../../pages/datasets/list/page";',
'export type {\n PageState,\n} from "../../pages/datasets/list/page";',
'export *\n from "../../pages/datasets/list/page";',
'import\n "../../pages/datasets/list/page";',
)
for declaration in declarations:
with self.subTest(declaration=declaration):
assert_shared_import_at_line(self, 'const pattern = /"/;\n' + declaration, 2)
def test_reports_multiline_static_imports_and_exports_at_their_starting_lines(self) -> None:
result = run_checker("violations/fend001-multiline")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND001"})
self.assertEqual(
[line.split(":", 2)[:2] for line in violation_lines(result)],
[["FEND001 shared/api/bad.ts", str(line)] for line in (3, 7, 11, 15, 18, 19)],
)
def test_reports_page_importing_another_page_internals(self) -> None:
result = run_checker("violations/fend002")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND002"})
def test_reports_route_local_model_importing_sibling_routes_and_cross_domain_shared(
self,
) -> None:
result = run_checker("violations/fend002-route-model")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND002"})
self.assertEqual(
[line.split(":", 2)[:2] for line in violation_lines(result)],
[["FEND002 pages/datasets/list/model/queries.ts", str(line)] for line in (1, 2, 3)],
)
def test_allows_route_local_model_imports_from_its_own_domain_shared_code(self) -> None:
result = run_checker("valid")
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertNotIn("FEND002", result.stdout)
def test_ignores_import_text_inside_comments_and_strings(self) -> None:
result = run_checker("valid")
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertNotIn("FEND001", result.stdout)
def test_reports_page_importing_another_domains_shared_code(self) -> None:
result = run_checker("violations/fend002-cross-domain-shared")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND002"})
def test_reports_component_fetch_and_generated_type_imports(self) -> None:
result = run_checker("violations/fend003")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND003"})
def test_reports_restricted_browser_persistence_fields(self) -> None:
result = run_checker("violations/fend004")
self.assertEqual(result.returncode, 1, result.stdout + result.stderr)
assert_expected_violations(self, result, {"FEND004"})
def test_default_make_check_includes_frontend_architecture_check(self) -> None:
result = subprocess.run(
["make", "-n", "check"],
cwd=REPOSITORY_ROOT,
text=True,
capture_output=True,
check=False,
)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertIn(
"scripts/check_frontend_architecture.py frontend/src frontend/tests/e2e", result.stdout
)
class StaticModuleParserTest(unittest.TestCase):
def test_ast_helper_returns_batched_ts_and_tsx_statement_start_lines(self) -> None:
with TemporaryDirectory(prefix="ploop-parser-input-") as directory:
root = Path(directory)
first = root / "with spaces.ts"
second = root / "view.tsx"
first.write_text(
"/* header */\n// declaration comment\nimport {\n Page,\n} from './page';\n"
"export type { PageState } from './types';\nimport './side-effect';\n",
encoding="utf-8",
)
second.write_text(
'const view = <span>import Page from "fake";</span>;\n'
"export { Page } from './tsx-page';\n",
encoding="utf-8",
)
result = run_static_parser(json.dumps([str(first), str(second)]))
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
self.assertEqual(
[json.loads(line) for line in result.stdout.splitlines()],
[
{"path": str(first), "line": 3, "specifier": "./page"},
{"path": str(first), "line": 6, "specifier": "./types"},
{"path": str(first), "line": 7, "specifier": "./side-effect"},
{"path": str(second), "line": 2, "specifier": "./tsx-page"},
],
)
def test_ast_helper_rejects_missing_or_invalid_path_input(self) -> None:
for input_text in ("", "not-json", "[]", "{}", "[42]", '["relative.ts"]'):
with self.subTest(input_text=input_text):
result = run_static_parser(input_text)
self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
self.assertEqual(result.stdout, "")
self.assertIn("source path", result.stderr)
def test_ast_helper_rejects_invalid_paths_without_partial_output(self) -> None:
with TemporaryDirectory(prefix="ploop-parser-invalid-path-") as directory:
root = Path(directory)
valid = root / "valid.ts"
valid.write_text("import './page';\n", encoding="utf-8")
folder = root / "folder.ts"
folder.mkdir()
wrong_suffix = root / "wrong.txt"
wrong_suffix.write_text("import './page';\n", encoding="utf-8")
for invalid in (root / "missing.ts", folder, wrong_suffix):
with self.subTest(path=invalid):
result = run_static_parser(json.dumps([str(valid), str(invalid)]))
self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
self.assertEqual(result.stdout, "")
self.assertIn("source path", result.stderr)
if __name__ == "__main__":
unittest.main()