Compare commits
2
Commits
website
...
fd63de3441
| Author | SHA1 | Date | |
|---|---|---|---|
 claude@clouddev1
|
fd63de3441 | ||
|
claude@clouddev1
|
65eab71439 |
Generated
+113
-3
@@ -64,6 +64,12 @@ dependencies = [
|
||||
"x11rb",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "arrayvec"
|
||||
version = "0.7.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f02882884d3e1bc524fb12c79f107f6ad0e1cfd498c536ffb494301740995dfe"
|
||||
|
||||
[[package]]
|
||||
name = "atomic"
|
||||
version = "0.6.1"
|
||||
@@ -164,6 +170,12 @@ version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
|
||||
|
||||
[[package]]
|
||||
name = "cfg_aliases"
|
||||
version = "0.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
|
||||
|
||||
[[package]]
|
||||
name = "cfg_aliases"
|
||||
version = "0.2.1"
|
||||
@@ -481,6 +493,12 @@ dependencies = [
|
||||
"litrs",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "downcast-rs"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.15.0"
|
||||
@@ -976,7 +994,7 @@ version = "1.1.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c0aeb26bf5e836cc1c341c8106051b573f1766dfa05aa87f0b98be5e51b02303"
|
||||
dependencies = [
|
||||
"nix",
|
||||
"nix 0.29.0",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
@@ -1038,6 +1056,18 @@ dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "nix"
|
||||
version = "0.28.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
|
||||
dependencies = [
|
||||
"bitflags 2.11.1",
|
||||
"cfg-if",
|
||||
"cfg_aliases 0.1.1",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "nix"
|
||||
version = "0.29.0"
|
||||
@@ -1046,7 +1076,7 @@ checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
|
||||
dependencies = [
|
||||
"bitflags 2.11.1",
|
||||
"cfg-if",
|
||||
"cfg_aliases",
|
||||
"cfg_aliases 0.2.1",
|
||||
"libc",
|
||||
"memoffset",
|
||||
]
|
||||
@@ -1360,6 +1390,27 @@ version = "1.13.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
|
||||
|
||||
[[package]]
|
||||
name = "portable-pty"
|
||||
version = "0.9.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b4a596a2b3d2752d94f51fac2d4a96737b8705dddd311a32b9af47211f08671e"
|
||||
dependencies = [
|
||||
"anyhow",
|
||||
"bitflags 1.3.2",
|
||||
"downcast-rs",
|
||||
"filedescriptor",
|
||||
"lazy_static",
|
||||
"libc",
|
||||
"log",
|
||||
"nix 0.28.0",
|
||||
"serial2",
|
||||
"shared_library",
|
||||
"shell-words",
|
||||
"winapi",
|
||||
"winreg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "powerfmt"
|
||||
version = "0.2.0"
|
||||
@@ -1548,6 +1599,7 @@ dependencies = [
|
||||
"futures-util",
|
||||
"gethostname",
|
||||
"insta",
|
||||
"portable-pty",
|
||||
"pretty_assertions",
|
||||
"rand 0.10.1",
|
||||
"ratatui",
|
||||
@@ -1559,6 +1611,7 @@ dependencies = [
|
||||
"tokio",
|
||||
"tracing",
|
||||
"tracing-subscriber",
|
||||
"vt100",
|
||||
"zip",
|
||||
]
|
||||
|
||||
@@ -1738,6 +1791,17 @@ dependencies = [
|
||||
"unsafe-libyaml-norway",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serial2"
|
||||
version = "0.2.37"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9eb6ea5562eeaed6936b8b54e086aa0f88b9e5b1bef45beb038e2519fa1185b1"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"libc",
|
||||
"windows-sys 0.61.2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sha2"
|
||||
version = "0.10.9"
|
||||
@@ -1758,6 +1822,22 @@ dependencies = [
|
||||
"lazy_static",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shared_library"
|
||||
version = "0.1.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shell-words"
|
||||
version = "1.1.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
|
||||
|
||||
[[package]]
|
||||
name = "shlex"
|
||||
version = "1.3.0"
|
||||
@@ -1968,7 +2048,7 @@ dependencies = [
|
||||
"libc",
|
||||
"log",
|
||||
"memmem",
|
||||
"nix",
|
||||
"nix 0.29.0",
|
||||
"num-derive",
|
||||
"num-traits",
|
||||
"ordered-float",
|
||||
@@ -2240,6 +2320,27 @@ version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
|
||||
|
||||
[[package]]
|
||||
name = "vt100"
|
||||
version = "0.16.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "054ff75fb8fa83e609e685106df4faeffdf3a735d3c74ebce97ec557d5d36fd9"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"unicode-width",
|
||||
"vte",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "vte"
|
||||
version = "0.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a5924018406ce0063cd67f8e008104968b74b563ee1b85dde3ed1f7cb87d3dbd"
|
||||
dependencies = [
|
||||
"arrayvec",
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "vtparse"
|
||||
version = "0.6.2"
|
||||
@@ -2639,6 +2740,15 @@ version = "0.53.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
|
||||
|
||||
[[package]]
|
||||
name = "winreg"
|
||||
version = "0.10.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
|
||||
dependencies = [
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wit-bindgen"
|
||||
version = "0.51.0"
|
||||
|
||||
@@ -59,8 +59,10 @@ zip = { version = "5.1.1", default-features = false, features = ["deflate"] }
|
||||
|
||||
[dev-dependencies]
|
||||
insta = { version = "1.47.2", features = ["yaml"] }
|
||||
portable-pty = "0.9"
|
||||
pretty_assertions = "1.4.1"
|
||||
tempfile = "3.27.0"
|
||||
vt100 = "0.16"
|
||||
|
||||
# Dev/test build hygiene (see CLAUDE.md "Build hygiene"). `cargo test`
|
||||
# links ~25 separate integration-test binaries, each statically
|
||||
|
||||
Executable
+168
@@ -0,0 +1,168 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Palette preview + WCAG contrast + CIEDE2000 perceptual audit.
|
||||
|
||||
A dev tool for working on the colour palette (`src/theme.rs`). It reads
|
||||
the live `dark()` / `light()` constructors so it never drifts from the
|
||||
code, renders a true-colour swatch + sample for every palette entry on
|
||||
the theme background, prints the WCAG-AA contrast ratio, and reports the
|
||||
pairwise CIEDE2000 (ΔE2000) distance between the syntax-token colours so
|
||||
near-duplicates (distinct hex, indistinguishable on screen) are obvious.
|
||||
|
||||
Usage:
|
||||
scripts/palette-preview.py
|
||||
scripts/palette-preview.py dark:tok_type=F58AAE light:tok_flag=7A5C00
|
||||
|
||||
Each `theme:key=HEX` argument previews a change without editing the
|
||||
source — handy for trying candidate colours. The gates mirrored here are
|
||||
enforced for real by the tests in `src/theme.rs` (NFR-5/NFR-7, ADR-0057):
|
||||
text foregrounds must clear 4.5:1; token pairs must clear ΔE2000 15.
|
||||
"""
|
||||
import math
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
THEME_RS = os.path.join(os.path.dirname(__file__), "..", "src", "theme.rs")
|
||||
|
||||
# --- WCAG contrast -----------------------------------------------------
|
||||
def _lin(c):
|
||||
c = c / 255.0
|
||||
return c / 12.92 if c <= 0.03928 else ((c + 0.055) / 1.055) ** 2.4
|
||||
|
||||
def _luminance(rgb):
|
||||
r, g, b = rgb
|
||||
return 0.2126 * _lin(r) + 0.7152 * _lin(g) + 0.0722 * _lin(b)
|
||||
|
||||
def contrast(fg, bg):
|
||||
a, b = _luminance(fg), _luminance(bg)
|
||||
hi, lo = max(a, b), min(a, b)
|
||||
return (hi + 0.05) / (lo + 0.05)
|
||||
|
||||
# --- sRGB -> CIELAB (D65) + CIEDE2000 ----------------------------------
|
||||
def _f(t):
|
||||
return t ** (1 / 3) if t > 0.008856 else 7.787 * t + 16 / 116
|
||||
|
||||
def rgb_to_lab(rgb):
|
||||
r, g, b = (_lin(c) for c in rgb)
|
||||
x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.95047
|
||||
y = r * 0.2126 + g * 0.7152 + b * 0.0722
|
||||
z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.08883
|
||||
fx, fy, fz = _f(x), _f(y), _f(z)
|
||||
return (116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz))
|
||||
|
||||
def de2000(lab1, lab2):
|
||||
L1, a1, b1 = lab1
|
||||
L2, a2, b2 = lab2
|
||||
avg_Lp = (L1 + L2) / 2
|
||||
C1, C2 = math.hypot(a1, b1), math.hypot(a2, b2)
|
||||
avg_C = (C1 + C2) / 2
|
||||
G = 0.5 * (1 - math.sqrt(avg_C ** 7 / (avg_C ** 7 + 25 ** 7))) if avg_C > 0 else 0
|
||||
a1p, a2p = (1 + G) * a1, (1 + G) * a2
|
||||
C1p, C2p = math.hypot(a1p, b1), math.hypot(a2p, b2)
|
||||
avg_Cp = (C1p + C2p) / 2
|
||||
def hp(ap, b):
|
||||
if ap == 0 and b == 0:
|
||||
return 0
|
||||
ang = math.degrees(math.atan2(b, ap))
|
||||
return ang + 360 if ang < 0 else ang
|
||||
h1p, h2p = hp(a1p, b1), hp(a2p, b2)
|
||||
dLp, dCp = L2 - L1, C2p - C1p
|
||||
if C1p * C2p == 0:
|
||||
dhp = 0
|
||||
elif abs(h2p - h1p) <= 180:
|
||||
dhp = h2p - h1p
|
||||
elif h2p - h1p > 180:
|
||||
dhp = h2p - h1p - 360
|
||||
else:
|
||||
dhp = h2p - h1p + 360
|
||||
dHp = 2 * math.sqrt(C1p * C2p) * math.sin(math.radians(dhp) / 2)
|
||||
if C1p * C2p == 0:
|
||||
avg_hp = h1p + h2p
|
||||
elif abs(h1p - h2p) <= 180:
|
||||
avg_hp = (h1p + h2p) / 2
|
||||
elif h1p + h2p < 360:
|
||||
avg_hp = (h1p + h2p + 360) / 2
|
||||
else:
|
||||
avg_hp = (h1p + h2p - 360) / 2
|
||||
T = (1 - 0.17 * math.cos(math.radians(avg_hp - 30))
|
||||
+ 0.24 * math.cos(math.radians(2 * avg_hp))
|
||||
+ 0.32 * math.cos(math.radians(3 * avg_hp + 6))
|
||||
- 0.20 * math.cos(math.radians(4 * avg_hp - 63)))
|
||||
d_ro = 30 * math.exp(-((avg_hp - 275) / 25) ** 2)
|
||||
Rc = 2 * math.sqrt(avg_Cp ** 7 / (avg_Cp ** 7 + 25 ** 7)) if avg_Cp > 0 else 0
|
||||
Sl = 1 + (0.015 * (avg_Lp - 50) ** 2) / math.sqrt(20 + (avg_Lp - 50) ** 2)
|
||||
Sc, Sh = 1 + 0.045 * avg_Cp, 1 + 0.015 * avg_Cp * T
|
||||
Rt = -math.sin(math.radians(2 * d_ro)) * Rc
|
||||
return math.sqrt((dLp / Sl) ** 2 + (dCp / Sc) ** 2 + (dHp / Sh) ** 2
|
||||
+ Rt * (dCp / Sc) * (dHp / Sh))
|
||||
|
||||
# --- parse the live palette from src/theme.rs --------------------------
|
||||
def parse_palette(path):
|
||||
text = open(path, encoding="utf-8").read()
|
||||
field = re.compile(
|
||||
r"(\w+):\s*Color::Rgb\(0x([0-9A-Fa-f]{2}),\s*0x([0-9A-Fa-f]{2}),\s*0x([0-9A-Fa-f]{2})\)"
|
||||
)
|
||||
def block(start, end):
|
||||
s = text.index(start)
|
||||
e = text.index(end, s)
|
||||
return {m.group(1): (m.group(2) + m.group(3) + m.group(4)).upper()
|
||||
for m in field.finditer(text[s:e])}
|
||||
return {"dark": block("fn dark()", "fn light()"),
|
||||
"light": block("fn light()", "fn highlight_class_color")}
|
||||
|
||||
def h(s):
|
||||
return tuple(int(s[i:i + 2], 16) for i in (0, 2, 4))
|
||||
|
||||
def fg(rgb):
|
||||
r, g, b = rgb
|
||||
return f"\x1b[38;2;{r};{g};{b}m"
|
||||
|
||||
def bg(rgb):
|
||||
r, g, b = rgb
|
||||
return f"\x1b[48;2;{r};{g};{b}m"
|
||||
|
||||
R = "\x1b[0m"
|
||||
TOKENS = ["tok_keyword", "tok_identifier", "tok_type", "tok_number",
|
||||
"tok_string", "tok_flag", "tok_function"]
|
||||
NONTEXT = {"border", "border_advanced"}
|
||||
SAMPLE = {
|
||||
"tok_keyword": "create table", "tok_identifier": "Customers",
|
||||
"tok_type": "serial", "tok_number": "42", "tok_string": "'hello'",
|
||||
"tok_flag": "--all-rows", "tok_function": "count(", "tok_punct": ", ;",
|
||||
"tok_error": "bad", "fg": "body text", "muted": "(none yet)",
|
||||
"system": "done.", "error": "error: nope", "warning": "[WRN] slow",
|
||||
"plan_efficient": "SEARCH idx", "mode_simple": "SIMPLE",
|
||||
"mode_advanced": "ADVANCED", "border": "──────", "border_advanced": "──────",
|
||||
}
|
||||
|
||||
def main():
|
||||
themes = parse_palette(THEME_RS)
|
||||
for arg in sys.argv[1:]:
|
||||
th, rest = arg.split(":")
|
||||
k, v = rest.split("=")
|
||||
themes[th][k] = v.upper()
|
||||
for tn, t in themes.items():
|
||||
B = h(t["bg"])
|
||||
print(f"\n{'=' * 64}\n {tn.upper()} THEME (bg #{t['bg']})\n{'=' * 64}")
|
||||
for k, hexv in t.items():
|
||||
if k == "bg":
|
||||
continue
|
||||
c = h(hexv)
|
||||
cr = contrast(c, B)
|
||||
swatch = f"{bg(c)} {R}"
|
||||
text = f"{bg(B)}{fg(c)} {SAMPLE.get(k, k):14}{R}"
|
||||
floor = 3.0 if k in NONTEXT else 4.5
|
||||
warn = "" if cr >= floor else f" !! < {floor}"
|
||||
print(f" {swatch} {text} #{hexv} {cr:5.2f}:1{warn} {k}")
|
||||
print("\n -- token ΔE2000 (<12 hard to distinguish; gate is >=15) --")
|
||||
labs = {k: rgb_to_lab(h(t[k])) for k in TOKENS if k in t}
|
||||
pairs = sorted(
|
||||
(de2000(labs[a], labs[b]), a, b)
|
||||
for i, a in enumerate(labs) for b in list(labs)[i + 1:]
|
||||
)
|
||||
for d, a, b in pairs[:6]:
|
||||
flag = " !! TOO CLOSE" if d < 15 else (" ~ close" if d < 18 else "")
|
||||
print(f" {d:5.1f} {a:14} vs {b:14}{flag}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+276
-5
@@ -106,13 +106,13 @@ impl Theme {
|
||||
// distinct from the mode-banner blue.
|
||||
tok_keyword: Color::Rgb(0xC7, 0x92, 0xEA), // muted purple
|
||||
tok_identifier: Color::Rgb(0x56, 0xB6, 0xC2), // cyan-teal — identifiers are the user's content, deserve a vivid distinct colour
|
||||
tok_type: Color::Rgb(0xF0, 0x8F, 0xC0), // pink — types sit in the red-purple range, clearly apart from the lavender keyword and teal identifier
|
||||
tok_type: Color::Rgb(0xF5, 0x8A, 0xAE), // rose-pink — types sit in the red-purple range, clearly apart from the lavender keyword and teal identifier (ADR-0057: widened ΔE from keyword 14.5→18.4)
|
||||
tok_number: Color::Rgb(0xF7, 0x8C, 0x6C), // warm orange
|
||||
tok_string: Color::Rgb(0xC3, 0xE8, 0x8D), // soft green
|
||||
tok_punct: Color::Rgb(0x8B, 0x90, 0x9A), // == muted
|
||||
tok_flag: Color::Rgb(0xFF, 0xCB, 0x6B), // amber
|
||||
tok_error: Color::Rgb(0xFF, 0x6B, 0x6B), // == error
|
||||
tok_function: Color::Rgb(0x82, 0xCF, 0xFD), // sky blue — cool like keyword but bluer, clearly apart from purple keyword + teal identifier + pink type
|
||||
tok_function: Color::Rgb(0x6C, 0xB2, 0xFF), // sky blue — cool like keyword but bluer, clearly apart from purple keyword + teal identifier + rose type (ADR-0057: widened ΔE from identifier 14.3→19.5)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -139,9 +139,9 @@ impl Theme {
|
||||
tok_identifier: Color::Rgb(0x0F, 0x6B, 0x76), // deep teal — same role as dark variant: identifiers stand out
|
||||
tok_type: Color::Rgb(0xA8, 0x2D, 0x73), // deep magenta — red-purple, distinct from royal-purple keyword + teal identifier
|
||||
tok_number: Color::Rgb(0xBC, 0x4F, 0x1F), // burnt orange
|
||||
tok_string: Color::Rgb(0x22, 0x86, 0x3A), // forest green
|
||||
tok_punct: Color::Rgb(0x60, 0x66, 0x73), // == muted
|
||||
tok_flag: Color::Rgb(0xB0, 0x88, 0x00), // mustard
|
||||
tok_string: Color::Rgb(0x1B, 0x7A, 0x33), // forest green (ADR-0057: darkened for WCAG-AA, 4.42→5.18:1)
|
||||
tok_punct: Color::Rgb(0x60, 0x66, 0x73), // == muted
|
||||
tok_flag: Color::Rgb(0x7A, 0x5C, 0x00), // dark mustard/olive (ADR-0057: darkened for WCAG-AA, 3.15→5.98:1)
|
||||
tok_error: Color::Rgb(0xC0, 0x39, 0x2B), // == error
|
||||
tok_function: Color::Rgb(0x1A, 0x5F, 0xB0), // strong blue — cool like keyword but bluer, apart from royal-purple keyword + teal identifier + magenta type
|
||||
}
|
||||
@@ -264,4 +264,275 @@ mod tests {
|
||||
assert_ne!(t.tok_function, t.tok_type);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- NFR-5 / NFR-7 (ADR-0057): WCAG-AA contrast gate ----
|
||||
//
|
||||
// Every text-bearing foreground must clear WCAG-AA 4.5:1 against
|
||||
// the panel background, in BOTH themes, so the colour scheme stays
|
||||
// legible on light and dark terminals (no dark-on-dark / light-on-
|
||||
// light failures). Borders are non-text structural chrome and are
|
||||
// handled by `advanced_mode_border_meets_ui_contrast` below; the
|
||||
// plain `border` is intentionally exempt (decorative — see ADR-0057).
|
||||
//
|
||||
// These checks rely on every `Theme` colour being `Color::Rgb`
|
||||
// (true-colour). `rgb_channels` panics on any other variant, which
|
||||
// also guards against a future regression to a named palette colour
|
||||
// (whose real contrast can't be known).
|
||||
|
||||
fn rgb_channels(c: Color) -> (f64, f64, f64) {
|
||||
match c {
|
||||
Color::Rgb(r, g, b) => (f64::from(r), f64::from(g), f64::from(b)),
|
||||
other => panic!("theme colours must be Color::Rgb for contrast checks; got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// WCAG 2.x relative luminance of an sRGB colour.
|
||||
// The luminance/Lab/CIEDE2000 maths below are published standards; we
|
||||
// keep them in canonical `a*x + b*y` form (verified against reference
|
||||
// vectors) rather than refactoring into `mul_add`, which would obscure
|
||||
// the formula for a negligible test-only gain.
|
||||
#[allow(clippy::suboptimal_flops)]
|
||||
fn relative_luminance(c: Color) -> f64 {
|
||||
let chan = |v: f64| {
|
||||
let v = v / 255.0;
|
||||
if v <= 0.03928 {
|
||||
v / 12.92
|
||||
} else {
|
||||
((v + 0.055) / 1.055).powf(2.4)
|
||||
}
|
||||
};
|
||||
let (r, g, b) = rgb_channels(c);
|
||||
0.2126 * chan(r) + 0.7152 * chan(g) + 0.0722 * chan(b)
|
||||
}
|
||||
|
||||
/// WCAG 2.x contrast ratio between two colours (1.0 ..= 21.0).
|
||||
fn contrast_ratio(a: Color, b: Color) -> f64 {
|
||||
let (la, lb) = (relative_luminance(a), relative_luminance(b));
|
||||
let (hi, lo) = if la >= lb { (la, lb) } else { (lb, la) };
|
||||
(hi + 0.05) / (lo + 0.05)
|
||||
}
|
||||
|
||||
fn theme_label(t: &Theme) -> &'static str {
|
||||
match t.background {
|
||||
Background::Dark => "dark",
|
||||
Background::Light => "light",
|
||||
}
|
||||
}
|
||||
|
||||
/// Every text foreground (incl. dimmed `muted`/`tok_punct` and the
|
||||
/// syntax-token classes) on `bg`, both themes.
|
||||
fn text_foregrounds(t: &Theme) -> [(&'static str, Color); 17] {
|
||||
[
|
||||
("fg", t.fg),
|
||||
("muted", t.muted),
|
||||
("mode_simple", t.mode_simple),
|
||||
("mode_advanced", t.mode_advanced),
|
||||
("system", t.system),
|
||||
("error", t.error),
|
||||
("warning", t.warning),
|
||||
("plan_efficient", t.plan_efficient),
|
||||
("tok_keyword", t.tok_keyword),
|
||||
("tok_identifier", t.tok_identifier),
|
||||
("tok_type", t.tok_type),
|
||||
("tok_number", t.tok_number),
|
||||
("tok_string", t.tok_string),
|
||||
("tok_punct", t.tok_punct),
|
||||
("tok_flag", t.tok_flag),
|
||||
("tok_error", t.tok_error),
|
||||
("tok_function", t.tok_function),
|
||||
]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_text_colours_meet_wcag_aa_contrast() {
|
||||
for t in [Theme::dark(), Theme::light()] {
|
||||
let label = theme_label(&t);
|
||||
for (name, c) in text_foregrounds(&t) {
|
||||
let ratio = contrast_ratio(c, t.bg);
|
||||
assert!(
|
||||
ratio >= 4.5,
|
||||
"{label} theme: {name} contrast {ratio:.2}:1 on bg is below WCAG-AA 4.5:1",
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn advanced_mode_border_meets_ui_contrast() {
|
||||
// The advanced-mode border carries a mode-warning signal, so it
|
||||
// meets WCAG's 3:1 non-text / UI-component threshold in both
|
||||
// themes. The plain `border` is decorative structural chrome and
|
||||
// is intentionally exempt (recorded in ADR-0057).
|
||||
for t in [Theme::dark(), Theme::light()] {
|
||||
let label = theme_label(&t);
|
||||
let ratio = contrast_ratio(t.border_advanced, t.bg);
|
||||
assert!(
|
||||
ratio >= 3.0,
|
||||
"{label} theme: border_advanced contrast {ratio:.2}:1 below the 3:1 UI bar",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- NFR-5 perceptual distinctness (ADR-0057) ----
|
||||
//
|
||||
// Contrast-against-background is necessary but not sufficient: two
|
||||
// token colours can each clear 4.5:1 yet be hard to tell APART from
|
||||
// each other (a real pain reported on high-quality screens). We lock
|
||||
// that in with a CIEDE2000 (ΔE2000) floor between every pair of
|
||||
// syntax-token classes that can share a line. The metric itself is
|
||||
// validated against the Sharma et al. reference vectors.
|
||||
|
||||
/// sRGB `Color` → CIELAB (D65), for perceptual-difference checks.
|
||||
#[allow(clippy::suboptimal_flops)]
|
||||
fn rgb_to_lab(c: Color) -> (f64, f64, f64) {
|
||||
let lin = |v: f64| {
|
||||
let v = v / 255.0;
|
||||
if v <= 0.03928 {
|
||||
v / 12.92
|
||||
} else {
|
||||
((v + 0.055) / 1.055).powf(2.4)
|
||||
}
|
||||
};
|
||||
let (r0, g0, b0) = rgb_channels(c);
|
||||
let (r, g, b) = (lin(r0), lin(g0), lin(b0));
|
||||
let x = (r * 0.4124 + g * 0.3576 + b * 0.1805) / 0.950_47;
|
||||
let y = r * 0.2126 + g * 0.7152 + b * 0.0722;
|
||||
let z = (r * 0.0193 + g * 0.1192 + b * 0.9505) / 1.088_83;
|
||||
let f = |t: f64| {
|
||||
if t > 0.008_856 {
|
||||
t.cbrt()
|
||||
} else {
|
||||
7.787 * t + 16.0 / 116.0
|
||||
}
|
||||
};
|
||||
let (fx, fy, fz) = (f(x), f(y), f(z));
|
||||
(116.0 * fy - 16.0, 500.0 * (fx - fy), 200.0 * (fy - fz))
|
||||
}
|
||||
|
||||
/// CIEDE2000 colour difference between two CIELAB values.
|
||||
#[allow(clippy::suboptimal_flops)]
|
||||
fn delta_e_2000(lab1: (f64, f64, f64), lab2: (f64, f64, f64)) -> f64 {
|
||||
let (l1, a1, b1) = lab1;
|
||||
let (l2, a2, b2) = lab2;
|
||||
let pow7 = |v: f64| v.powi(7);
|
||||
let k_l = pow7(25.0);
|
||||
|
||||
let avg_lp = (l1 + l2) / 2.0;
|
||||
let c1 = a1.hypot(b1);
|
||||
let c2 = a2.hypot(b2);
|
||||
let avg_c = (c1 + c2) / 2.0;
|
||||
let g = if avg_c > 0.0 {
|
||||
0.5 * (1.0 - (pow7(avg_c) / (pow7(avg_c) + k_l)).sqrt())
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let a1p = (1.0 + g) * a1;
|
||||
let a2p = (1.0 + g) * a2;
|
||||
let c1p = a1p.hypot(b1);
|
||||
let c2p = a2p.hypot(b2);
|
||||
let avg_cp = (c1p + c2p) / 2.0;
|
||||
|
||||
let hp = |ap: f64, b: f64| -> f64 {
|
||||
if ap == 0.0 && b == 0.0 {
|
||||
return 0.0;
|
||||
}
|
||||
let ang = b.atan2(ap).to_degrees();
|
||||
if ang < 0.0 { ang + 360.0 } else { ang }
|
||||
};
|
||||
let h1p = hp(a1p, b1);
|
||||
let h2p = hp(a2p, b2);
|
||||
|
||||
let dlp = l2 - l1;
|
||||
let dcp = c2p - c1p;
|
||||
let dhp = if c1p * c2p == 0.0 {
|
||||
0.0
|
||||
} else if (h2p - h1p).abs() <= 180.0 {
|
||||
h2p - h1p
|
||||
} else if h2p - h1p > 180.0 {
|
||||
h2p - h1p - 360.0
|
||||
} else {
|
||||
h2p - h1p + 360.0
|
||||
};
|
||||
let d_big_hp = 2.0 * (c1p * c2p).sqrt() * (dhp.to_radians() / 2.0).sin();
|
||||
|
||||
let avg_hp = if c1p * c2p == 0.0 {
|
||||
h1p + h2p
|
||||
} else if (h1p - h2p).abs() <= 180.0 {
|
||||
(h1p + h2p) / 2.0
|
||||
} else if h1p + h2p < 360.0 {
|
||||
(h1p + h2p + 360.0) / 2.0
|
||||
} else {
|
||||
(h1p + h2p - 360.0) / 2.0
|
||||
};
|
||||
let t = 1.0 - 0.17 * (avg_hp - 30.0).to_radians().cos()
|
||||
+ 0.24 * (2.0 * avg_hp).to_radians().cos()
|
||||
+ 0.32 * (3.0 * avg_hp + 6.0).to_radians().cos()
|
||||
- 0.20 * (4.0 * avg_hp - 63.0).to_radians().cos();
|
||||
let d_ro = 30.0 * (-((avg_hp - 275.0) / 25.0).powi(2)).exp();
|
||||
let rc = if avg_cp > 0.0 {
|
||||
2.0 * (pow7(avg_cp) / (pow7(avg_cp) + k_l)).sqrt()
|
||||
} else {
|
||||
0.0
|
||||
};
|
||||
let sl = 1.0 + (0.015 * (avg_lp - 50.0).powi(2)) / (20.0 + (avg_lp - 50.0).powi(2)).sqrt();
|
||||
let sc = 1.0 + 0.045 * avg_cp;
|
||||
let sh = 1.0 + 0.015 * avg_cp * t;
|
||||
let rt = -(2.0 * d_ro.to_radians()).sin() * rc;
|
||||
|
||||
((dlp / sl).powi(2)
|
||||
+ (dcp / sc).powi(2)
|
||||
+ (d_big_hp / sh).powi(2)
|
||||
+ rt * (dcp / sc) * (d_big_hp / sh))
|
||||
.sqrt()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delta_e_2000_matches_reference_vectors() {
|
||||
// Sharma, Wu & Dalal (2005) CIEDE2000 test data — validates the
|
||||
// metric so the distinctness gate below rests on a correct base.
|
||||
let cases = [
|
||||
((50.0, 2.6772, -79.7751), (50.0, 0.0, -82.7485), 2.0425),
|
||||
((50.0, 3.1571, -77.2803), (50.0, 0.0, -82.7485), 2.8615),
|
||||
((50.0, 2.4900, -0.0010), (50.0, -2.4900, 0.0009), 7.1792),
|
||||
((50.0, -1.0, 2.0), (50.0, 0.0, 0.0), 2.3669),
|
||||
];
|
||||
for (l1, l2, exp) in cases {
|
||||
let got = delta_e_2000(l1, l2);
|
||||
assert!(
|
||||
(got - exp).abs() < 0.01,
|
||||
"ΔE2000 {got:.4} != reference {exp:.4}",
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn syntax_token_colours_are_perceptually_distinct() {
|
||||
// Every pair of syntax-token classes that can appear together on
|
||||
// one line must be perceptually separable, not merely unequal in
|
||||
// hex. Floor at ΔE2000 >= 15 (post-ADR-0057 minimum is ~18).
|
||||
// Excludes tok_punct (== muted) and tok_error (== error), which
|
||||
// deliberately alias other roles.
|
||||
const MIN_DE: f64 = 15.0;
|
||||
for t in [Theme::dark(), Theme::light()] {
|
||||
let label = theme_label(&t);
|
||||
let toks = [
|
||||
("tok_keyword", t.tok_keyword),
|
||||
("tok_identifier", t.tok_identifier),
|
||||
("tok_type", t.tok_type),
|
||||
("tok_number", t.tok_number),
|
||||
("tok_string", t.tok_string),
|
||||
("tok_flag", t.tok_flag),
|
||||
("tok_function", t.tok_function),
|
||||
];
|
||||
for (i, (name_a, ca)) in toks.iter().enumerate() {
|
||||
for (name_b, cb) in toks.iter().skip(i + 1) {
|
||||
let de = delta_e_2000(rgb_to_lab(*ca), rgb_to_lab(*cb));
|
||||
assert!(
|
||||
de >= MIN_DE,
|
||||
"{label} theme: {name_a} vs {name_b} ΔE2000 {de:.1} below {MIN_DE} — too similar",
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,420 @@
|
||||
//! Tier-4 PTY-based end-to-end tests (ADR-0008 §Tier-4, requirements TT4).
|
||||
//!
|
||||
//! These drive the **actual built binary** in a real pseudo-terminal and
|
||||
//! assert on what a user would see on screen — catching what the lower
|
||||
//! tiers can't: TTY setup, raw-mode / alternate-screen transitions, real
|
||||
//! I/O timing, and graceful quit. The four flows mirror ADR-0008's
|
||||
//! initial Tier-4 scope exactly:
|
||||
//!
|
||||
//! 1. cold launch → first DDL command → graceful quit
|
||||
//! 2. project save → reopen → identical state
|
||||
//! 3. project export → import into a fresh project → rebuilt state
|
||||
//! 4. `undo` immediately after `DROP TABLE` (incl. the confirm modal)
|
||||
//!
|
||||
//! Tooling (ADR-0008, refined): `portable-pty` to spawn the binary in a
|
||||
//! PTY at a fixed window size, `vt100` to parse the output stream into an
|
||||
//! inspectable screen grid. ADR-0008 also named `expectrl`; we dropped it
|
||||
//! — it bundles its own PTY abstraction (conflicts with portable-pty) and
|
||||
//! is line-oriented, a poor fit for a full-screen TUI. A small hand-rolled
|
||||
//! `wait_for` polling the vt100 screen replaces it.
|
||||
//!
|
||||
//! Determinism: each test gets its own temp `--data-dir` (no contact with
|
||||
//! the user's real projects / resume state), a fixed 100×30 terminal (the
|
||||
//! wide three-region layout, ADR-0046), and `--theme dark`. Tests run
|
||||
//! **serially** (one PTY + child process at a time) so timing stays
|
||||
//! predictable on the low-parallelism self-hosted CI runner, with tight,
|
||||
//! fail-fast timeouts: a slow wait means a real hang, not contention.
|
||||
|
||||
// `PtyApp` deliberately holds a serial `MutexGuard` for its whole lifetime
|
||||
// (to run PTY tests one at a time), and the screen-reading helpers hold the
|
||||
// vt100 parser lock for the duration of a read. `significant_drop_tightening`
|
||||
// flags both as droppable-earlier, but tightening them is either impossible
|
||||
// (the guard *is* the serialization) or pointless here.
|
||||
#![allow(clippy::significant_drop_tightening)]
|
||||
|
||||
use std::io::{Read, Write};
|
||||
use std::path::Path;
|
||||
use std::sync::{Arc, Mutex, MutexGuard};
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use portable_pty::{CommandBuilder, MasterPty, PtySize, native_pty_system};
|
||||
use tempfile::TempDir;
|
||||
|
||||
const COLS: u16 = 100;
|
||||
const ROWS: u16 = 30;
|
||||
/// Tight, fail-fast wait. The self-hosted runner has little parallelism,
|
||||
/// so anything slower than this is a genuine hang worth failing on.
|
||||
const WAIT: Duration = Duration::from_secs(3);
|
||||
const POLL: Duration = Duration::from_millis(20);
|
||||
|
||||
/// Tier-4 tests share one global lock so only one PTY + child runs at a
|
||||
/// time (predictable timing; no resource races). Poison-tolerant so a
|
||||
/// panicking test doesn't cascade-fail the rest.
|
||||
static SERIAL: Mutex<()> = Mutex::new(());
|
||||
|
||||
fn lock_serial() -> MutexGuard<'static, ()> {
|
||||
SERIAL
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
}
|
||||
|
||||
/// A running instance of the app under a pseudo-terminal.
|
||||
struct PtyApp {
|
||||
_serial: MutexGuard<'static, ()>,
|
||||
/// Present when this instance owns its data dir (single-launch
|
||||
/// flows); `None` when the test owns it (multi-launch flows that
|
||||
/// reopen the same dir).
|
||||
_owned_dir: Option<TempDir>,
|
||||
_master: Box<dyn MasterPty + Send>,
|
||||
writer: Box<dyn Write + Send>,
|
||||
parser: Arc<Mutex<vt100::Parser>>,
|
||||
child: Box<dyn portable_pty::Child + Send + Sync>,
|
||||
_reader: thread::JoinHandle<()>,
|
||||
/// Spawn → first rendered frame (the `SIMPLE` mode label). Measured
|
||||
/// for NFR-1; note this is the *debug* binary, so it's a generous
|
||||
/// gross-regression signal, not the release startup figure.
|
||||
startup: Duration,
|
||||
}
|
||||
|
||||
impl PtyApp {
|
||||
/// Launch against a fresh, owned temp data dir.
|
||||
fn launch(args: &[&str]) -> Self {
|
||||
let dir = TempDir::new().expect("create temp data dir");
|
||||
let mut app = Self::launch_in(dir.path(), args);
|
||||
app._owned_dir = Some(dir);
|
||||
app
|
||||
}
|
||||
|
||||
/// Launch against a caller-owned data dir (so a later launch can
|
||||
/// reopen the same projects — flow 2).
|
||||
fn launch_in(data_dir: &Path, args: &[&str]) -> Self {
|
||||
let serial = lock_serial();
|
||||
let pty = native_pty_system();
|
||||
let pair = pty
|
||||
.openpty(PtySize {
|
||||
rows: ROWS,
|
||||
cols: COLS,
|
||||
pixel_width: 0,
|
||||
pixel_height: 0,
|
||||
})
|
||||
.expect("open pty");
|
||||
|
||||
let mut cmd = CommandBuilder::new(env!("CARGO_BIN_EXE_rdbms-playground"));
|
||||
cmd.arg("--data-dir");
|
||||
cmd.arg(data_dir);
|
||||
cmd.arg("--theme");
|
||||
cmd.arg("dark");
|
||||
for a in args {
|
||||
cmd.arg(a);
|
||||
}
|
||||
cmd.env("TERM", "xterm-256color");
|
||||
cmd.env("RDBMS_PLAYGROUND_DEMO", "0");
|
||||
cmd.cwd(data_dir);
|
||||
|
||||
let started = Instant::now();
|
||||
let child = pair.slave.spawn_command(cmd).expect("spawn binary");
|
||||
drop(pair.slave); // we never write to the slave directly
|
||||
|
||||
let parser = Arc::new(Mutex::new(vt100::Parser::new(ROWS, COLS, 0)));
|
||||
let mut reader = pair.master.try_clone_reader().expect("clone pty reader");
|
||||
let writer = pair.master.take_writer().expect("take pty writer");
|
||||
|
||||
let parser_for_reader = Arc::clone(&parser);
|
||||
let reader_handle = thread::spawn(move || {
|
||||
let mut buf = [0u8; 8192];
|
||||
loop {
|
||||
match reader.read(&mut buf) {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => parser_for_reader
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.process(&buf[..n]),
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let mut app = Self {
|
||||
_serial: serial,
|
||||
_owned_dir: None,
|
||||
_master: pair.master,
|
||||
writer,
|
||||
parser,
|
||||
child,
|
||||
_reader: reader_handle,
|
||||
startup: Duration::ZERO,
|
||||
};
|
||||
// Every flow needs a booted, idle app; block on the first frame.
|
||||
app.wait_for("SIMPLE");
|
||||
app.startup = started.elapsed();
|
||||
app
|
||||
}
|
||||
|
||||
/// Current visible screen as text (one line per row, trailing blanks
|
||||
/// trimmed) — what a human would read.
|
||||
fn screen_text(&self) -> String {
|
||||
self.parser
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
||||
.screen()
|
||||
.contents()
|
||||
}
|
||||
|
||||
/// Text of just the left **Tables sidebar** region (first
|
||||
/// [`SIDEBAR_W`] columns). The Output panel echoes every command, so
|
||||
/// a table name typed in a command pollutes a whole-screen match —
|
||||
/// table presence/absence must be read from the sidebar, where the
|
||||
/// items list actually lives.
|
||||
fn sidebar(&self) -> String {
|
||||
const SIDEBAR_W: u16 = 28;
|
||||
let parser = self
|
||||
.parser
|
||||
.lock()
|
||||
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
||||
let screen = parser.screen();
|
||||
let mut out = String::new();
|
||||
for row in 0..ROWS {
|
||||
for col in 0..SIDEBAR_W {
|
||||
if let Some(cell) = screen.cell(row, col) {
|
||||
out.push_str(cell.contents());
|
||||
}
|
||||
}
|
||||
out.push('\n');
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// Poll a predicate to the tight timeout, panicking with a screen dump.
|
||||
fn wait_until(&self, desc: &str, pred: impl Fn(&Self) -> bool) {
|
||||
let deadline = Instant::now() + WAIT;
|
||||
loop {
|
||||
if pred(self) {
|
||||
return;
|
||||
}
|
||||
assert!(
|
||||
Instant::now() < deadline,
|
||||
"timed out after {WAIT:?} waiting for {desc}\n\
|
||||
----- screen -----\n{}\n------------------",
|
||||
self.screen_text(),
|
||||
);
|
||||
thread::sleep(POLL);
|
||||
}
|
||||
}
|
||||
|
||||
/// Wait for `needle` anywhere on screen (Output-panel messages, modals).
|
||||
fn wait_for(&self, needle: &str) {
|
||||
self.wait_until(&format!("{needle:?} on screen"), |a| {
|
||||
a.screen_text().contains(needle)
|
||||
});
|
||||
}
|
||||
|
||||
/// Wait for a table `name` to appear in the Tables sidebar.
|
||||
fn wait_for_table(&self, name: &str) {
|
||||
self.wait_until(&format!("table {name:?} in sidebar"), |a| {
|
||||
a.sidebar().contains(name)
|
||||
});
|
||||
}
|
||||
|
||||
/// Wait for the Tables sidebar to be empty (the `(none yet)` placeholder).
|
||||
fn wait_for_no_tables(&self) {
|
||||
self.wait_until("empty Tables sidebar", |a| {
|
||||
a.sidebar().contains("(none yet)")
|
||||
});
|
||||
}
|
||||
|
||||
fn send(&mut self, bytes: &[u8]) {
|
||||
self.writer.write_all(bytes).expect("write to pty");
|
||||
self.writer.flush().expect("flush pty");
|
||||
}
|
||||
|
||||
/// Type a command and submit it (Enter == carriage return in raw mode).
|
||||
fn submit(&mut self, line: &str) {
|
||||
self.send(line.as_bytes());
|
||||
self.send(b"\r");
|
||||
}
|
||||
|
||||
fn pid(&self) -> Option<u32> {
|
||||
self.child.process_id()
|
||||
}
|
||||
|
||||
/// Resident set size of the child in KiB (Linux only).
|
||||
#[cfg(target_os = "linux")]
|
||||
fn rss_kib(&self) -> Option<u64> {
|
||||
let pid = self.pid()?;
|
||||
let status = std::fs::read_to_string(format!("/proc/{pid}/status")).ok()?;
|
||||
status.lines().find_map(|l| {
|
||||
let rest = l.strip_prefix("VmRSS:")?;
|
||||
rest.split_whitespace().next()?.parse::<u64>().ok()
|
||||
})
|
||||
}
|
||||
|
||||
/// Send Ctrl-C and assert the process exits cleanly within the wait.
|
||||
fn quit(mut self) {
|
||||
self.send(b"\x03");
|
||||
let deadline = Instant::now() + WAIT;
|
||||
loop {
|
||||
match self.child.try_wait() {
|
||||
Ok(Some(status)) => {
|
||||
assert!(status.success(), "app exited unsuccessfully: {status:?}");
|
||||
return;
|
||||
}
|
||||
Ok(None) => {}
|
||||
Err(e) => panic!("waiting on child failed: {e}"),
|
||||
}
|
||||
if Instant::now() >= deadline {
|
||||
let _ = self.child.kill();
|
||||
panic!(
|
||||
"app did not exit within {WAIT:?} of Ctrl-C\n\
|
||||
----- screen -----\n{}\n------------------",
|
||||
self.screen_text(),
|
||||
);
|
||||
}
|
||||
thread::sleep(POLL);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for PtyApp {
|
||||
fn drop(&mut self) {
|
||||
// Never leak a child process, even if a test panicked mid-flow.
|
||||
let _ = self.child.kill();
|
||||
let _ = self.child.wait();
|
||||
}
|
||||
}
|
||||
|
||||
// ============================ the four flows ===========================
|
||||
|
||||
/// Flow 1 — cold launch → first DDL command → graceful quit.
|
||||
#[test]
|
||||
fn cold_launch_ddl_and_quit() {
|
||||
let mut app = PtyApp::launch(&[]);
|
||||
app.wait_for_no_tables(); // fresh project: empty sidebar
|
||||
app.submit("create table Customers with pk id(serial)");
|
||||
app.wait_for_table("Customers"); // table appears in the sidebar
|
||||
app.quit();
|
||||
}
|
||||
|
||||
/// Flow 2 — create, quit, reopen the same project (`--resume`), identical
|
||||
/// state. Persistence is per-command autosave; the kept temp is recorded
|
||||
/// as the resume target on quit (ADR-0015).
|
||||
#[test]
|
||||
fn save_quit_and_reopen_restores_state() {
|
||||
let dir = TempDir::new().expect("shared data dir");
|
||||
|
||||
let mut app = PtyApp::launch_in(dir.path(), &[]);
|
||||
app.submit("create table Customers with pk id(serial)");
|
||||
app.wait_for_table("Customers");
|
||||
app.submit("add column to Customers: Name (text)");
|
||||
app.wait_for("Name (text) ✓");
|
||||
app.quit();
|
||||
|
||||
// Reopen the most-recently-used project from the same data root, then
|
||||
// assert the *column* survived — not just the table name — so "identical
|
||||
// state" means the schema, not merely that some table exists. In this
|
||||
// fresh process "Name" appears only from the show-data header.
|
||||
let mut reopened = PtyApp::launch_in(dir.path(), &["--resume"]);
|
||||
reopened.wait_for_table("Customers");
|
||||
reopened.submit("show data Customers");
|
||||
reopened.wait_for("Name"); // the added column round-tripped through restart
|
||||
reopened.quit();
|
||||
}
|
||||
|
||||
/// Flow 3 — export a project, import it into a fresh project, confirm the
|
||||
/// rebuilt database carries the schema and data.
|
||||
#[test]
|
||||
fn export_then_import_into_fresh_project() {
|
||||
let zip_dir = TempDir::new().expect("zip dir");
|
||||
let zip_path = zip_dir.path().join("export.zip");
|
||||
let zip = zip_path.to_str().expect("utf-8 zip path");
|
||||
|
||||
// Source project: a table with one data row. `Name` is a regular
|
||||
// column (added separately) — putting it in the `with pk` clause would
|
||||
// make a compound PK and block the serial auto-fill.
|
||||
let mut source = PtyApp::launch(&[]);
|
||||
source.submit("create table Customers with pk id(serial)");
|
||||
source.wait_for_table("Customers");
|
||||
// Pace each command to completion before the next — driving a TUI, like
|
||||
// a real user (or the cast driver), means waiting for each result. A
|
||||
// command sent while the previous one's worker rebuild is still in
|
||||
// flight can be misread against a stale schema cache (issue #39).
|
||||
source.submit("add column to Customers: Name (text)");
|
||||
source.wait_for("Name (text) ✓");
|
||||
source.submit("insert into Customers values ('Alice')");
|
||||
// The insert's OWN success echo (value + ✓) — not a bare "✓", which the
|
||||
// create already painted — so export runs only once the row is in CSV.
|
||||
source.wait_for("('Alice') ✓");
|
||||
source.submit(&format!("export {zip}"));
|
||||
source.wait_for("[ok] export");
|
||||
source.quit();
|
||||
|
||||
// Fresh project (new data dir): import the zip. Import switches to the
|
||||
// imported project, rebuilding its db from text since the export omits
|
||||
// the .db (ADR-0004/0015). "Alice" is unambiguous here — it appears in
|
||||
// no command typed into this instance, only in a rebuilt data row.
|
||||
let mut target = PtyApp::launch(&[]);
|
||||
target.submit(&format!("import {zip}"));
|
||||
target.wait_for("now editing"); // switched to the imported project
|
||||
target.wait_for_table("Customers"); // schema rebuilt
|
||||
target.submit("show data Customers");
|
||||
target.wait_for("Alice"); // data rebuilt from the CSV
|
||||
target.quit();
|
||||
}
|
||||
|
||||
/// Flow 4 — `undo` immediately after `DROP TABLE`, including the
|
||||
/// confirmation modal.
|
||||
#[test]
|
||||
fn undo_after_drop_table_restores_it() {
|
||||
let mut app = PtyApp::launch(&[]);
|
||||
app.submit("create table Customers with pk id(serial)");
|
||||
app.wait_for_table("Customers");
|
||||
|
||||
app.submit("drop table Customers");
|
||||
app.wait_for_no_tables(); // gone from the sidebar
|
||||
|
||||
app.submit("undo");
|
||||
app.wait_for("Restore that earlier state?"); // the confirm modal
|
||||
app.send(b"y"); // confirm
|
||||
app.wait_for_table("Customers"); // table restored in the sidebar
|
||||
app.quit();
|
||||
}
|
||||
|
||||
// ===================== NFR perf (measured, generous) ===================
|
||||
//
|
||||
// These run against the DEBUG binary, so the bounds are loose
|
||||
// gross-regression catches, not the NFR targets. The real NFR-1 (startup
|
||||
// < 500 ms) and NFR-3 (idle RSS < 50 MB) figures are measured on a
|
||||
// --release build and recorded in the NFR verification doc (ADR-0057).
|
||||
|
||||
/// NFR-1 — startup to first rendered frame. Generous debug-binary bound.
|
||||
#[test]
|
||||
fn startup_to_first_frame_is_reasonable() {
|
||||
let app = PtyApp::launch(&[]);
|
||||
let ms = app.startup.as_millis();
|
||||
eprintln!("NFR-1 startup (debug binary, under test harness): {ms} ms");
|
||||
assert!(
|
||||
app.startup < Duration::from_millis(2000),
|
||||
"startup {ms} ms exceeds the generous 2000 ms debug bound — likely a real regression",
|
||||
);
|
||||
app.quit();
|
||||
}
|
||||
|
||||
/// NFR-3 — idle resident memory. Generous debug-binary bound (Linux only;
|
||||
/// reads the child's /proc VmRSS).
|
||||
#[cfg(target_os = "linux")]
|
||||
#[test]
|
||||
fn idle_memory_footprint_is_reasonable() {
|
||||
let app = PtyApp::launch(&[]);
|
||||
// Already idle after the readiness wait; let it settle a moment.
|
||||
thread::sleep(Duration::from_millis(200));
|
||||
let rss = app.rss_kib().expect("read VmRSS");
|
||||
eprintln!(
|
||||
"NFR-3 idle RSS (debug binary): {} KiB ({:.1} MB)",
|
||||
rss,
|
||||
rss as f64 / 1024.0,
|
||||
);
|
||||
assert!(
|
||||
rss < 150_000,
|
||||
"idle RSS {rss} KiB exceeds the generous 150 MB debug bound — likely a real regression",
|
||||
);
|
||||
app.quit();
|
||||
}
|
||||
Reference in New Issue
Block a user