address coverage gaps and regressions introduced by fixes.

Author: daveshanley

datamodel/low/extraction_functions.go

@@ -1255,6 +1255,10 @@ func hashYamlNodeFast(n *yaml.Node) string {
 
 // hashNodeTree walks the YAML tree and hashes it without marshaling
 func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
+	hashNodeTreeWithNumericNormalization(h, n, visited, true)
+}
+
+func hashNodeTreeWithNumericNormalization(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool, normalizeNumericScalars bool) {
 	if n == nil {
 		return
 	}
@@ -1268,7 +1272,7 @@ func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
 
 	// Hash node metadata. Numeric scalars are normalized so semantically equivalent
 	// values like `1e-08` and `1e-8` compare equal.
-	tag, value := comparableScalarTagAndValue(n)
+	tag, value := scalarTagAndValueForHash(n, normalizeNumericScalars)
 	h.Write([]byte{byte(n.Kind)})
 	h.Write([]byte(tag))
 	h.Write([]byte(value))
@@ -1290,7 +1294,7 @@ func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
 	case yaml.SequenceNode:
 		h.Write([]byte("["))
 		for _, child := range content {
-			hashNodeTree(h, child, visited)
+			hashNodeTreeWithNumericNormalization(h, child, visited, normalizeNumericScalars)
 			h.Write([]byte(","))
 		}
 		h.Write([]byte("]"))
@@ -1317,7 +1321,9 @@ func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
 			if i+1 < len(content) {
 				keyH := hasherPool.Get().(*maphash.Hash)
 				keyH.Reset()
-				hashNodeTree(keyH, content[i], visited)
+				keyVisited := getVisitedMap()
+				hashNodeTreeWithNumericNormalization(keyH, content[i], keyVisited, false)
+				putVisitedMap(keyVisited)
 				pairs = append(pairs, kvPair{
 					keyHash:   keyH.Sum64(),
 					keyNode:   content[i],
@@ -1334,36 +1340,43 @@ func hashNodeTree(h *maphash.Hash, n *yaml.Node, visited map[*yaml.Node]bool) {
 
 		// Hash in sorted order
 		for _, pair := range pairs {
-			hashNodeTree(h, pair.keyNode, visited)
+			hashNodeTreeWithNumericNormalization(h, pair.keyNode, visited, false)
 			h.Write([]byte(":"))
-			hashNodeTree(h, pair.valueNode, visited)
+			hashNodeTreeWithNumericNormalization(h, pair.valueNode, visited, true)
 			h.Write([]byte(","))
 		}
 		h.Write([]byte("}"))
 
 	case yaml.DocumentNode:
 		h.Write([]byte("DOC["))
 		for _, child := range content {
-			hashNodeTree(h, child, visited)
+			hashNodeTreeWithNumericNormalization(h, child, visited, normalizeNumericScalars)
 		}
 		h.Write([]byte("]"))
 
 	case yaml.AliasNode:
 		h.Write([]byte("ALIAS["))
 		if n.Alias != nil {
-			hashNodeTree(h, n.Alias, visited)
+			hashNodeTreeWithNumericNormalization(h, n.Alias, visited, normalizeNumericScalars)
 		}
 		h.Write([]byte("]"))
 	}
 }
 
 func comparableScalarTagAndValue(n *yaml.Node) (string, string) {
+	return scalarTagAndValueForHash(n, true)
+}
+
+func scalarTagAndValueForHash(n *yaml.Node, normalizeNumericScalars bool) (string, string) {
 	if n == nil {
 		return "", ""
 	}
 	if n.Kind != yaml.ScalarNode {
 		return n.Tag, n.Value
 	}
+	if !normalizeNumericScalars {
+		return n.Tag, n.Value
+	}
 	if n.Tag != "!!int" && n.Tag != "!!float" {
 		return n.Tag, n.Value
 	}

datamodel/low/extraction_functions_test.go

@@ -2973,6 +2973,32 @@ func TestCompareYAMLNodes_ComplexNodesNumericEquivalence(t *testing.T) {
 	assert.True(t, CompareYAMLNodes(left, right))
 }
 
+func TestScalarTagAndValueForHash_DisablesNumericNormalization(t *testing.T) {
+	node := &yaml.Node{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1.0"}
+	tag, value := scalarTagAndValueForHash(node, false)
+	assert.Equal(t, "!!float", tag)
+	assert.Equal(t, "1.0", value)
+}
+
+func TestCompareYAMLNodes_NumericMapKeysAreNotEquivalent(t *testing.T) {
+	left := &yaml.Node{
+		Kind: yaml.MappingNode,
+		Content: []*yaml.Node{
+			{Kind: yaml.ScalarNode, Tag: "!!int", Value: "1"},
+			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "coffee"},
+		},
+	}
+	right := &yaml.Node{
+		Kind: yaml.MappingNode,
+		Content: []*yaml.Node{
+			{Kind: yaml.ScalarNode, Tag: "!!float", Value: "1.0"},
+			{Kind: yaml.ScalarNode, Tag: "!!str", Value: "coffee"},
+		},
+	}
+
+	assert.False(t, CompareYAMLNodes(left, right))
+}
+
 func TestGenerateHashString_SchemaProxyNoCache(t *testing.T) {
 	// Test that SchemaProxy types don't get cached (shouldCache = false)
 	// We can't easily test this without creating actual SchemaProxy objects

what-changed/model/comparison_functions.go

@@ -25,6 +25,10 @@ const (
 
 var changeMutex sync.Mutex
 
+type changeCollection interface {
+	GetAllChanges() []*Change
+}
+
 // SetReferenceIfExists checks if a low-level value has a reference and sets it on the change object
 // if the change object implements the ChangeIsReferenced interface.
 func SetReferenceIfExists[T any](value *low.ValueReference[T], changeObj any) {
@@ -45,6 +49,56 @@ func PreserveParameterReference[T any](lRefs, rRefs map[string]*low.ValueReferen
 	}
 }
 
+func overrideChangeCollectionBreaking(changeObj any, breaking bool) {
+	if changeObj == nil {
+		return
+	}
+	collection, ok := changeObj.(changeCollection)
+	if !ok {
+		return
+	}
+	for _, change := range collection.GetAllChanges() {
+		if change != nil {
+			change.Breaking = breaking
+		}
+	}
+}
+
+func compareExamplesWithParentBreaking(component, property string) func(l, r *base.Example) *ExampleChanges {
+	return func(l, r *base.Example) *ExampleChanges {
+		changes := CompareExamples(l, r)
+		if changes == nil {
+			return nil
+		}
+
+		switch {
+		case l == nil:
+			overrideChangeCollectionBreaking(changes, BreakingAdded(component, property))
+		case r == nil:
+			overrideChangeCollectionBreaking(changes, BreakingRemoved(component, property))
+		default:
+			overrideChangeCollectionBreaking(changes, BreakingModified(component, property))
+		}
+		return changes
+	}
+}
+
+func CheckExampleMapForChangesWithRules(
+	expLeft, expRight *orderedmap.Map[low.KeyReference[string], low.ValueReference[*base.Example]],
+	changes *[]*Change, label string, component, property string,
+) map[string]*ExampleChanges {
+	return CheckMapForChangesWithRules(expLeft, expRight, changes, label,
+		compareExamplesWithParentBreaking(component, property), component, property)
+}
+
+func CheckExampleMapForChangesWithNilSupportAndRules(
+	expLeft, expRight *orderedmap.Map[low.KeyReference[string], low.ValueReference[*base.Example]],
+	changes *[]*Change, label string, component, property string,
+) map[string]*ExampleChanges {
+	return CheckMapForChangesWithNilSupportAndRules(expLeft, expRight, changes, label,
+		compareExamplesWithParentBreaking(component, property), component, property)
+}
+
 func checkLocation(ctx *ChangeContext, hs base.HasIndex) bool {
 	if !reflect.ValueOf(hs).IsNil() {
 		idx := hs.GetIndex()

what-changed/model/comparison_functions_test.go

@@ -4,10 +4,12 @@
 package model
 
 import (
+	"context"
 	"github.com/pb33f/libopenapi/index"
 	"testing"
 
 	"github.com/pb33f/libopenapi/datamodel/low"
+	"github.com/pb33f/libopenapi/datamodel/low/base"
 	"github.com/pb33f/libopenapi/orderedmap"
 	"github.com/pb33f/libopenapi/utils"
 	"github.com/stretchr/testify/assert"
@@ -237,6 +239,78 @@ func TestCheckMapForAdditionRemoval(t *testing.T) {
 	assert.Len(t, changes, 1)
 }
 
+func buildTestExample(t *testing.T, raw string) *base.Example {
+	t.Helper()
+
+	var node yaml.Node
+	assert.NoError(t, yaml.Unmarshal([]byte(raw), &node))
+
+	var example base.Example
+	assert.NoError(t, low.BuildModel(node.Content[0], &example))
+	assert.NoError(t, example.Build(context.Background(), nil, node.Content[0], nil))
+	return &example
+}
+
+func TestOverrideChangeCollectionBreaking(t *testing.T) {
+	overrideChangeCollectionBreaking(nil, true)
+	overrideChangeCollectionBreaking("not-a-collection", true)
+
+	changes := &ExampleChanges{
+		PropertyChanges: NewPropertyChanges([]*Change{
+			{Breaking: true},
+			{Breaking: false},
+		}),
+	}
+
+	overrideChangeCollectionBreaking(changes, false)
+	assert.False(t, changes.Changes[0].Breaking)
+	assert.False(t, changes.Changes[1].Breaking)
+
+	overrideChangeCollectionBreaking(changes, true)
+	assert.True(t, changes.Changes[0].Breaking)
+	assert.True(t, changes.Changes[1].Breaking)
+}
+
+func TestCompareExamplesWithParentBreaking(t *testing.T) {
+	ResetDefaultBreakingRules()
+	ResetActiveBreakingRulesConfig()
+	defer ResetDefaultBreakingRules()
+	defer ResetActiveBreakingRulesConfig()
+
+	config := GenerateDefaultBreakingRules()
+	config.Example.Value = rule(false, true, false)
+	config.Parameter.Examples = rule(false, false, false)
+	config.MediaType.Examples = rule(true, false, true)
+	SetActiveBreakingRulesConfig(config)
+
+	modified := compareExamplesWithParentBreaking(CompParameter, PropExamples)(
+		buildTestExample(t, "value: left"),
+		buildTestExample(t, "value: right"),
+	)
+	assert.NotNil(t, modified)
+	assert.False(t, modified.GetAllChanges()[0].Breaking)
+
+	added := compareExamplesWithParentBreaking(CompMediaType, PropExamples)(
+		nil,
+		buildTestExample(t, "value: right"),
+	)
+	assert.NotNil(t, added)
+	assert.True(t, added.GetAllChanges()[0].Breaking)
+
+	removed := compareExamplesWithParentBreaking(CompMediaType, PropExamples)(
+		buildTestExample(t, "value: left"),
+		nil,
+	)
+	assert.NotNil(t, removed)
+	assert.True(t, removed.GetAllChanges()[0].Breaking)
+
+	unchanged := compareExamplesWithParentBreaking(CompParameter, PropExamples)(
+		buildTestExample(t, "value: same"),
+		buildTestExample(t, "value: same"),
+	)
+	assert.Nil(t, unchanged)
+}
+
 type test_hasIndex struct {
 	index *index.SpecIndex
 }

what-changed/model/header.go

@@ -76,6 +76,9 @@ func (h *HeaderChanges) TotalChanges() int {
 // TotalBreakingChanges returns the total number of breaking changes made between two Header instances.
 func (h *HeaderChanges) TotalBreakingChanges() int {
 	c := h.PropertyChanges.TotalBreakingChanges()
+	for k := range h.ExamplesChanges {
+		c += h.ExamplesChanges[k].TotalBreakingChanges()
+	}
 	for k := range h.ContentChanges {
 		c += h.ContentChanges[k].TotalBreakingChanges()
 	}
@@ -282,8 +285,8 @@ func CompareHeaders(l, r any) *HeaderChanges {
 		}
 
 		// examples
-		hc.ExamplesChanges = CheckMapForChangesWithRules(lHeader.Examples.Value, rHeader.Examples.Value,
-			&changes, v3.ExamplesLabel, CompareExamples, CompHeader, PropExamples)
+		hc.ExamplesChanges = CheckExampleMapForChangesWithRules(lHeader.Examples.Value, rHeader.Examples.Value,
+			&changes, v3.ExamplesLabel, CompHeader, PropExamples)
 
 		// content
 		hc.ContentChanges = CheckMapForChanges(lHeader.Content.Value, rHeader.Content.Value,

what-changed/model/header_test.go

@@ -346,3 +346,39 @@ func TestCompareHeaders_v3_ExamplesRemoved(t *testing.T) {
 	assert.Equal(t, 0, extChanges.TotalBreakingChanges())
 	assert.Equal(t, ObjectRemoved, extChanges.Changes[0].ChangeType)
 }
+
+func TestCompareHeaders_v3_ExamplesModified_WithCustomBreakingRule(t *testing.T) {
+	ResetDefaultBreakingRules()
+	ResetActiveBreakingRulesConfig()
+	defer ResetDefaultBreakingRules()
+	defer ResetActiveBreakingRulesConfig()
+
+	config := GenerateDefaultBreakingRules()
+	config.Header.Examples = rule(false, true, false)
+	SetActiveBreakingRulesConfig(config)
+
+	low.ClearHashCache()
+	left := `examples:
+  something:
+    value: left header`
+	right := `examples:
+  something:
+    value: right header`
+
+	var lNode, rNode yaml.Node
+	_ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
+
+	var lDoc v3.Header
+	var rDoc v3.Header
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = lDoc.Build(context.Background(), nil, lNode.Content[0], nil)
+	_ = rDoc.Build(context.Background(), nil, rNode.Content[0], nil)
+
+	extChanges := CompareHeadersV3(&lDoc, &rDoc)
+	assert.Equal(t, 1, extChanges.TotalChanges())
+	assert.Equal(t, 1, extChanges.TotalBreakingChanges())
+	assert.Len(t, extChanges.ExamplesChanges, 1)
+	assert.True(t, extChanges.ExamplesChanges["something"].GetAllChanges()[0].Breaking)
+}

what-changed/model/media_type.go

@@ -140,8 +140,8 @@ func CompareMediaTypes(l, r *v3.MediaType) *MediaTypeChanges {
 	}
 
 	// examples - use nil-aware version so added/removed examples appear in the map for tree rendering
-	mc.ExampleChanges = CheckMapForChangesWithNilSupportAndRules(l.Examples.Value, r.Examples.Value,
-		&changes, v3.ExamplesLabel, CompareExamples, CompMediaType, PropExamples)
+	mc.ExampleChanges = CheckExampleMapForChangesWithNilSupportAndRules(l.Examples.Value, r.Examples.Value,
+		&changes, v3.ExamplesLabel, CompMediaType, PropExamples)
 
 	// encoding
 	mc.EncodingChanges = CheckMapForChanges(l.Encoding.Value, r.Encoding.Value,