test: address Copilot review comments on PR #172

- query: assert m.Match result instead of discarding it
- fix: assert atomicWriteFile returns error; check temp-file prefix not length
- ruledocs: use deterministic errFS type so ReadDir error tests are reliable
- config: assert yaml.Unmarshal returns expected "bool or mapping" error
- crossfilereferenceintegrity: rename misleading TestParseTarget_OpaqueURL test
- tablereadability: remove dead _ = math.MaxFloat64 line
- headingstyle: convert fmt.Printf exploratory tests to real assertions

https://claude.ai/code/session_01DvP5H17ofGpHmR7DhSU438

Author: claude

internal/config/config_test.go

@@ -1577,10 +1577,8 @@ func TestUnmarshalYAML_NonScalarNonMappingValue(t *testing.T) {
 	input := "rules:\n  line-length:\n    - item1\n    - item2\n"
 	var cfg Config
 	err := yaml.Unmarshal([]byte(input), &cfg)
-	// The error may occur during YAML unmarshalling.
-	// If the custom UnmarshalYAML triggers the "not bool or mapping" path, we get an error.
-	// Just check we don't panic.
-	_ = err
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "rule config must be a bool or a mapping")
 }
 
 // TestTopLevelKeySet_DocumentNodeEmpty exercises the

internal/fix/fix_coverage_test.go

@@ -5,6 +5,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strings"
 	"testing"
 
 	"github.com/jeduden/mdsmith/internal/config"
@@ -437,13 +438,14 @@ func TestAtomicWriteFile_TmpFileCleanedUpOnRenameFailure(t *testing.T) {
 	targetDir := filepath.Join(dir, "target")
 	require.NoError(t, os.Mkdir(targetDir, 0o755))
 
-	_ = atomicWriteFile(targetDir, []byte("data"), 0o644)
+	err := atomicWriteFile(targetDir, []byte("data"), 0o644)
+	require.Error(t, err)
 
 	// Verify no orphaned temp files remain in the directory after the failure.
 	entries, err := os.ReadDir(dir)
 	require.NoError(t, err)
 	for _, e := range entries {
-		assert.False(t, len(e.Name()) > len(".mdsmith-fix-"),
+		assert.False(t, strings.HasPrefix(e.Name(), ".mdsmith-fix-"),
 			"unexpected leftover temp file: %s", e.Name())
 	}
 }

internal/query/query_test.go

@@ -120,10 +120,11 @@ func TestCollectPaths_NonStructCUE(t *testing.T) {
 	// collectPaths should return nil and Match should use unification only.
 	m, err := Compile(`>=1 & <=10`)
 	require.NoError(t, err)
-	// A non-struct schema: no paths to verify. Unification with a plain
-	// JSON number value would succeed, but the front matter is a map.
-	// The exact result depends on CUE unification semantics.
-	_ = m.Match(map[string]any{"value": 5})
+	// A non-struct schema has no paths to verify. Match therefore falls back
+	// to unification only, and a map-shaped front matter value cannot unify
+	// with a top-level numeric constraint.
+	result := m.Match(map[string]any{"value": 5})
+	assert.False(t, result, "non-struct CUE schema should not match a map value")
 }
 
 // TestMatch_JSONMarshalError exercises the json.Marshal err != nil branch in Match.

internal/rules/crossfilereferenceintegrity/rule_morecoverage_test.go

@@ -197,16 +197,7 @@ func TestCheck_InvalidExcludeGlobReturnsConfigDiag(t *testing.T) {
 
 // --- parseTarget: path == "" && u.Opaque != "" ---
 // An opaque URI like "mailto:user@example.com" has Opaque set.
-// But url.Parse of "mailto:user@example.com" sets Scheme="mailto", so it
-// returns false before reaching the opaque branch.
-// To reach opaque: need Scheme=="" and Opaque!="". This is an unusual URL
-// like "C:path" on Windows (opaque path). We construct it directly.
-func TestParseTarget_OpaqueURL(t *testing.T) {
-	// url.Parse("C:relative") → {Opaque: "relative", Scheme: "C"} — has Scheme, returns false.
-	// It's very hard to get Scheme="" and Opaque!="" via url.Parse in practice.
-	// The only case is if url.Parse fails to identify a scheme but sets Opaque.
-	// Actually this branch may be dead code; skip it and test something else.
-	// Instead test a path with just a fragment but no hash prefix.
+func TestParseTarget_PlainRelativePath(t *testing.T) {
 	target, ok := parseTarget("guide.md")
 	require.True(t, ok)
 	require.Equal(t, "guide.md", target.Path)

internal/rules/headingstyle/explore3_test.go

@@ -1,53 +1,51 @@
 package headingstyle
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/jeduden/mdsmith/internal/lint"
 	"github.com/yuin/goldmark/ast"
 	"github.com/yuin/goldmark/text"
 )
 
-func TestExploreHeadingWithManualChildren(t *testing.T) {
-	// Try to craft a heading with Lines().Len() == 0 but with text children
-	// by creating one manually and calling headingLine
-
+func TestHeadingLine_ManualATXWithTextChild(t *testing.T) {
+	// A manually constructed ATX heading with Lines().Len()==0 and a Text child;
+	// headingLine should fall back to the child segment offset (line 1).
 	src := []byte("# Title\n")
 	f, err := lint.NewFile("test.md", src)
 	if err != nil {
 		t.Fatal(err)
 	}
-	_ = f
 
-	// Create a heading with no lines but manually attach a text child
 	h := ast.NewHeading(1)
 	textNode := ast.NewText()
 	textNode.Segment = text.NewSegment(2, 7) // "Title" in "# Title\n"
 	h.AppendChild(h, textNode)
 
-	fmt.Printf("Manual heading: Lines=%d, FirstChild=%T\n", h.Lines().Len(), h.FirstChild())
 	line := headingLine(h, f)
-	fmt.Printf("headingLine returned: %d\n", line)
+	if line < 1 {
+		t.Errorf("expected headingLine >= 1, got %d", line)
+	}
 }
 
-func TestExploreHeadingWithNonTextChild(t *testing.T) {
-	// Heading with Lines=0 and first child is Emphasis (not Text), wrapping Text
+func TestHeadingLine_ManualATXWithEmphasisChild(t *testing.T) {
+	// Heading with Lines==0 and first child is Emphasis wrapping Text;
+	// headingLine should still return a valid line number (>= 1).
 	src := []byte("# **bold**\n")
 	f, err := lint.NewFile("test.md", src)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	// Create heading manually
 	h := ast.NewHeading(1)
 	em := ast.NewEmphasis(2)
 	textNode := ast.NewText()
-	textNode.Segment = text.NewSegment(3, 7) // "bold" in "# **bold**\n" -- rough
+	textNode.Segment = text.NewSegment(3, 7)
 	em.AppendChild(em, textNode)
 	h.AppendChild(h, em)
 
-	fmt.Printf("Manual heading with emphasis: Lines=%d\n", h.Lines().Len())
 	line := headingLine(h, f)
-	fmt.Printf("headingLine returned: %d (expected 1 for offset 3)\n", line)
+	if line < 1 {
+		t.Errorf("expected headingLine >= 1, got %d", line)
+	}
 }

internal/rules/ruledocs_test.go

@@ -1,6 +1,7 @@
 package rules
 
 import (
+	"fmt"
 	"io/fs"
 	"testing"
 	"testing/fstest"
@@ -9,6 +10,11 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+// errFS is an fs.FS that always returns an error on Open, forcing ReadDir to fail.
+type errFS struct{}
+
+func (errFS) Open(string) (fs.File, error) { return nil, fmt.Errorf("forced readdir error") }
+
 func TestListRules_SortedByID(t *testing.T) {
 	rules, err := ListRules()
 	require.NoError(t, err, "ListRules: %v", err)
@@ -150,20 +156,8 @@ func TestListRulesFromFS_SkipsMissingStatus(t *testing.T) {
 
 // listRulesFromFS: ReadDir error
 func TestListRulesFromFS_ReadDirError(t *testing.T) {
-	// An empty fstest.MapFS with a sub-path causes ReadDir(".")
-	// to succeed, but we can use a sub-FS that errors on ReadDir.
-	// The simplest way: use an fs.Sub on a non-existent subdirectory.
-	fsys := fstest.MapFS{
-		"readme.txt": &fstest.MapFile{Data: []byte("not a dir")},
-	}
-	// fs.Sub on a file path causes ReadDir to fail.
-	sub, err := fs.Sub(fsys, "readme.txt")
-	if err == nil {
-		_, err = listRulesFromFS(sub)
-		// Whether it errors or not depends on the FS implementation;
-		// the key is we exercise the ReadDir error path.
-		_ = err
-	}
+	_, err := listRulesFromFS(errFS{})
+	require.Error(t, err)
 }
 
 // listRulesFromFS: non-directory entry → continue
@@ -202,17 +196,8 @@ func TestListRulesFromFS_SkipsEmptyDir(t *testing.T) {
 
 // lookupRuleFromFS: listRulesFromFS error propagation
 func TestLookupRuleFromFS_PropagatesReadDirError(t *testing.T) {
-	// Use an FS that returns an error on ReadDir.
-	fsys := fstest.MapFS{
-		"readme.txt": &fstest.MapFile{Data: []byte("file")},
-	}
-	sub, err := fs.Sub(fsys, "readme.txt")
-	if err == nil {
-		_, err = lookupRuleFromFS(sub, "anything")
-		// Error may or may not occur depending on implementation;
-		// this exercises the lookupRuleFromFS error propagation path.
-		_ = err
-	}
+	_, err := lookupRuleFromFS(errFS{}, "anything")
+	require.Error(t, err)
 }
 
 // parseFrontMatter: missing ID → error

internal/rules/tablereadability/rule_coverage_test.go

@@ -322,7 +322,6 @@ func TestColumnWidthRatio_OneEmptyOneNonEmpty(t *testing.T) {
 	}
 	ratio := tbl.columnWidthRatio()
 	assert.True(t, math.IsInf(ratio, 1), "expected +Inf when min column avg is 0")
-	_ = math.MaxFloat64 // suppress unused import warning
 }
 
 // columnWidthRatio: only separator rows → columns==0 → return 0