1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
"""Tests for the theme-studio page generator (generate.py).
The generator's risky logic is the export-strip and the placeholder substitution
that inline colormath.js and the sample/palette data into the page. A bug there
ships a broken theme-studio.html that the JS unit tests can't see. These tests
exercise the strip in isolation and assert the assembled page has every
placeholder filled and carries the colormath body verbatim.
Run: python3 -m unittest test_generate (from scripts/theme-studio/)
"""
import os
import unittest
import generate # importable without side effects: the file write is __main__-guarded
class StripExports(unittest.TestCase):
def test_removes_the_export_line_keeps_the_body(self):
src = "function f(){return 1;}\nexport { f };"
self.assertEqual(generate.strip_exports(src), "function f(){return 1;}")
def test_preserves_multiline_body_and_rstrips_trailing_blanks(self):
src = "const a=1;\nconst b=2;\nexport { a, b };\n\n"
self.assertEqual(generate.strip_exports(src), "const a=1;\nconst b=2;")
def test_no_export_line_returns_body_rstripped(self):
self.assertEqual(generate.strip_exports("let x=1;\n"), "let x=1;")
def test_removes_every_export_line_not_just_the_last(self):
src = "export const a=1;\ncode();\nexport { a };"
self.assertEqual(generate.strip_exports(src), "code();")
def test_removes_import_lines_too(self):
# A pure module may import a peer for its own tests; the import must be
# stripped on inline (the peer is already in the page).
src = "import { rl } from './colormath.js';\nfunction f(){return rl();}"
self.assertEqual(generate.strip_exports(src), "function f(){return rl();}")
def test_matches_the_js_side_strip_so_integrity_holds(self):
# test-colormath.mjs strips with the same rule: drop lines starting with
# 'export', then trim trailing whitespace. Keep the two in lockstep.
src = "x();\nexport { x };\n"
js_equivalent = "\n".join(
l for l in src.split("\n") if not l.startswith("export")
).rstrip()
self.assertEqual(generate.strip_exports(src), js_equivalent)
class ColormathInlining(unittest.TestCase):
def setUp(self):
self.cm_src = open(os.path.join(generate.HERE, "colormath.js")).read()
def test_colormath_export_is_a_single_line(self):
# The strip is line-based, so a multi-line `export { ... }` would leave the
# continuation lines behind as a dangling block (a real bug this caught).
export_lines = [l for l in self.cm_src.splitlines() if l.startswith("export")]
self.assertEqual(len(export_lines), 1, "colormath.js must have one export line")
def test_stripped_body_has_no_export_line_and_ends_cleanly(self):
# "export" can still appear inside a comment; what must be gone is any line
# that *starts* with export (and the dangling continuation lines a
# multi-line export would leave).
body = generate.strip_exports(self.cm_src)
for line in body.splitlines():
self.assertFalse(line.startswith("export"), f"export line survived: {line!r}")
self.assertTrue(body.endswith("}"), "body should end at the last function")
class AssembledPage(unittest.TestCase):
PLACEHOLDERS = [
"STYLES_CSS", "APP_JS", "APP_CORE_J", "APP_UTIL_J",
"COLORMATH_J", "SAMPLES_J", "PALETTE_J", "CATS_J",
"UIFACES_J", "UIMAP_J", "APPS_J", "BOLD_J", "MAP_J",
]
def test_every_placeholder_is_substituted(self):
for token in self.PLACEHOLDERS:
self.assertNotIn(token, generate.HTML, f"{token} left unsubstituted")
def test_page_carries_the_colormath_body_verbatim(self):
# Python-side inline-integrity: the same guarantee the JS test asserts, but
# checked at the point the page is built rather than after a round-trip.
self.assertIn(generate.COLORMATH_BODY, generate.HTML)
def test_page_carries_the_app_core_body_verbatim(self):
# app-core.js inlines verbatim (no data placeholders), so the inlined copy
# and the unit-tested module cannot drift.
self.assertIn(generate.APP_CORE_BODY, generate.HTML)
def test_page_carries_the_app_util_body_verbatim(self):
# app-util.js inlines verbatim after its import line is stripped.
self.assertIn(generate.APP_UTIL_BODY, generate.HTML)
def test_app_util_inlined_body_has_no_import_line(self):
# The `import rl` line must be gone, or the page <script> is invalid.
for line in generate.APP_UTIL_BODY.splitlines():
self.assertFalse(line.startswith("import"), f"import survived: {line!r}")
def test_page_carries_the_stylesheet_verbatim(self):
# styles.css has no placeholders, so it inlines verbatim: the inlined copy
# and the source file cannot drift.
self.assertIn(generate.STYLES, generate.HTML)
def test_page_carries_the_app_script_faithfully(self):
# app.js does carry placeholders, so the page holds it as fill_data renders
# it (APP_FILLED), not the raw file. This guards the splice: the script
# reaches the page intact, with its data placeholders correctly filled.
self.assertIn(generate.APP_FILLED, generate.HTML)
def test_page_is_a_single_script_document(self):
self.assertEqual(generate.HTML.count("<script>"), 1)
self.assertEqual(generate.HTML.count("</script>"), 1)
class FacesHelper(unittest.TestCase):
def test_strips_prefix_and_derives_label_and_merges_seed(self):
# Normal: the prefix comes off the label, and the per-face seed is attached.
rows = generate._faces(["org-todo", "org-done"], "org-", {"org-todo": {"fg": "gold"}})
self.assertEqual(rows, [
["org-todo", "todo", {"fg": "gold"}],
["org-done", "done", {}],
])
def test_label_drops_face_suffix_and_spaces_remaining_dashes(self):
# Boundary: "-face" is removed and the rest of the dashes become spaces.
rows = generate._faces(["lsp-rename-placeholder-face"], "lsp-", {})
self.assertEqual(rows[0][1], "rename placeholder")
def test_name_without_the_prefix_is_left_intact(self):
# Boundary: a name that doesn't start with the prefix keeps its full text
# (only "-face" removal and dash-spacing apply).
rows = generate._faces(["shr-text"], "org-", {})
self.assertEqual(rows[0], ["shr-text", "shr text", {}])
def test_empty_names_gives_empty_list(self):
# Error/Boundary: nothing in, nothing out.
self.assertEqual(generate._faces([], "org-", {"org-todo": {"fg": "gold"}}), [])
if __name__ == "__main__":
unittest.main()
|
