cleaning up code, fixing test coverage.

Author: daveshanley

strict/matcher.go

@@ -35,10 +35,6 @@ func (v *Validator) dataMatchesSchema(schema *base.Schema, data any) (bool, erro
 	if err != nil {
 		return false, err
 	}
-	if compiled == nil {
-		return false, nil
-	}
-
 	return compiled.Validate(data) == nil, nil
 }
 

strict/property_collector.go

@@ -59,11 +59,7 @@ func (v *Validator) collectDeclaredProperties(
 				continue
 			}
 			// trigger property exists, include dependent schema's properties
-			depProxy := pair.Value()
-			if depProxy == nil {
-				continue
-			}
-			mergePropertiesIntoDeclared(declared, depProxy.Schema())
+			mergePropertiesIntoDeclared(declared, pair.Value().Schema())
 		}
 	}
 

strict/utils.go

@@ -126,10 +126,7 @@ func compilePattern(pattern string) *regexp.Regexp {
 
 	b.WriteString("$")
 
-	re, err := regexp.Compile(b.String())
-	if err != nil {
-		return nil
-	}
+	re, _ := regexp.Compile(b.String())
 	return re
 }
 

strict/utils_test.go

@@ -0,0 +1,134 @@
+// Copyright 2023-2025 Princess Beef Heavy Industries, LLC / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package strict
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestCompilePattern_EscapedDoubleAsterisk(t *testing.T) {
+	// Pattern \*\* should match literal "**" in path (lines 78-80)
+	// This escapes the glob ** so it matches the literal string **
+	re := compilePattern(`$.body.\*\*`)
+	assert.NotNil(t, re)
+
+	// Should match literal ** in path
+	assert.True(t, re.MatchString("$.body.**"))
+
+	// Should NOT match arbitrary depth (that's what unescaped ** does)
+	assert.False(t, re.MatchString("$.body.foo.bar"))
+}
+
+func TestCompilePattern_EscapedNonAsterisk(t *testing.T) {
+	// Pattern with escaped character that's not * (lines 88-90)
+	// \n should match literal 'n', \. should match literal '.'
+	re := compilePattern(`$.body\nvalue`)
+	assert.NotNil(t, re)
+
+	// Should match with literal 'n' (the escape just includes the next char)
+	assert.True(t, re.MatchString("$.bodynvalue"))
+}
+
+func TestCompilePattern_EscapedDot(t *testing.T) {
+	// Escaped dot should be literal dot
+	re := compilePattern(`$.body\.name`)
+	assert.NotNil(t, re)
+
+	// Should match path with literal dot
+	assert.True(t, re.MatchString("$.body.name"))
+}
+
+func TestCompilePattern_Empty(t *testing.T) {
+	// Empty pattern returns nil
+	re := compilePattern("")
+	assert.Nil(t, re)
+}
+
+func TestBuildPath_WithDot(t *testing.T) {
+	// Property with dot uses bracket notation
+	result := buildPath("$.body", "a.b")
+	assert.Equal(t, "$.body['a.b']", result)
+}
+
+func TestBuildPath_WithBrackets(t *testing.T) {
+	// Property with brackets uses bracket notation
+	result := buildPath("$.body", "x[0]")
+	assert.Equal(t, "$.body['x[0]']", result)
+}
+
+func TestBuildPath_Simple(t *testing.T) {
+	// Simple property uses dot notation
+	result := buildPath("$.body", "name")
+	assert.Equal(t, "$.body.name", result)
+}
+
+func TestBuildArrayPath(t *testing.T) {
+	result := buildArrayPath("$.body.items", 5)
+	assert.Equal(t, "$.body.items[5]", result)
+}
+
+func TestCompileIgnorePaths_Empty(t *testing.T) {
+	result := compileIgnorePaths(nil)
+	assert.Nil(t, result)
+
+	result = compileIgnorePaths([]string{})
+	assert.Nil(t, result)
+}
+
+func TestCompileIgnorePaths_WithPatterns(t *testing.T) {
+	patterns := []string{
+		"$.body.metadata",
+		"$.body.items[*].internal",
+	}
+	result := compileIgnorePaths(patterns)
+	assert.Len(t, result, 2)
+}
+
+func TestTruncateValue_LongString(t *testing.T) {
+	// String > 50 chars gets truncated
+	longStr := "this is a very long string that exceeds fifty characters in length"
+	result := TruncateValue(longStr)
+	assert.Equal(t, "this is a very long string that exceeds fifty c...", result)
+}
+
+func TestTruncateValue_ShortString(t *testing.T) {
+	shortStr := "short"
+	result := TruncateValue(shortStr)
+	assert.Equal(t, "short", result)
+}
+
+func TestTruncateValue_LargeMap(t *testing.T) {
+	// Map with > 3 keys shows {...}
+	m := map[string]any{"a": 1, "b": 2, "c": 3, "d": 4}
+	result := TruncateValue(m)
+	assert.Equal(t, "{...}", result)
+}
+
+func TestTruncateValue_SmallMap(t *testing.T) {
+	m := map[string]any{"a": 1, "b": 2}
+	result := TruncateValue(m)
+	assert.Equal(t, m, result)
+}
+
+func TestTruncateValue_LargeSlice(t *testing.T) {
+	// Slice with > 3 elements shows [...]
+	s := []any{1, 2, 3, 4}
+	result := TruncateValue(s)
+	assert.Equal(t, "[...]", result)
+}
+
+func TestTruncateValue_SmallSlice(t *testing.T) {
+	s := []any{1, 2}
+	result := TruncateValue(s)
+	assert.Equal(t, s, result)
+}
+
+func TestTruncateValue_OtherTypes(t *testing.T) {
+	// Other types returned as-is
+	assert.Equal(t, 42, TruncateValue(42))
+	assert.Equal(t, true, TruncateValue(true))
+	assert.Equal(t, 3.14, TruncateValue(3.14))
+}