diff options
Diffstat (limited to 'scripts/theme-studio/test_generate.py')
| -rw-r--r-- | scripts/theme-studio/test_generate.py | 387 |
1 files changed, 381 insertions, 6 deletions
diff --git a/scripts/theme-studio/test_generate.py b/scripts/theme-studio/test_generate.py index ee13f8de..4e9afb1e 100644 --- a/scripts/theme-studio/test_generate.py +++ b/scripts/theme-studio/test_generate.py @@ -9,9 +9,17 @@ placeholder filled and carries the colormath body verbatim. Run: python3 -m unittest test_generate (from scripts/theme-studio/) """ import os +import io +import tempfile +import runpy import unittest +from collections import Counter, defaultdict +from contextlib import redirect_stdout import generate # importable without side effects: the file write is __main__-guarded +from app_inventory import face_rows +from default_faces import DefaultFaces, changed_summary +from face_specs import face_spec, package_face_spec, ui_face_spec class StripExports(unittest.TestCase): @@ -48,7 +56,8 @@ class StripExports(unittest.TestCase): class ColormathInlining(unittest.TestCase): def setUp(self): - self.cm_src = open(os.path.join(generate.HERE, "colormath.js")).read() + with open(os.path.join(generate.HERE, "colormath.js")) as src: + self.cm_src = src.read() def test_colormath_export_is_a_single_line(self): # The strip is line-based, so a multi-line `export { ... }` would leave the @@ -69,8 +78,9 @@ class ColormathInlining(unittest.TestCase): class AssembledPage(unittest.TestCase): PLACEHOLDERS = [ "STYLES_CSS", "APP_JS", "APP_CORE_J", "APP_UTIL_J", + "PALETTE_ACTIONS_J", "BROWSER_GATES_J", "COLORMATH_J", "SAMPLES_J", "PALETTE_J", "CATS_J", - "UIFACES_J", "UIMAP_J", "APPS_J", "BOLD_J", "MAP_J", + "UIFACES_J", "UIMAP_J", "APPS_J", "SYNTAX_J", "MAP_J", ] def test_every_placeholder_is_substituted(self): @@ -91,6 +101,12 @@ class AssembledPage(unittest.TestCase): # app-util.js inlines verbatim after its import line is stripped. self.assertIn(generate.APP_UTIL_BODY, generate.HTML) + def test_page_carries_palette_actions_verbatim(self): + self.assertIn(generate.PALETTE_ACTIONS_BODY, generate.HTML) + + def test_page_carries_browser_gates_verbatim(self): + self.assertIn(generate.BROWSER_GATES_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(): @@ -112,10 +128,39 @@ class AssembledPage(unittest.TestCase): self.assertEqual(generate.HTML.count("</script>"), 1) +class LanguageSamples(unittest.TestCase): + def _tokens(self, lang): + return [tok for line in generate.SAMPLES[lang] for tok in line] + + def test_rust_and_zig_are_available_in_the_language_selector(self): + self.assertIn("Rust", generate.SAMPLES) + self.assertIn("Zig", generate.SAMPLES) + + def test_rust_sample_exercises_language_specific_categories(self): + tokens = self._tokens("Rust") + cats = {k for k, _ in tokens} + text = "".join(t for _, t in tokens) + for cat in ("dec", "ty", "bi", "kw", "op", "var"): + self.assertIn(cat, cats) + self.assertIn("'a", text) + self.assertIn("trait", text) + self.assertIn("vec!", text) + + def test_zig_sample_exercises_language_specific_categories(self): + tokens = self._tokens("Zig") + cats = {k for k, _ in tokens} + text = "".join(t for _, t in tokens) + for cat in ("bi", "kw", "ty", "con", "op", "prop"): + self.assertIn(cat, cats) + self.assertIn("comptime", text) + self.assertIn("@import", text) + self.assertIn("error.MissingColor", text) + + 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"}}) + rows = face_rows(["org-todo", "org-done"], "org-", {"org-todo": {"fg": "gold"}}) self.assertEqual(rows, [ ["org-todo", "todo", {"fg": "gold"}], ["org-done", "done", {}], @@ -123,18 +168,348 @@ class FacesHelper(unittest.TestCase): 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-", {}) + rows = face_rows(["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-", {}) + rows = face_rows(["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"}}), []) + self.assertEqual(face_rows([], "org-", {"org-todo": {"fg": "gold"}}), []) + + +class FaceSpecDefaults(unittest.TestCase): + def test_ui_face_spec_fills_style_fields(self): + self.assertEqual(ui_face_spec({"bg": "#ffffff", "bold": True}), { + "fg": None, + "bg": "#ffffff", + "bold": True, + "italic": False, + "underline": False, + "strike": False, + "box": None, + }) + + def test_package_face_spec_fills_structure_fields(self): + self.assertEqual(package_face_spec({"inherit": "base", "height": 1.2}), { + "fg": None, + "bg": None, + "bold": False, + "italic": False, + "underline": False, + "strike": False, + "inherit": "base", + "height": 1.2, + "box": None, + }) + + def test_generated_color_names_are_base_columns_when_legacy(self): + self.assertEqual(generate.column_id("color-22"), "color-22") + self.assertEqual(generate.column_id("color-129"), "color-129") + self.assertEqual(generate.column_id("blue-1"), "blue") + self.assertEqual(generate.column_id("blue+1"), "blue") + self.assertEqual(generate.column_id("blue1"), "blue") + self.assertEqual(generate.column_id("grey80"), "grey") + self.assertEqual(generate.column_id("orchid3"), "orchid") + + +class GeneratorStateHelpers(unittest.TestCase): + def test_initial_maps_use_column_fallbacks_without_defaults_snapshot(self): + cols = {"kw": [None, True], "str": [None, False]} + color_map, bold, italic = generate.initial_maps(cols, DefaultFaces(None)) + self.assertEqual(color_map["bg"], "#000000") + self.assertEqual(color_map["p"], "#ffffff") + self.assertTrue(bold["kw"]) + self.assertFalse(bold["str"]) + self.assertFalse(italic["kw"]) + + def test_build_uimap_uses_fallback_styles_without_defaults_snapshot(self): + uimap = generate.build_uimap(generate.UI_FACES, DefaultFaces(None)) + self.assertTrue(uimap["link"]["underline"]) + self.assertEqual(uimap["mode-line"]["box"], {"style": "released", "width": 1, "color": None}) + + def test_build_syntax_uses_map_and_style_fallbacks_without_defaults_snapshot(self): + syntax = generate.build_syntax( + {"kw": [None, True]}, + {"kw": "#d3d3d3"}, + {"kw": True}, + {"kw": False}, + DefaultFaces(None), + ) + self.assertEqual(syntax["kw"]["fg"], "#d3d3d3") + self.assertTrue(syntax["kw"]["bold"]) + self.assertFalse(syntax["kw"]["italic"]) + + def test_builtin_fallback_styles_fill_known_emacs_styles(self): + uimap = { + name: ui_face_spec() + for name in ( + "link", "lazy-highlight", "show-paren-match", + "error", "warning", "success", + "mode-line", "mode-line-inactive", + ) + } + generate.apply_builtin_fallback_styles(uimap) + self.assertTrue(uimap["link"]["underline"]) + self.assertTrue(uimap["lazy-highlight"]["underline"]) + self.assertTrue(uimap["show-paren-match"]["underline"]) + self.assertTrue(uimap["error"]["bold"]) + self.assertTrue(uimap["warning"]["bold"]) + self.assertTrue(uimap["success"]["bold"]) + self.assertEqual(uimap["mode-line"]["box"], {"style": "released", "width": 1, "color": None}) + self.assertEqual(uimap["mode-line-inactive"]["box"], {"style": "released", "width": 1, "color": None}) + + def test_seed_basics_replace_palette_ui_and_locks(self): + palette = [["#ffffff", "bg", "ground"]] + uimap = {"region": ui_face_spec()} + data = { + "palette": [["#101010", "bg", "ground"], ["#eeeeee", "fg", "ground"]], + "ui": {"region": ui_face_spec({"bg": "#67809c"})}, + "locks": ["region"], + } + seeded_palette, seeded_ui, locks = generate.apply_seed_basics(data, palette, uimap, []) + self.assertEqual(seeded_palette, data["palette"]) + self.assertEqual(seeded_ui["region"]["bg"], "#67809c") + self.assertEqual(locks, ["region"]) + + def test_load_seed_data_reads_relative_json_seed(self): + with tempfile.NamedTemporaryFile("w", dir=generate.HERE, suffix=".json", delete=False) as tmp: + tmp.write('{"locks":["kw"]}') + name = os.path.basename(tmp.name) + try: + self.assertEqual(generate.load_seed_data(name), {"locks": ["kw"]}) + finally: + os.unlink(tmp.name) + + def test_syntax_seed_updates_known_roles_and_map(self): + syntax = {"kw": face_spec(), "str": face_spec({"fg": "#111111"})} + color_map = {"kw": "", "str": "#111111"} + generate.apply_syntax_seed({ + "syntax": { + "kw": {"fg": "#222222", "bold": True}, + "unknown": {"fg": "#ff0000"}, + } + }, syntax, color_map) + self.assertEqual(syntax["kw"]["fg"], "#222222") + self.assertTrue(syntax["kw"]["bold"]) + self.assertEqual(color_map["kw"], "#222222") + self.assertNotIn("unknown", syntax) + + def test_seed_package_overrides_replace_known_package_faces(self): + apps = {"demo": {"faces": [["demo-face", "face", {"fg": "#111111"}]]}} + generate.apply_seed_packages(apps, { + "packages": {"demo": {"demo-face": {"fg": "#222222", "source": "user"}}} + }, "seed.json") + self.assertEqual(apps["demo"]["faces"][0][2]["fg"], "#222222") + self.assertEqual(apps["demo"]["faces"][0][2]["source"], "user") + + def test_palette_color_names_are_unique_and_stable_columns(self): + palette = [["#111111", "blue", "blue"]] + defaults = DefaultFaces(None) + generate.add_palette_color(palette, defaults, "#222222", "blue") + self.assertEqual(palette[-1], ["#222222", "blue-2", "blue"]) + + def test_default_palette_collection_includes_box_colors(self): + palette = [["#000000", "bg", "ground"], ["#ffffff", "fg", "ground"]] + defaults = DefaultFaces(None) + generate.add_default_palette_colors( + palette, + {"bg": "#000000", "p": "#ffffff", "kw": "#111111"}, + {"kw": face_spec({"fg": "#111111", "bg": "#222222", "box": {"color": "#333333"}})}, + {"region": ui_face_spec({"fg": "#444444", "bg": "#555555", "box": {"color": "#666666"}})}, + {"demo": {"faces": [["demo-face", "face", {"fg": "#777777", "bg": "#888888", "box": {"color": "#999999"}}]]}}, + defaults, + ) + colors = {entry[0] for entry in palette} + for color in ("#333333", "#666666", "#999999"): + self.assertIn(color, colors) + + def test_render_theme_studio_writes_html_to_requested_path(self): + with tempfile.NamedTemporaryFile(delete=False) as tmp: + path = tmp.name + try: + out = io.StringIO() + with redirect_stdout(out): + generate.render_theme_studio(path) + self.assertIn("wrote " + path, out.getvalue()) + with open(path) as generated: + self.assertIn("<!doctype html>", generated.read().lower()) + finally: + os.unlink(path) + + def test_generate_script_entrypoint_writes_default_output(self): + out = io.StringIO() + with redirect_stdout(out): + runpy.run_path(generate.__file__, run_name="__main__") + self.assertIn("wrote " + generate.OUT, out.getvalue()) + + +class DefaultFaceAdapter(unittest.TestCase): + def setUp(self): + self.defaults = DefaultFaces({ + "faces": { + "sample": { + "chosenGuiLight": { + "foreground": "gray20", + "foregroundHex": "#333333", + "background": "white", + "backgroundHex": "#ffffff", + "weight": "bold", + "slant": "italic", + "underline": True, + "inherit": "parent", + "box": [":line-width", ["cons", 2, 2], ":style", "released-button"], + }, + "effectiveGuiLight": {"foreground": "black", "foregroundHex": "#000000"}, + }, + "boxed": { + "chosenGuiLight": { + "box": [":line-width", -3, ":color", "gray20"], + }, + "effectiveGuiLight": {}, + }, + } + }) + + def test_seed_uses_own_face_attributes_and_converts_boxes(self): + self.assertEqual(self.defaults.seed("sample", effective=False), { + "fg": "#333333", + "bg": "#ffffff", + "bold": True, + "italic": True, + "underline": True, + "inherit": "parent", + "box": {"style": "released", "width": 2, "color": None}, + }) + + def test_color_reads_effective_hex_by_default(self): + self.assertEqual(self.defaults.color("sample"), "#000000") + + def test_line_box_keeps_width_and_resolves_named_color(self): + self.assertEqual(self.defaults.seed("boxed")["box"], { + "style": "line", + "width": 3, + "color": "#333333", + }) + + def test_label_uses_captured_color_name_when_present(self): + self.assertEqual(self.defaults.label("#333333", "fallback"), "gray20") + + def test_missing_snapshot_is_safe(self): + defaults = DefaultFaces(None) + self.assertFalse(defaults.available) + self.assertEqual(defaults.face("missing"), {}) + self.assertEqual(defaults.seed("missing"), {}) + self.assertEqual(defaults.label("#000000", "fallback"), "fallback") + + def test_summary_reports_default_drift_fields(self): + defaults = DefaultFaces({ + "meta": {"emacs-version": "30.2", "package-unresolved-face-count": 2}, + "ui-faces": ["sample"], + "package-inventory": {"pkg": ["pkg-face"]}, + "faces": { + "default": { + "effectiveGuiLight": { + "foregroundHex": "#000000", + "backgroundHex": "#ffffff", + }, + "chosenGuiLight": {}, + }, + "sample": { + "chosenGuiLight": {"backgroundHex": "#ffffff"}, + "effectiveGuiLight": {}, + }, + "pkg-face": { + "chosenGuiLight": {"inherit": "base-face"}, + "effectiveGuiLight": {}, + }, + }, + }) + self.assertEqual(defaults.summary(), { + "emacsVersion": "30.2", + "default": {"foreground": "#000000", "background": "#ffffff"}, + "faceCount": 3, + "packageFaceCount": 1, + "packageUnresolvedFaceCount": 2, + "uiOwnSeeds": {"sample": {"bg": "#ffffff"}}, + "packageInherits": {"pkg-face": "base-face"}, + }) + + def test_changed_summary_reports_only_changed_top_level_keys(self): + self.assertEqual(changed_summary({"a": 1, "b": 2}, {"a": 1, "b": 3, "c": 4}), { + "b": {"before": 2, "after": 3}, + "c": {"before": None, "after": 4}, + }) + + +class PackageFaceCoverage(unittest.TestCase): + ALLOWED_DUPLICATES = { + "magit-left-margin": ["magit", "magit-section"], + "magit-section-child-count": ["magit", "magit-section"], + "magit-section-heading": ["magit", "magit-section"], + "magit-section-heading-selection": ["magit", "magit-section"], + "magit-section-highlight": ["magit", "magit-section"], + "magit-section-secondary-heading": ["magit", "magit-section"], + } + + def app_faces(self): + rows = [] + for app, data in generate.APPS.items(): + for face, _label, _seed in data["faces"]: + rows.append((face, app)) + return rows + + def inventory_faces(self): + inventory = generate.DEFAULTS.data.get("package-inventory", {}) + return {face for faces in inventory.values() for face in faces} + + def test_every_inventory_face_has_a_theme_studio_row(self): + app_face_names = {face for face, _app in self.app_faces()} + self.assertEqual(sorted(self.inventory_faces() - app_face_names), []) + + def test_duplicate_rows_are_intentional(self): + counts = Counter(face for face, _app in self.app_faces()) + actual = defaultdict(list) + for face, app in self.app_faces(): + if counts[face] > 1: + actual[face].append(app) + self.assertEqual(dict(sorted(actual.items())), self.ALLOWED_DUPLICATES) + + +class GeneratedDefaults(unittest.TestCase): + def package_seed(self, app, face): + for row_face, _label, seed in generate.APPS[app]["faces"]: + if row_face == face: + return seed + self.fail(f"{app}/{face} is not in generated APPS") + + def test_ground_defaults_match_emacs_q_light_default(self): + self.assertEqual(generate.MAP["bg"], "#ffffff") + self.assertEqual(generate.MAP["p"], "#000000") + self.assertEqual(generate.PALETTE[:2], [["#ffffff", "bg", "ground"], ["#000000", "fg", "ground"]]) + + def test_ui_defaults_preserve_own_overlay_and_modeline_specs(self): + self.assertEqual(generate.UIMAP["lazy-highlight"]["bg"], "#afeeee") + self.assertIsNone(generate.UIMAP["lazy-highlight"]["fg"]) + self.assertEqual(generate.UIMAP["mode-line"]["box"], {"style": "released", "width": 1, "color": None}) + self.assertEqual(generate.UIMAP["mode-line-inactive"]["inherit"], "mode-line") + self.assertEqual(generate.UIMAP["mode-line-inactive"]["box"], {"style": "line", "width": 1, "color": "#bfbfbf"}) + + def test_representative_package_inherits_are_selected(self): + self.assertEqual(self.package_seed("elfeed", "elfeed-search-filter-face")["inherit"], "mode-line-buffer-id") + self.assertEqual(self.package_seed("ghostel", "ghostel-default")["inherit"], "default") + + def test_syntax_defaults_capture_font_lock_styles(self): + self.assertEqual(generate.MAP["kw"], "#d3d3d3") + self.assertTrue(generate.SYNTAX["kw"]["bold"]) + self.assertFalse(generate.SYNTAX["kw"]["italic"]) + self.assertEqual(generate.MAP["str"], "#696969") + self.assertFalse(generate.SYNTAX["str"]["bold"]) + self.assertTrue(generate.SYNTAX["str"]["italic"]) if __name__ == "__main__": |