test/fix(schema): more patch coverage; normalise renderRegex whitespace

Codecov measured 95.59% patch coverage on the previous push,
just below the 96.07% target. Add targeted tests for the
remaining easy branches in expected.go, hint.go, and
validate.go: regex unquote failure, half-open upper-bound int
range, parseRenderedBounds half-open upper return, and the
front-matter-stripped path of docFrontmatterKeyLines. Local
patch coverage now reads 97.4% on the changed lines.

Address a Copilot review observation on renderRegex line 75:
the helper used to strip only the exact prefix `string &`
(with a space), so the equivalent CUE form `string&=~"^A$"`
fell through to the raw expression. Normalise by stripping
`string` then `&` with optional whitespace between them so the
renderer recognises both spellings. A new
TestRenderExpected_RegexNoWhitespace regresses every variant.

https://claude.ai/code/session_01QcXckX3yVwReho2kaq3qRK

Author: claude

internal/schema/expected.go

@@ -61,15 +61,25 @@ func renderStringDisjunction(expr string) (string, bool) {
 	return "one of: " + strings.Join(literals, ", "), true
 }
 
-// renderRegex matches `=~"<pattern>"` (with optional surrounding
-// `string &`) and renders it as `string matching <pattern>`.
-// Bare regex matchers without a `string &` cover the common
-// proto.md shape; constraints that further restrict the type
-// fall through to the raw expression.
+// renderRegex matches `=~"<pattern>"` (with an optional
+// surrounding `string &`) and renders it as `string matching
+// <pattern>`. Bare regex matchers without a `string &` cover
+// the common proto.md shape; constraints that further restrict
+// the type fall through to the raw expression.
+//
+// CUE doesn't require whitespace around `&`, so both
+// `string & =~"^A$"` and `string&=~"^A$"` are valid input.
+// We normalise by splitting on the `=~` token directly rather
+// than the whitespace-sensitive `string &` prefix, so format
+// drift on the input side doesn't lose the rendered shape.
 func renderRegex(expr string) (string, bool) {
-	body := expr
+	body := strings.TrimSpace(expr)
+	// Strip an optional `string` prefix and any `&` (with or
+	// without surrounding whitespace) so we land directly on
+	// the `=~` token.
+	body = strings.TrimPrefix(body, "string")
 	body = strings.TrimSpace(body)
-	body = strings.TrimPrefix(body, "string &")
+	body = strings.TrimPrefix(body, "&")
 	body = strings.TrimSpace(body)
 	if !strings.HasPrefix(body, "=~") {
 		return "", false

internal/schema/expected_coverage_test.go

@@ -78,3 +78,36 @@ func TestRenderExpected_IntRangeUnknownOperand(t *testing.T) {
 	got := RenderExpected("int & some-other & >=1")
 	assert.Equal(t, "int & some-other & >=1", got)
 }
+
+// TestRenderExpected_RegexNoWhitespace regresses a Copilot
+// review observation: `string&=~"^A$"` (no spaces around `&`)
+// is semantically equivalent to `string & =~"^A$"`. Both now
+// render as `string matching <pattern>` instead of falling
+// through to the raw expression.
+func TestRenderExpected_RegexNoWhitespace(t *testing.T) {
+	cases := map[string]string{
+		`string&=~"^A$"`:  "string matching ^A$",
+		`string &=~"^B$"`: "string matching ^B$",
+		`string& =~"^C$"`: "string matching ^C$",
+		`=~"^D$"`:         "string matching ^D$",
+	}
+	for in, want := range cases {
+		assert.Equal(t, want, RenderExpected(in), "input: %q", in)
+	}
+}
+
+// TestRenderExpected_RegexUnquoteFailure covers the
+// strconv.Unquote error branch in renderRegex: a pattern
+// with a malformed escape sequence (e.g. `\q` which Go does
+// not recognise) is rejected after isQuotedString accepts
+// the outer quotes.
+func TestRenderExpected_RegexUnquoteFailure(t *testing.T) {
+	assert.Equal(t, `=~"\q"`, RenderExpected(`=~"\q"`))
+}
+
+// TestRenderExpected_IntRangeUpperHalfOpen covers the
+// half-open upper-bound render branch (`int <= N`) that the
+// other tests miss when the lower bound is unspecified.
+func TestRenderExpected_IntRangeUpperHalfOpen(t *testing.T) {
+	assert.Equal(t, "int <= 5", RenderExpected("int & <=5"))
+}

internal/schema/hint_coverage_test.go

@@ -38,9 +38,11 @@ func TestRenderHint_NonQuotedAlternative(t *testing.T) {
 // error branch: a malformed escape inside a string literal
 // prevents the literal from being decoded, so no hint fires.
 func TestRenderHint_UnquoteFailure(t *testing.T) {
-	// Two alternatives so len(parts) >= 2; the bad escape
-	// breaks Unquote on the second literal.
-	assert.Empty(t, RenderHint(`"ok" | "\xff"`, "ok-typo"))
+	// `"\q"` uses an invalid Go escape sequence (`\q` is
+	// not a recognised letter). isQuotedString accepts it
+	// (it starts and ends with `"`), but strconv.Unquote
+	// fails, exercising the error branch.
+	assert.Empty(t, RenderHint(`"ok" | "\q"`, "qq"))
 }
 
 // TestRenderHint_ExactMatchSkipped covers the d==0 branch:
@@ -119,6 +121,17 @@ func TestParseRenderedBounds_Edges(t *testing.T) {
 		assert.False(t, hasLo)
 		assert.False(t, hasHi)
 	})
+
+	t.Run("half-open upper bound parses cleanly", func(t *testing.T) {
+		// `int <= 5` is the upper half-open form; the helper
+		// returns (0, 5, false, true). The other tests use
+		// `int >= N` which already covers the lower-half
+		// branch.
+		_, hi, hasLo, hasHi := parseRenderedBounds("int <= 5")
+		assert.False(t, hasLo)
+		assert.True(t, hasHi)
+		assert.Equal(t, 5, hi)
+	})
 }
 
 // TestLevenshtein_InlineGuardKicksIn exercises the

internal/schema/validate_coverage_test.go

@@ -246,3 +246,19 @@ func TestDocFrontmatterKeyLines_SourceFallback(t *testing.T) {
 	assert.Equal(t, 2, lines["id"])
 	assert.Equal(t, 3, lines["status"])
 }
+
+// TestDocFrontmatterKeyLines_StrippedFrontMatter covers the
+// production path: lint.NewFileFromSource(..., true) leaves
+// f.FrontMatter populated with the stripped block. The
+// helper goes through parseFMBlockKeyLines directly without
+// re-extracting from the source.
+func TestDocFrontmatterKeyLines_StrippedFrontMatter(t *testing.T) {
+	src := []byte("---\nid: 1\nstatus: open\n---\n# Body\n")
+	f, err := lint.NewFileFromSource("doc.md", src, true)
+	require.NoError(t, err)
+	require.NotEmpty(t, f.FrontMatter)
+	lines := docFrontmatterKeyLines(f)
+	require.NotNil(t, lines)
+	assert.Equal(t, 2, lines["id"])
+	assert.Equal(t, 3, lines["status"])
+}