spec-to-ui 0.1.0 → 0.2.0

package/skills/ui-ux-pro-max/scripts/tests/test_core.py

@@ -0,0 +1,343 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Stdlib-only regression tests for core.py / design_system.py (unittest, not
+pytest -- this project ships with zero external dependencies and the tests
+shouldn't add one).
+
+Run with:
+    python -m unittest discover -s scripts/tests -v
+or directly:
+    python scripts/tests/test_core.py
+"""
+
+import os
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from unittest.mock import patch
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+import core
+from core import BM25, detect_domain, search, search_stack, CSV_CONFIG, AVAILABLE_STACKS
+from design_system import DesignSystemGenerator, generate_design_system
+
+
+class TestTokenizer(unittest.TestCase):
+    def test_short_domain_terms_are_kept(self):
+        bm25 = BM25()
+        tokens = bm25.tokenize("UI and UX design with 3D and AI")
+        self.assertIn("ui", tokens)
+        self.assertIn("3d", tokens)
+        self.assertIn("ai", tokens)
+
+    def test_stopwords_removed(self):
+        bm25 = BM25()
+        tokens = bm25.tokenize("this is for the team to do")
+        for stopword in ("is", "for", "the", "to", "do"):
+            self.assertNotIn(stopword, tokens)
+
+    def test_synonym_normalization(self):
+        bm25 = BM25()
+        self.assertEqual(bm25.tokenize("e-commerce store"), bm25.tokenize("ecommerce store"))
+        self.assertEqual(bm25.tokenize("dark-mode toggle"), bm25.tokenize("dark toggle"))
+
+    def test_boundary_safe_nav_normalization_preserves_existing_words(self):
+        bm25 = BM25()
+        tokens = bm25.tokenize("nav navigation navbar")
+        self.assertIn("navigation", tokens)
+        self.assertIn("navbar", tokens)
+        self.assertNotIn("navigationigation", tokens)
+        self.assertNotIn("navigationbar", tokens)
+
+    def test_punctuation_and_uk_variants_normalize_to_canonical_tokens(self):
+        bm25 = BM25()
+        tokens = bm25.tokenize("colour, organisation; behaviour customisation")
+        for expected in ("color", "organization", "behavior", "customization"):
+            self.assertIn(expected, tokens)
+
+
+class TestBm25CoreBehavior(unittest.TestCase):
+    def test_empty_documents_produce_no_scores_or_vocab(self):
+        bm25 = BM25()
+        bm25.fit([])
+        self.assertEqual(bm25.score("anything"), [])
+        self.assertEqual(bm25.vocabulary(), [])
+
+    def test_bm25_cache_rebuilds_after_file_mtime_changes(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "search.csv"
+            path.write_text("Name,Keywords\nAlpha,alpha token\n", encoding="utf-8")
+            results_a, bm25_a = core._search_csv(path, ["Name", "Keywords"], ["Name"], "alpha", 1)
+            self.assertEqual(results_a[0]["Name"], "Alpha")
+
+            path.write_text("Name,Keywords\nBeta,beta token\n", encoding="utf-8")
+            stat = path.stat()
+            os.utime(path, ns=(stat.st_atime_ns + 1_000_000_000, stat.st_mtime_ns + 1_000_000_000))
+
+            results_b, bm25_b = core._search_csv(path, ["Name", "Keywords"], ["Name"], "beta", 1)
+            self.assertEqual(results_b[0]["Name"], "Beta")
+            self.assertIsNot(bm25_a, bm25_b)
+
+    def test_search_uses_one_verified_rows_and_index_snapshot(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "search.csv"
+            path.write_text("Name,Keywords\nAlpha,alpha token\n", encoding="utf-8")
+            original_get_bm25 = core._get_bm25
+            replaced = False
+
+            def replace_after_read(filepath, search_cols, data, signature=None,
+                                   cache_variant=""):
+                nonlocal replaced
+                if not replaced:
+                    path.write_text("Name,Keywords\nBeta,beta token\n", encoding="utf-8")
+                    replaced = True
+                return original_get_bm25(
+                    filepath, search_cols, data, signature, cache_variant)
+
+            with patch.object(core, "_get_bm25", side_effect=replace_after_read):
+                results, _, _ = core._search_csv_detailed(
+                    path, ["Name", "Keywords"], ["Name"], "alpha", 1)
+            self.assertEqual(results[0]["Name"], "Alpha")
+
+            results, _, _ = core._search_csv_detailed(
+                path, ["Name", "Keywords"], ["Name"], "beta", 1)
+            self.assertEqual(results[0]["Name"], "Beta")
+
+
+class TestSearchDomains(unittest.TestCase):
+    def test_read_failure_is_not_reported_as_a_search_result(self):
+        failure = UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid")
+        with patch("core._load_csv_snapshot", side_effect=failure):
+            domain = search("palette", domain="color", max_results=1)
+            stack = search_stack("component", "react", max_results=1)
+        for result in (domain, stack):
+            self.assertEqual(0, result["count"])
+            self.assertEqual([], result["results"])
+            self.assertRegex(result["error"], r"^Unable to read search data:")
+            self.assertNotIn("invalid", result["error"])
+
+    def test_ui_is_searchable_in_style_domain(self):
+        result = search("ui minimalism", domain="style", max_results=1)
+        self.assertGreater(result["count"], 0, "literal 'ui' token must be searchable, not filtered by tokenizer")
+
+    def test_accessibility_query_hits_ux(self):
+        result = search("accessibility contrast wcag keyboard", domain="ux", max_results=3)
+        self.assertGreater(result["count"], 0)
+
+    def test_zero_result_query_reports_suggestions_not_error(self):
+        result = search("zzqqxx totally made up gibberish", domain="ux", max_results=2)
+        self.assertEqual(result["count"], 0)
+        self.assertIn("suggestions", result)
+        self.assertNotIn("error", result)
+
+    def test_hard_negative_query_abstains_across_registered_domains_and_stacks(self):
+        query = "sourdough starter crumb fermentation"
+        for domain in CSV_CONFIG:
+            with self.subTest(kind="domain", name=domain):
+                self.assertEqual(search(query, domain=domain, max_results=1)["count"], 0)
+        for stack in AVAILABLE_STACKS:
+            with self.subTest(kind="stack", name=stack):
+                self.assertEqual(search_stack(query, stack, max_results=1)["count"], 0)
+
+    def test_typo_suggestions_are_deterministic_and_retryable(self):
+        first = search("testimonal", domain="landing", max_results=3)
+        second = search("testimonal", domain="landing", max_results=3)
+        self.assertEqual(first["count"], 0)
+        self.assertEqual(first.get("suggestions"), second.get("suggestions"))
+        self.assertTrue(first["suggestions"], "typo path should return at least one deterministic suggestion")
+
+        retry = search(first["suggestions"][0], domain="landing", max_results=3)
+        self.assertGreater(retry["count"], 0)
+
+    def test_suggestions_never_repeat_the_input_or_offer_a_dead_first_retry(self):
+        pricing = search("pricing", domain="landing", max_results=3)
+        self.assertNotIn("pricing", pricing.get("suggestions", []))
+
+        minimal = search("minimal", domain="style", max_results=3)
+        self.assertEqual(1, minimal["count"])
+        self.assertEqual(
+            "minimalism-and-swiss-style", minimal["results"][0]["Style ID"]
+        )
+
+    def test_unknown_programmatic_domain_keeps_legacy_style_fallback(self):
+        result = search("minimalism", domain="unknown", max_results=1)
+        self.assertEqual(result["domain"], "unknown")
+        self.assertEqual(result["file"], CSV_CONFIG["style"]["file"])
+        self.assertGreater(result["count"], 0)
+
+    def test_unsupported_icon_library_abstains_instead_of_returning_other_library(self):
+        result = search("lucide icon", diagnostics=True)
+        self.assertEqual(result["domain"], "icons")
+        self.assertEqual(result["count"], 0)
+        self.assertEqual(result["diagnostics"]["reason"], "unsupported-library")
+
+    def test_every_configured_domain_file_exists_and_is_searchable(self):
+        for domain, config in CSV_CONFIG.items():
+            with self.subTest(domain=domain):
+                result = search("design", domain=domain, max_results=1)
+                self.assertNotIn("error", result, f"domain '{domain}' failed: {result.get('error')}")
+
+    def test_chart_output_keeps_legacy_grade_during_risk_migration(self):
+        result = search("time series chart", domain="chart", max_results=1)
+        self.assertEqual(result["count"], 1)
+        self.assertEqual(
+            result["results"][0]["Accessibility Grade"],
+            "deprecated: use Accessibility Risk",
+        )
+        self.assertIn("Accessibility Risk", result["results"][0])
+
+    def test_every_stack_file_exists_and_is_searchable(self):
+        for stack in AVAILABLE_STACKS:
+            with self.subTest(stack=stack):
+                result = search_stack("performance", stack, max_results=1)
+                self.assertNotIn("error", result, f"stack '{stack}' failed: {result.get('error')}")
+
+
+class TestDomainDetection(unittest.TestCase):
+    def test_style_keywords_route_to_style(self):
+        self.assertEqual(detect_domain("glassmorphism dark ui"), "style")
+
+    def test_accessibility_keywords_route_to_ux(self):
+        self.assertEqual(detect_domain("accessibility contrast wcag"), "ux")
+
+    def test_ambiguous_query_returns_runner_up(self):
+        domain, _ = detect_domain("font pairing elegant crypto", return_scores=True)
+        self.assertIsNotNone(domain)
+
+    def test_empty_query_falls_back_to_style(self):
+        self.assertEqual(detect_domain("...!!!???"), "style")
+
+    def test_router_prioritizes_color_intent_over_generic_product_terms(self):
+        self.assertEqual(detect_domain("semantic color tokens palette"), "color")
+
+    def test_router_prioritizes_icons_when_icon_library_and_icon_intent_present(self):
+        self.assertEqual(detect_domain("lucide search icon outline"), "icons")
+
+    def test_router_prioritizes_typography_for_font_pairing_queries(self):
+        self.assertEqual(detect_domain("font pairing elegant serif body font"), "typography")
+
+    def test_router_prioritizes_chart_queries_over_generic_product_keywords(self):
+        self.assertEqual(detect_domain("time series chart forecast"), "chart")
+
+    def test_hash_only_routes_color_for_a_valid_hex_literal(self):
+        self.assertNotEqual(detect_domain("C# WPF desktop app"), "color")
+        self.assertEqual(detect_domain("use #ff00aa as the accent"), "color")
+
+    def test_product_router_keeps_high_signal_service_aliases(self):
+        self.assertEqual(detect_domain("beauty spa"), "product")
+        self.assertEqual(detect_domain("salon booking"), "product")
+
+    def test_native_drag_intent_beats_generic_react_token(self):
+        self.assertEqual(detect_domain("drag reorder react native"), "web")
+
+    def test_every_router_term_is_searchable_or_has_a_corpus_rewrite(self):
+        for domain, keywords in core._domain_keywords().items():
+            config = CSV_CONFIG[domain]
+            path = core.DATA_DIR / config["file"]
+            index = core._get_bm25(path, config["search_cols"], core._load_csv(path))
+            vocabulary = set(index.vocabulary())
+            for keyword in keywords:
+                with self.subTest(domain=domain, keyword=keyword):
+                    searchable = bool(set(index.tokenize(keyword)) & vocabulary)
+                    explicitly_routing_only = keyword in core._DOMAIN_QUERY_REWRITES.get(domain, {})
+                    self.assertTrue(searchable or explicitly_routing_only)
+
+
+class TestPersistence(unittest.TestCase):
+    def test_concurrent_non_force_persist_has_one_writer(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            search_script = SCRIPTS_DIR / "search.py"
+            processes = [subprocess.Popen(
+                [sys.executable, str(search_script), f"saas dashboard {index}",
+                 "--design-system", "--persist", "--project-name", "Race Probe",
+                 "--output-dir", tmp, "--json"],
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+            ) for index in range(8)]
+            statuses = []
+            for process in processes:
+                stdout, stderr = process.communicate(timeout=30)
+                self.assertEqual(process.returncode, 0, stderr)
+                statuses.append(json.loads(stdout)["persistence"]["status"])
+
+            self.assertEqual(statuses.count("success"), 1)
+            self.assertEqual(statuses.count("skipped_exists"), 7)
+
+    def test_persist_then_skip_then_force(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            result = generate_design_system("saas dashboard", "Test Project", persist=True, output_dir=tmp)
+            self.assertEqual(result["persistence"]["status"], "success")
+            master = Path(result["persistence"]["master_file"])
+            self.assertTrue(master.exists())
+            original_content = master.read_text(encoding="utf-8")
+
+            # Second persist without force must not overwrite.
+            result2 = generate_design_system("saas dashboard", "Test Project", persist=True, output_dir=tmp)
+            self.assertEqual(result2["persistence"]["status"], "skipped_exists")
+            self.assertEqual(master.read_text(encoding="utf-8"), original_content)
+
+            # A new page override may be added without rewriting the existing Master.
+            page_result = generate_design_system(
+                "checkout form", "Test Project", persist=True, page="Checkout", output_dir=tmp
+            )
+            self.assertEqual(page_result["persistence"]["status"], "success")
+            self.assertEqual(master.read_text(encoding="utf-8"), original_content)
+            page_file = Path(tmp) / "design-system" / "test-project" / "pages" / "checkout.md"
+            self.assertEqual(page_result["persistence"]["created_files"], [str(page_file)])
+            self.assertTrue(page_file.exists())
+
+            # Existing page overrides are protected by the same default no-overwrite rule.
+            page_content = page_file.read_text(encoding="utf-8")
+            page_result2 = generate_design_system(
+                "different checkout", "Test Project", persist=True, page="Checkout", output_dir=tmp
+            )
+            self.assertEqual(page_result2["persistence"]["status"], "skipped_exists")
+            self.assertEqual(page_file.read_text(encoding="utf-8"), page_content)
+
+            # With force=True it must overwrite.
+            result3 = generate_design_system("ecommerce luxury", "Test Project", persist=True, output_dir=tmp, force=True)
+            self.assertEqual(result3["persistence"]["status"], "success")
+
+    def test_persist_writes_only_under_output_dir(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            generate_design_system("saas dashboard", "Scoped Project", persist=True, output_dir=tmp)
+            expected = Path(tmp) / "design-system" / "scoped-project" / "MASTER.md"
+            self.assertTrue(expected.exists())
+
+
+class TestReasoningMatch(unittest.TestCase):
+    def test_known_category_matches_exactly(self):
+        gen = DesignSystemGenerator()
+        rule = gen._find_reasoning_rule("SaaS (General)")
+        self.assertTrue(rule, "exact-match category lookup should not fall through to fuzzy matching")
+
+    def test_unknown_category_falls_back_gracefully(self):
+        gen = DesignSystemGenerator()
+        rule = gen._find_reasoning_rule("Totally Unknown Category XYZ")
+        # Should not raise; may return {} which _apply_reasoning handles with defaults.
+        self.assertIsInstance(rule, dict)
+
+
+class TestDiagnosticsContracts(unittest.TestCase):
+    def test_diagnostics_opt_in_is_additive_for_domain_search(self):
+        baseline = search("minimalism", domain="style", max_results=1)
+        diagnosed = search("minimalism", domain="style", max_results=1, diagnostics=True)
+        self.assertEqual(set(baseline.keys()), set(diagnosed.keys()) - {"diagnostics"})
+        self.assertIn("diagnostics", diagnosed)
+        self.assertIn("top_score", diagnosed["diagnostics"])
+        self.assertIn("query_rewrites", diagnosed["diagnostics"])
+
+    def test_diagnostics_opt_in_is_additive_for_stack_search(self):
+        baseline = search_stack("performance", "react", max_results=1)
+        diagnosed = search_stack("performance", "react", max_results=1, diagnostics=True)
+        self.assertEqual(set(baseline.keys()), set(diagnosed.keys()) - {"diagnostics"})
+        self.assertIn("diagnostics", diagnosed)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/ui-ux-pro-max/scripts/tests/test_core_data_quality.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Semantic quality contracts for the core UI/UX datasets."""
+
+import csv
+import sys
+import unittest
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).resolve().parent.parent
+DATA_DIR = SCRIPTS_DIR.parent / "data"
+sys.path.insert(0, str(SCRIPTS_DIR))
+
+from core import search  # noqa: E402
+from validate_data import (  # noqa: E402
+    CHART_NON_COLOR_GUIDANCE,
+    CHART_RISKS,
+    CHART_TEXT_FALLBACK,
+    COLOR_CONTRAST_PAIRS,
+    CSS_IMPORT,
+    ICON_CONTEXTS,
+    ICON_ROLES,
+    ICON_USAGE_REQUIREMENTS,
+    WCAG_GRADE,
+    _check_chart_contract,
+    _check_icon_contract,
+    _check_typography_contract,
+    _configured_font_names,
+    _font_families,
+    _font_names,
+    contrast_ratio,
+)
+
+
+def read_rows(name):
+    with (DATA_DIR / name).open(encoding="utf-8", newline="") as handle:
+        return list(csv.DictReader(handle))
+
+
+class TestSemanticColors(unittest.TestCase):
+    def test_declared_text_and_ui_pairs_meet_role_thresholds(self):
+        for row in read_rows("colors.csv"):
+            for foreground, (background, role, minimum) in COLOR_CONTRAST_PAIRS.items():
+                with self.subTest(
+                        product=row["Product Type"], pair=foreground, role=role):
+                    self.assertGreaterEqual(
+                        contrast_ratio(row[foreground], row[background]), minimum)
+
+    def test_destructive_tokens_are_not_success_green(self):
+        for row in read_rows("colors.csv"):
+            value = row["Destructive"].lstrip("#")
+            red, green, blue = (int(value[index:index + 2], 16)
+                                for index in (0, 2, 4))
+            with self.subTest(product=row["Product Type"]):
+                self.assertFalse(green > red * 1.1 and green > blue * 1.1)
+
+
+class TestAccessibilityGuidance(unittest.TestCase):
+    def test_wcag_22_topics_have_explicit_rows_and_are_retrievable(self):
+        rows = read_rows("ux-guidelines.csv")
+        issues = {row["Issue"] for row in rows}
+        expected_platforms = {
+            "Focus Not Obscured (Minimum)": "Web",
+            "Focus Not Obscured (Enhanced)": "Web",
+            "Focus Appearance": "Web",
+            "Dragging Movements": "All",
+            "Target Size (Minimum)": "Web",
+            "Consistent Help": "All",
+            "Redundant Entry": "All",
+            "Accessible Authentication (Minimum)": "All",
+            "Auto-Rotating Content Controls": "All",
+        }
+        self.assertTrue(expected_platforms.keys() <= issues)
+        for issue, expected_platform in expected_platforms.items():
+            with self.subTest(issue=issue):
+                row = next(row for row in rows if row["Issue"] == issue)
+                self.assertEqual(row["Platform"], expected_platform)
+                self.assertIn(row["Severity"], {"Medium", "High", "Critical"})
+                self.assertNotEqual(row["Do"], row["Description"])
+                result = search(issue, domain="ux", max_results=3)
+                self.assertTrue(any(row.get("Issue") == issue for row in result["results"]))
+
+    def test_native_and_web_target_sizes_remain_distinct(self):
+        native = next(row for row in read_rows("app-interface.csv")
+                      if row["Issue"] == "Touch Target Size")
+        web = next(row for row in read_rows("ux-guidelines.csv")
+                   if row["Issue"] == "Target Size (Minimum)")
+        native_text = " ".join(native.values())
+        web_text = " ".join(web.values())
+        self.assertIn("44pt", native_text)
+        self.assertIn("48dp", native_text)
+        self.assertIn("24 CSS px", web_text)
+
+    def test_motion_recipes_offer_reduced_motion_or_user_control(self):
+        for row in read_rows("motion.csv"):
+            text = " ".join(row.values()).casefold()
+            with self.subTest(row=row["No"], category=row["Category"]):
+                self.assertTrue(
+                    "reduced-motion" in text or "user-controlled" in text,
+                    "every motion recipe needs an explicit opt-out",
+                )
+
+
+class TestChartsTypographyAndIcons(unittest.TestCase):
+    def test_mutated_accessibility_and_import_contracts_fail(self):
+        mutations = []
+        chart = dict(read_rows("charts.csv")[0])
+        chart["A11y Fallback"] = "A visible table is available."
+        mutations.append((_check_chart_contract, chart, "keyboard"))
+        typography = dict(read_rows("typography.csv")[0])
+        typography["CSS Import"] = (
+            "@import url('https://fonts.googleapis.com/css2?family=Comic+Sans');"
+        )
+        mutations.append((_check_typography_contract, typography, "differ"))
+        missing_weight = dict(read_rows("typography.csv")[0])
+        missing_weight["Notes"] += " Recommended weight 900."
+        mutations.append((_check_typography_contract, missing_weight, "weights"))
+        icon = dict(read_rows("icons.csv")[0])
+        icon["Import Code"] = "import { IconName } from '@phosphor-icons/react'"
+        mutations.append((_check_icon_contract, icon, "import"))
+        for checker, row, expected in mutations:
+            with self.subTest(checker=checker.__name__):
+                problems = []
+                checker([row], problems)
+                self.assertTrue(any(expected in problem for problem in problems))
+
+    def test_chart_risk_is_not_a_conformance_grade(self):
+        for row in read_rows("charts.csv"):
+            with self.subTest(data_type=row["Data Type"]):
+                self.assertIn(row["Accessibility Risk"], CHART_RISKS)
+                self.assertEqual(
+                    row["Accessibility Grade"],
+                    "deprecated: use Accessibility Risk",
+                )
+                text = " ".join((row["Accessibility Notes"], row["A11y Fallback"]))
+                self.assertIsNone(WCAG_GRADE.search(text))
+                self.assertIsNotNone(CHART_TEXT_FALLBACK.search(text.casefold()))
+                self.assertIsNotNone(
+                    CHART_NON_COLOR_GUIDANCE.search(text.casefold())
+                )
+                self.assertIn("keyboard", text.casefold())
+
+    def test_named_fonts_match_google_import_css_import_and_tailwind_config(self):
+        for row in read_rows("typography.csv"):
+            url_families = _font_families(row["Google Fonts URL"])
+            families = _font_names(url_families)
+            configured = _configured_font_names(row["Tailwind Config"])
+            named = {row["Heading Font"], row["Body Font"]}
+            with self.subTest(pairing=row["Font Pairing Name"]):
+                self.assertTrue(named <= families)
+                self.assertTrue(named <= configured)
+                match = CSS_IMPORT.fullmatch(row["CSS Import"])
+                self.assertIsNotNone(match)
+                self.assertEqual(
+                    sorted(url_families),
+                    sorted(_font_families(match.group(2))),
+                )
+
+    def test_icon_semantics_are_explicit_and_imports_are_concrete(self):
+        for row in read_rows("icons.csv"):
+            with self.subTest(icon=row["Icon Name"]):
+                self.assertIn(row["Semantic Role"], ICON_ROLES)
+                self.assertEqual(set(row["Allowed Contexts"].split("|")), ICON_CONTEXTS)
+                self.assertNotRegex(row["Usage"], r"[\u3400-\u9fff]")
+                self.assertNotIn("IconName", row["Import Code"])
+                for requirement in ICON_USAGE_REQUIREMENTS:
+                    self.assertRegex(row["Usage"].casefold(), requirement)
+
+    def test_natural_accessibility_queries_are_retrievable(self):
+        cases = {
+            "chart": ("keyboard accessible chart", "keyboard"),
+            "landing": ("accessible drag interaction", "keyboard controls"),
+            "icons": ("decorative icon aria hidden", "aria-hidden"),
+            "gsap": ("stop animation offscreen", "visibility"),
+            "ux": ("error summary validation", "error summary"),
+        }
+        for domain, (query, expected) in cases.items():
+            with self.subTest(domain=domain, query=query):
+                result = search(query, domain=domain, max_results=3)
+                self.assertGreater(result["count"], 0)
+                self.assertIn(
+                    expected.casefold(),
+                    " ".join(str(value) for value in result["results"][0].values()).casefold(),
+                )
+
+
+class TestCurrentReactGuidance(unittest.TestCase):
+    def test_effect_event_is_scoped_and_community_use_latest_is_removed(self):
+        rows = read_rows("react-performance.csv")
+        effect_event = next(row for row in rows if row["Issue"] == "Effect Events")
+        text = " ".join(effect_event.values()).casefold()
+        self.assertIn("inside effects", text)
+        self.assertIn("dependencies", text)
+        self.assertFalse(any("uselatest" in " ".join(row.values()).casefold()
+                             for row in rows))
+
+
+if __name__ == "__main__":
+    unittest.main()