test(schema): cover edge branches for codecov patch gate

The PR's codecov/patch check failed at 85.86% (target 96.07%)
because several edge branches in the new diagnostic /
expected-value / hint code lacked tests:

- diagnostic.go: no-Actual / field-only Format() paths;
  formatActual's json.Marshal fallback for unmarshalable
  values
- expected.go: empty input, non-quoted disjunction
  alternative, regex unquote failure, mixed-exclusive int
  range, missing int keyword, unknown operand
- hint.go: non-string actual, single-part disjunction,
  unquote failure, exact-match skip, int / int64 actuals,
  parseRenderedBounds malformed-input branches, levenshtein
  empty / over-cap fallback, runeCountAtMost / tooLong
  helpers
- validate.go: schemaKeyForPath / lookupConstraint /
  lookupFM / schemaRef edge cases; json.Marshal failure
  path; extra-field branch; docFrontmatterKeyLines source-
  fallback for files built via lint.NewFile (the integration
  runner's mode)

Patch coverage on the changed lines climbs from 85.86% to
~96.3%, satisfying the codecov/patch gate.

https://claude.ai/code/session_01QcXckX3yVwReho2kaq3qRK

Author: claude

internal/schema/diagnostic_test.go

@@ -32,6 +32,42 @@ func TestSchemaDiagnostic_Format_AllFields(t *testing.T) {
 	assert.Equal(t, want, got)
 }
 
+// TestSchemaDiagnostic_Format_NoActual covers the branch
+// where Field and Expected are set but Actual is empty: the
+// rendered message uses ": expected ..." rather than the
+// "got X, expected Y" form, so absent-but-known constraints
+// (e.g. a wildcard-text scope) read cleanly.
+func TestSchemaDiagnostic_Format_NoActual(t *testing.T) {
+	d := SchemaDiagnostic{
+		Field:     "## Goal",
+		Expected:  "section to be present",
+		SchemaRef: "kind plan",
+	}
+	want := "## Goal: expected section to be present\nschema: kind plan"
+	assert.Equal(t, want, d.Format())
+}
+
+// TestSchemaDiagnostic_Format_FieldOnly covers the very
+// minimal render: just a field name with no actual,
+// expected, hint, or schema ref. The renderer should still
+// produce a non-empty string.
+func TestSchemaDiagnostic_Format_FieldOnly(t *testing.T) {
+	d := SchemaDiagnostic{Field: "field"}
+	assert.Equal(t, "field", d.Format())
+}
+
+// TestFormatActual_FallbackOnMarshalError exercises the
+// final fmt.Sprintf("%v", v) fallback. json.Marshal fails
+// on channels, functions, and complex values; the helper
+// degrades to the default formatter so the caller still
+// gets a printable string.
+func TestFormatActual_FallbackOnMarshalError(t *testing.T) {
+	// Channels can't be JSON-marshalled; the helper falls
+	// through to %v which produces a pointer-shaped string.
+	got := formatActual(make(chan int))
+	assert.NotEmpty(t, got)
+}
+
 // TestSchemaDiagnostic_Format_NoHint covers the no-hint branch:
 // when the extractor cannot suggest a fix, the message ends at the
 // expected line and goes straight to the schema reference.

internal/schema/expected_coverage_test.go

@@ -0,0 +1,80 @@
+package schema
+
+import (
+	"math"
+	"strconv"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestRenderExpected_Edges exercises the early-return branches
+// in RenderExpected and renderStringDisjunction / renderRegex /
+// renderNonEmptyString that previously had no test coverage.
+func TestRenderExpected_Edges(t *testing.T) {
+	t.Run("empty input returns empty", func(t *testing.T) {
+		assert.Equal(t, "", RenderExpected(""))
+		// Whitespace-only is trimmed to "" before any shape
+		// matches; the renderer returns the trimmed value.
+		assert.Equal(t, "", RenderExpected("   "))
+	})
+
+	t.Run("disjunction with non-quoted alternative falls back", func(t *testing.T) {
+		// `int | "x"` has a non-string-literal alternative; the
+		// renderer should fall back to the raw expression
+		// rather than misreport.
+		assert.Equal(t, `int | "x"`, RenderExpected(`int | "x"`))
+	})
+
+	t.Run("regex with bad unquote falls back", func(t *testing.T) {
+		// A regex pattern that uses single-quote delimiters
+		// (CUE accepts double-quoted only) can't be unquoted;
+		// the renderer falls through to the raw form.
+		assert.Equal(t, `=~'foo'`, RenderExpected(`=~'foo'`))
+	})
+
+	t.Run("regex without quoted pattern falls back", func(t *testing.T) {
+		assert.Equal(t, `=~foo`, RenderExpected(`=~foo`))
+	})
+}
+
+// TestRenderExpected_IntRangeMixed covers the mixed-exclusive
+// render branch: when one bound can be converted to inclusive
+// (`<= N-1`) but the other can't (`>MaxInt`), the renderer
+// emits both with explicit comparison operators so the
+// asymmetry stays visible.
+func TestRenderExpected_IntRangeMixed(t *testing.T) {
+	maxStr := strconv.Itoa(math.MaxInt)
+	got := RenderExpected("int & >" + maxStr + " & <=10")
+	assert.Contains(t, got, "int > "+maxStr)
+	assert.Contains(t, got, "and <= 10")
+}
+
+// TestRenderExpected_IntRangeOnlyExclusiveUpper exercises the
+// half-open upper-bound rendering with an exclusive `<` form
+// that the overflow guard preserves intact.
+func TestRenderExpected_IntRangeOnlyExclusiveUpper(t *testing.T) {
+	minStr := strconv.Itoa(math.MinInt)
+	got := RenderExpected("int & <" + minStr)
+	assert.Equal(t, "int < "+minStr, got)
+}
+
+// TestRenderExpected_IntRangeNoIntKeyword regresses the early
+// false return when the `int` keyword is missing from the
+// constraint (e.g. `>=1 & <=5` without `int &`). The
+// constraint isn't recognised as an int range, so the renderer
+// falls back to the raw expression.
+func TestRenderExpected_IntRangeNoIntKeyword(t *testing.T) {
+	got := RenderExpected(">=1 & <=5")
+	assert.Equal(t, ">=1 & <=5", got)
+}
+
+// TestRenderExpected_IntRangeUnknownOperand exercises the
+// fallback when a `&`-joined part doesn't fit the small
+// grammar (int / >=, >, <=, <). The renderer aborts and falls
+// back to the raw expression so a partial constraint never
+// reaches the user.
+func TestRenderExpected_IntRangeUnknownOperand(t *testing.T) {
+	got := RenderExpected("int & some-other & >=1")
+	assert.Equal(t, "int & some-other & >=1", got)
+}

internal/schema/hint_coverage_test.go

@@ -0,0 +1,200 @@
+package schema
+
+import (
+	"math"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// TestRenderHint_NonStringActualDisjunction exercises the
+// `actual` non-string branch in hintForStringDisjunction: a
+// numeric actual against a string-disjunction constraint
+// produces no hint (the disjunction path only fires for
+// string actuals).
+func TestRenderHint_NonStringActualDisjunction(t *testing.T) {
+	expr := `"a" | "b"`
+	assert.Empty(t, RenderHint(expr, 42))
+	assert.Empty(t, RenderHint(expr, float64(3.14)))
+}
+
+// TestRenderHint_SinglePartDisjunction covers the "not a
+// disjunction" early return (len(parts) < 2): a bare `"x"`
+// constraint cannot produce a "did you mean" hint.
+func TestRenderHint_SinglePartDisjunction(t *testing.T) {
+	assert.Empty(t, RenderHint(`"x"`, "y"))
+}
+
+// TestRenderHint_NonQuotedAlternative covers the
+// isQuotedString=false branch: when one of the disjunction
+// alternatives isn't a string literal (e.g. `int | "x"`), the
+// extractor backs off rather than misreporting.
+func TestRenderHint_NonQuotedAlternative(t *testing.T) {
+	assert.Empty(t, RenderHint(`int | "x"`, "y"))
+}
+
+// TestRenderHint_UnquoteFailure covers the strconv.Unquote
+// 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"))
+}
+
+// TestRenderHint_ExactMatchSkipped covers the d==0 branch:
+// the actual exactly equals one of the literals, so no hint
+// fires (a "did you mean X?" message when X equals the actual
+// would be confusing).
+func TestRenderHint_ExactMatchSkipped(t *testing.T) {
+	// The CUE constraint validator never calls RenderHint on
+	// a value that satisfies the constraint, but the
+	// disjunction extractor still guards against the case
+	// defensively. Pass an exact match to exercise the
+	// guard.
+	assert.Empty(t, RenderHint(`"foo" | "bar"`, "foo"))
+}
+
+// TestRenderHint_IntRangeNonNumericActual exercises the
+// toFloat64=false branch: a string actual against an int
+// range produces no hint.
+func TestRenderHint_IntRangeNonNumericActual(t *testing.T) {
+	assert.Empty(t, RenderHint("int & >=1 & <=5", "not-a-number"))
+}
+
+// TestRenderHint_IntRangeWithIntActual exercises the int /
+// int64 paths of toFloat64 that the float64 default missed.
+func TestRenderHint_IntRangeWithIntActual(t *testing.T) {
+	assert.Equal(t, "try 1", RenderHint("int & >=1 & <=5", int(0)))
+	assert.Equal(t, "try 5", RenderHint("int & >=1 & <=5", int64(6)))
+}
+
+// TestRenderHint_IntRangeNoBoundCrossed covers the no-hint
+// branch when neither bound is exceeded but the actual is
+// still in range (in-range actuals already exit before hint
+// rendering, but the guard inside hintForIntRange covers
+// boundary-equal cases).
+func TestRenderHint_IntRangeNoBoundCrossed(t *testing.T) {
+	// Value equal to a bound — within range, no hint.
+	assert.Empty(t, RenderHint("int & >=1 & <=5", float64(1)))
+	assert.Empty(t, RenderHint("int & >=1 & <=5", float64(5)))
+}
+
+// TestParseRenderedBounds_Edges exercises the error branches
+// in parseRenderedBounds. These fire when the rendered string
+// is malformed; in practice renderIntRange produces a
+// well-formed string, so hintForIntRange short-circuits on
+// the renderIntRange ok=false path. Direct calls cover the
+// defensive branches for future callers.
+func TestParseRenderedBounds_Edges(t *testing.T) {
+	t.Run("malformed between drops the and separator", func(t *testing.T) {
+		_, _, hasLo, hasHi := parseRenderedBounds("int between 1 5")
+		assert.False(t, hasLo)
+		assert.False(t, hasHi)
+	})
+
+	t.Run("non-integer lower bound", func(t *testing.T) {
+		_, _, hasLo, _ := parseRenderedBounds("int between abc and 5")
+		assert.False(t, hasLo)
+	})
+
+	t.Run("non-integer upper bound", func(t *testing.T) {
+		_, _, _, hasHi := parseRenderedBounds("int between 1 and zzz")
+		assert.False(t, hasHi)
+	})
+
+	t.Run("non-integer half-open lower", func(t *testing.T) {
+		_, _, hasLo, _ := parseRenderedBounds("int >= xyz")
+		assert.False(t, hasLo)
+	})
+
+	t.Run("non-integer half-open upper", func(t *testing.T) {
+		_, _, _, hasHi := parseRenderedBounds("int <= xyz")
+		assert.False(t, hasHi)
+	})
+
+	t.Run("unknown rendered form", func(t *testing.T) {
+		_, _, hasLo, hasHi := parseRenderedBounds("string")
+		assert.False(t, hasLo)
+		assert.False(t, hasHi)
+	})
+}
+
+// TestLevenshtein_InlineGuardKicksIn exercises the
+// CodeQL-visible inline guard path inside levenshtein() that
+// the over-cap helper would normally short-circuit before.
+// The test calls levenshtein directly with strings sized at
+// the cap to confirm the inner branch path is reached.
+func TestLevenshtein_InlineGuardKicksIn(t *testing.T) {
+	// Inputs at maxLevInput rune count stay inside the DP
+	// branch; smaller of the two governs the row size.
+	short := strings.Repeat("a", maxLevInput)
+	tiny := "abc"
+	// short ↔ tiny: 1024 - 3 = 1021 deletions, 0 substitutions
+	// from the 3-char overlap, so distance ~ 1021.
+	got := levenshtein(short, tiny)
+	assert.Greater(t, got, 1000)
+}
+
+// TestLevenshtein_OneEmpty exercises the early-return branches
+// for empty operands that the typo tests don't hit.
+func TestLevenshtein_OneEmpty(t *testing.T) {
+	assert.Equal(t, 4, levenshtein("", "abcd"))
+	assert.Equal(t, 4, levenshtein("abcd", ""))
+}
+
+// TestLevenshtein_BothOverCapReturnsLonger exercises both
+// branches of the over-cap fallback: when b is longer than a,
+// the helper returns len(b)'s capped count; when a is
+// longer, it returns len(a). The first call below covers
+// the `return cb` branch the typo tests miss.
+func TestLevenshtein_BothOverCapReturnsLonger(t *testing.T) {
+	short := strings.Repeat("a", maxLevInput+5)
+	longer := strings.Repeat("a", maxLevInput+50)
+	// b longer → returns cb (= maxLevInput+1).
+	got := levenshtein(short, longer)
+	assert.Equal(t, maxLevInput+1, got)
+	// a longer → returns ca.
+	got = levenshtein(longer, short)
+	assert.Equal(t, maxLevInput+1, got)
+}
+
+// TestRuneCountAtMost_Cap exercises the early-exit branch of
+// runeCountAtMost: a string longer than the cap returns
+// exactly the cap, not the true rune count.
+func TestRuneCountAtMost_Cap(t *testing.T) {
+	s := strings.Repeat("a", maxLevInput+10)
+	got := runeCountAtMost(s, maxLevInput)
+	assert.Equal(t, maxLevInput, got)
+}
+
+// TestTooLongForLevInput_Bound exercises the boundary branch:
+// exactly maxLevInput runes is not "too long", maxLevInput+1
+// is.
+func TestTooLongForLevInput_Bound(t *testing.T) {
+	exact := strings.Repeat("a", maxLevInput)
+	tooLong := strings.Repeat("a", maxLevInput+1)
+	assert.False(t, tooLongForLevInput(exact))
+	assert.True(t, tooLongForLevInput(tooLong))
+}
+
+// TestRenderHint_IntRangeOverflowFalsePositive guards the
+// hint extractor against suggesting the rendered exclusive
+// form's bound (`int > MaxInt`) for an in-range value. With
+// the inclusive shift skipped, parseRenderedBounds doesn't
+// match the rendered form, so hintForIntRange returns no
+// hint.
+func TestRenderHint_IntRangeOverflowFalsePositive(t *testing.T) {
+	maxStr := math.MaxInt
+	assert.Empty(t, RenderHint("int & >"+itoa(maxStr), float64(0)))
+}
+
+// itoa is a tiny wrapper so the test reads naturally without
+// importing strconv at the call site.
+func itoa(n int) string {
+	if n == math.MaxInt {
+		return "9223372036854775807"
+	}
+	return ""
+}