notque/vexjoy-agent / skills/frontend/frontend
frontend
UnverifiedFrontend: UI design, distinctive visual styles, HTML artifacts, Three.js 3D, TypeScript/React/Next.js apps, e-commerce, portfolios, React Native, web performance.
scripts-html-artifact/tests/test_css_slop_emission.py
View on GitHub"""Tests for the vendored slop scan wired into validate-artifact.py and the
self-describing stamp emitted by assemble-template.py."""
from __future__ import annotations
import re
import sys
import tempfile
from importlib import import_module
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent))
validate_mod = import_module("validate-artifact")
validate_artifact = validate_mod.validate_artifact
assemble_mod = import_module("assemble-template")
assemble_template = assemble_mod.assemble_template
slop = import_module("css_slop_rules")
scan_css = slop.scan_css
STAMP_RE = re.compile(r"/\* vexjoy-artifact: shape=(\S+) theme=(\S+) contrast=(pass|fail|n/a) \*/")
# Minimal stand-in for templates/fonts/archivo-black.css: embedded face plus a heading rule.
HEADING_FONT_CSS = (
'@font-face { font-family: "Archivo Black"; src: url(data:font/woff2;base64,AAAA) format("woff2"); }'
" h1, h2, h3 { font-family: var(--font-heading); }"
)
# Clean CSS: no slop patterns.
CLEAN_HTML = (
"""<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Clean</title>
<style>
body { color: #111111; background-color: #ffffff; }
.card { transition: opacity 150ms, transform 150ms; }
h1 { color: #222222; }
</style>
</head>
<body><h1>Hello</h1><p>content</p></body>
</html>"""
).replace("<style>", "<style>" + HEADING_FONT_CSS)
# Slop CSS: transition-all + gradient-text-headline on h1.
SLOP_HTML = (
"""<!DOCTYPE html>
<html lang="en">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Slop</title>
<style>
.card { transition: all 200ms ease; }
h1 { background-clip: text; -webkit-background-clip: text; }
</style>
</head>
<body><h1>Headline</h1><p>content</p></body>
</html>"""
).replace("<style>", "<style>" + HEADING_FONT_CSS)
def _write_tmp(content: str) -> Path:
f = tempfile.NamedTemporaryFile(mode="w", suffix=".html", delete=False, encoding="utf-8")
f.write(content)
f.close()
return Path(f.name)
class TestSlopScanWiring:
"""The vendored scan_css fires on slop and stays silent on clean CSS."""
def test_clean_css_no_slop_warnings(self) -> None:
path = _write_tmp(CLEAN_HTML)
try:
result = validate_artifact(path)
assert result.checks["css_slop_clean"] is True
assert not any(w.startswith("CSS slop") for w in result.warnings)
# Slop warnings are non-blocking — clean file is still valid.
assert result.valid
finally:
path.unlink()
def test_slop_css_emits_warnings(self) -> None:
path = _write_tmp(SLOP_HTML)
try:
result = validate_artifact(path)
assert result.checks["css_slop_clean"] is False
slop_warnings = [w for w in result.warnings if w.startswith("CSS slop")]
assert any("transition-all" in w for w in slop_warnings)
assert any("gradient-text-headline" in w for w in slop_warnings)
finally:
path.unlink()
def test_slop_is_non_blocking(self) -> None:
# Structurally valid file with slop: warnings only, exit-equivalent valid.
path = _write_tmp(SLOP_HTML)
try:
result = validate_artifact(path)
assert result.valid
finally:
path.unlink()
def test_invisible_text_blocks_build(self) -> None:
# Contrast below 1.2:1 is an error, so the artifact is invalid.
path = _write_tmp(
CLEAN_HTML.replace("h1 { color: #222222; }", "h1 { color: #1a1a1a; background-color: #1e1e1e; }")
)
try:
result = validate_artifact(path)
assert not result.valid
assert any("contrast-canary" in e for e in result.errors)
assert not any("contrast-canary" in w for w in result.warnings)
finally:
path.unlink()
def test_low_but_visible_contrast_only_warns(self) -> None:
# 1.21:1 sits between the 1.2 error floor and the canary threshold: warning only.
css = "h1 { color: oklch(0.30 0.02 250); background-color: oklch(0.35 0.02 250); }"
path = _write_tmp(CLEAN_HTML.replace("h1 { color: #222222; }", css))
try:
result = validate_artifact(path)
assert result.valid
assert any("contrast-canary" in w for w in result.warnings)
finally:
path.unlink()
def test_scan_shape_agnostic(self) -> None:
# Same slop CSS flagged regardless of declared shape (report has no hero).
path = _write_tmp(SLOP_HTML)
try:
for shape in ("report", "data-viz", "spec", "deck"):
result = validate_artifact(path, shape=shape)
assert result.checks["css_slop_clean"] is False
finally:
path.unlink()
def test_oversized_file_still_scanned_fast(self) -> None:
# The slop scanner is linear, so oversized files are scanned, not skipped.
# Slop in an oversized file is still flagged; the size check fires
# independently. Must complete quickly, not hang.
import time
path = _write_tmp(SLOP_HTML + ("x" * (501 * 1024)))
try:
start = time.perf_counter()
result = validate_artifact(path)
assert time.perf_counter() - start < 1.0
assert result.checks["css_slop_clean"] is False
assert not result.checks["reasonable_size"]
finally:
path.unlink()
def test_oversized_single_line_does_not_hang(self) -> None:
# Adversarial ~1MB minified single line: the old O(n^2) block regex hung.
import time
unit = '<div class="btn cta" style="color:#111;background:#222">x</div>'
path = _write_tmp("<html><body>" + unit * 16000 + "</body></html>")
try:
start = time.perf_counter()
validate_artifact(path)
assert time.perf_counter() - start < 1.0
finally:
path.unlink()
class TestVendoredModuleParity:
"""The vendored scan_css is the same engine as the source module."""
def test_findings_match_direct_scan(self) -> None:
findings = scan_css(SLOP_HTML)
rule_ids = {f.rule_id for f in findings}
assert "transition-all" in rule_ids
assert "gradient-text-headline" in rule_ids
def test_clean_css_no_findings(self) -> None:
assert scan_css(CLEAN_HTML) == []
class TestStampEmission:
"""assemble-template.py emits a parseable vexjoy-artifact stamp."""
def test_stamp_present_and_parseable(self) -> None:
html = assemble_template("spec", "Test")
m = STAMP_RE.search(html)
assert m is not None
assert m.group(1) == "spec"
assert m.group(2) == "birchline"
assert m.group(3) == "n/a"
def test_stamp_is_first_css_comment(self) -> None:
html = assemble_template("report", "Test")
style_open = html.index("<style>")
first_comment = html.index("/*", style_open)
assert html[first_comment:].startswith("/* vexjoy-artifact:")
def test_stamp_reflects_theme_override(self) -> None:
html = assemble_template("spec", "Test", theme="dark-focus")
m = STAMP_RE.search(html)
assert m is not None
assert m.group(2) == "dark-focus"
def test_stamp_per_shape_default_theme(self) -> None:
html = assemble_template("code-review", "Test")
m = STAMP_RE.search(html)
assert m is not None
assert m.group(1) == "code-review"
assert m.group(2) == "dark-focus"
def test_stamp_survives_validation_as_clean(self) -> None:
# The stamp itself must not trip any slop rule.
html = assemble_template("report", "Stamped")
path = _write_tmp(html)
try:
result = validate_artifact(path)
stamp_warnings = [w for w in result.warnings if "vexjoy-artifact" in w]
assert stamp_warnings == []
finally:
path.unlink()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |