Added callback object to what-changed

Cleaned up more covage in v3 model, we're almost there. My god what a mission this has been.

datamodel/low/v3/constants.go

@@ -9,6 +9,7 @@ const (
 	SchemasLabel              = "schemas"
 	EncodingLabel             = "encoding"
 	HeadersLabel              = "headers"
+	ExpressionLabel           = "expression"
 	ParametersLabel           = "parameters"
 	RequestBodyLabel          = "requestBody"
 	RequestBodiesLabel        = "requestBodies"

datamodel/low/v3/response_test.go

@@ -27,6 +27,7 @@ func TestResponses_Build(t *testing.T) {
     someLink:
       description: a link
   x-gut: rot    
+x-shoes: old
 default:
   description: default response`
 
@@ -59,6 +60,44 @@ default:
 	assert.NotNil(t, link.Value)
 	assert.Equal(t, "a link", link.Value.Description.Value)
 
+	// check hash
+	assert.Equal(t, "4ab807033ce9ca57ab551d8569cc11da8722c4ae75c003bc23b495ab756f468a",
+		low.GenerateHashString(&n))
+
+}
+
+func TestResponses_NoDefault(t *testing.T) {
+
+	yml := `"200":
+  description: some response
+  headers:
+    header1: 
+      description: some header
+  content: 
+    nice/rice:
+      schema:
+        type: string
+        description: this is some content.
+  links:
+    someLink:
+      description: a link
+  x-gut: rot    
+x-shoes: old`
+
+	var idxNode yaml.Node
+	_ = yaml.Unmarshal([]byte(yml), &idxNode)
+	idx := index.NewSpecIndex(&idxNode)
+
+	var n Responses
+	err := low.BuildModel(&idxNode, &n)
+	assert.NoError(t, err)
+
+	err = n.Build(idxNode.Content[0], idx)
+
+	// check hash
+	assert.Equal(t, "1b9161a7d31a9aa4580899f57092bcb6801b37045777bff28981bd2288c72b10",
+		low.GenerateHashString(&n))
+
 }
 
 func TestResponses_Build_FailCodes_WrongType(t *testing.T) {
@@ -234,3 +273,54 @@ links:
 	assert.Equal(t, n.Hash(), n2.Hash())
 
 }
+
+//
+//func TestResponses_Default(t *testing.T) {
+//
+//	yml := `"200":
+//  description: some response
+//  headers:
+//    header1:
+//      description: some header
+//  content:
+//    nice/rice:
+//      schema:
+//        type: string
+//        description: this is some content.
+//  links:
+//    someLink:
+//      description: a link
+//  x-gut: rot
+//default:
+//  description: default response`
+//
+//	var idxNode yaml.Node
+//	_ = yaml.Unmarshal([]byte(yml), &idxNode)
+//	idx := index.NewSpecIndex(&idxNode)
+//
+//	var n Responses
+//	err := low.BuildModel(&idxNode, &n)
+//	assert.NoError(t, err)
+//
+//	err = n.Build(idxNode.Content[0], idx)
+//	assert.NoError(t, err)
+//	assert.Equal(t, "default response", n.Default.Value.Description.Value)
+//
+//	ok := n.FindResponseByCode("200")
+//	assert.NotNil(t, ok.Value)
+//	assert.Equal(t, "some response", ok.Value.Description.Value)
+//	assert.Equal(t, "rot", ok.Value.FindExtension("x-gut").Value)
+//
+//	con := ok.Value.FindContent("nice/rice")
+//	assert.NotNil(t, con.Value)
+//	assert.Equal(t, "this is some content.", con.Value.Schema.Value.Schema().Description.Value)
+//
+//	head := ok.Value.FindHeader("header1")
+//	assert.NotNil(t, head.Value)
+//	assert.Equal(t, "some header", head.Value.Description.Value)
+//
+//	link := ok.Value.FindLink("someLink")
+//	assert.NotNil(t, link.Value)
+//	assert.Equal(t, "a link", link.Value.Description.Value)
+//
+//}

datamodel/low/v3/responses.go

@@ -67,13 +67,6 @@ func (r *Responses) Build(root *yaml.Node, idx *index.SpecIndex) error {
 
 func (r *Responses) getDefault() *low.NodeReference[*Response] {
 	for n, o := range r.Codes {
-		if n.Value == DefaultLabel {
-			return &low.NodeReference[*Response]{
-				ValueNode: o.ValueNode,
-				KeyNode:   n.KeyNode,
-				Value:     o.Value,
-			}
-		}
 		if strings.ToLower(n.Value) == DefaultLabel {
 			return &low.NodeReference[*Response]{
 				ValueNode: o.ValueNode,

datamodel/low/v3/security_scheme_test.go

@@ -57,6 +57,10 @@ x-milk: please`
 
 	err = n.Build(idxNode.Content[0], idx)
 	assert.NoError(t, err)
+
+	assert.Equal(t, "0b5ee36519fdfc6383c7befd92294d77b5799cd115911ff8c3e194f345a8c103",
+		low.GenerateHashString(&n))
+
 	assert.Equal(t, "tea", n.Type.Value)
 	assert.Equal(t, "cake", n.Description.Value)
 	assert.Equal(t, "biscuit", n.Name.Value)

datamodel/low/v3/server_test.go

@@ -31,11 +31,20 @@ variables:
 
 	err = n.Build(idxNode.Content[0], idx)
 	assert.NoError(t, err)
+
+	assert.Equal(t, "ec69dfcf68ad8988f3804e170ee6c4a7ad2e4ac51084796eea93168820827546",
+		low.GenerateHashString(&n))
+
 	assert.Equal(t, "https://pb33f.io", n.URL.Value)
 	assert.Equal(t, "high quality software for developers.", n.Description.Value)
 	assert.Equal(t, "hello", n.FindVariable("var1").Value.Default.Value)
 	assert.Equal(t, "a var", n.FindVariable("var1").Value.Description.Value)
 
+	// test var hash
+	s := n.FindVariable("var1")
+	assert.Equal(t, "00eef99ee4a7b746be7b4ccdece59c5a96222c6206f846fafed782c9f3f9b46b",
+		low.GenerateHashString(s.Value))
+
 }
 
 func TestServer_Build_NoVars(t *testing.T) {

datamodel/low/v3/server_variable.go

@@ -2,7 +2,9 @@ package v3
 
 import (
 	"crypto/sha256"
+	"fmt"
 	"github.com/pb33f/libopenapi/datamodel/low"
+	"sort"
 	"strings"
 )
 
@@ -22,9 +24,14 @@ type ServerVariable struct {
 // Hash will return a consistent SHA256 Hash of the ServerVariable object
 func (s *ServerVariable) Hash() [32]byte {
 	var f []string
+	keys := make([]string, len(s.Enum))
+	z := 0
 	for k := range s.Enum {
-		f = append(f, s.Enum[k].Value)
+		keys[z] = fmt.Sprint(s.Enum[k].Value)
+		z++
 	}
+	sort.Strings(keys)
+	f = append(f, keys...)
 	if !s.Default.IsEmpty() {
 		f = append(f, s.Default.Value)
 	}

what-changed/model/callback.go

@@ -0,0 +1,95 @@
+// Copyright 2022 Princess B33f Heavy Industries / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package model
+
+import (
+	"github.com/pb33f/libopenapi/datamodel/low"
+	"github.com/pb33f/libopenapi/datamodel/low/v3"
+)
+
+type CallbackChanges struct {
+	PropertyChanges
+	ExpressionChanges map[string]*PathItemChanges
+	ExtensionChanges  *ExtensionChanges
+}
+
+func (c *CallbackChanges) TotalChanges() int {
+	d := c.PropertyChanges.TotalChanges()
+	for k := range c.ExpressionChanges {
+		d += c.ExpressionChanges[k].TotalChanges()
+	}
+	if c.ExtensionChanges != nil {
+		d += c.ExtensionChanges.TotalChanges()
+	}
+	return d
+}
+
+func (c *CallbackChanges) TotalBreakingChanges() int {
+	d := c.PropertyChanges.TotalBreakingChanges()
+	for k := range c.ExpressionChanges {
+		d += c.ExpressionChanges[k].TotalBreakingChanges()
+	}
+	if c.ExtensionChanges != nil {
+		d += c.ExtensionChanges.TotalBreakingChanges()
+	}
+	return d
+}
+
+func CompareCallback(l, r *v3.Callback) *CallbackChanges {
+
+	cc := new(CallbackChanges)
+	var changes []*Change
+
+	lHashes := make(map[string]string)
+	rHashes := make(map[string]string)
+
+	lValues := make(map[string]low.ValueReference[*v3.PathItem])
+	rValues := make(map[string]low.ValueReference[*v3.PathItem])
+
+	for k := range l.Expression.Value {
+		lHashes[k.Value] = low.GenerateHashString(l.Expression.Value[k].Value)
+		lValues[k.Value] = l.Expression.Value[k]
+	}
+
+	for k := range r.Expression.Value {
+		rHashes[k.Value] = low.GenerateHashString(r.Expression.Value[k].Value)
+		rValues[k.Value] = r.Expression.Value[k]
+	}
+
+	expChanges := make(map[string]*PathItemChanges)
+
+	// check left path item hashes
+	for k := range lHashes {
+		rhash := rHashes[k]
+		if rhash == "" {
+			CreateChange(&changes, ObjectRemoved, k,
+				lValues[k].GetValueNode(), nil, true,
+				lValues[k].GetValue(), nil)
+			continue
+		}
+		if lHashes[k] == rHashes[k] {
+			continue
+		}
+		// run comparison.
+		expChanges[k] = ComparePathItems(lValues[k].Value, rValues[k].Value)
+	}
+
+	//check right path item hashes
+	for k := range rHashes {
+		lhash := lHashes[k]
+		if lhash == "" {
+			CreateChange(&changes, ObjectAdded, k,
+				nil, rValues[k].GetValueNode(), false,
+				nil, rValues[k].GetValue())
+			continue
+		}
+	}
+	cc.ExpressionChanges = expChanges
+	cc.ExtensionChanges = CompareExtensions(l.Extensions, r.Extensions)
+	cc.Changes = changes
+	if cc.TotalChanges() <= 0 {
+		return nil
+	}
+	return cc
+}

what-changed/model/callback_test.go

@@ -0,0 +1,193 @@
+// Copyright 2022 Princess B33f Heavy Industries / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package model
+
+import (
+	"github.com/pb33f/libopenapi/datamodel/low"
+	"github.com/pb33f/libopenapi/datamodel/low/v3"
+	"github.com/stretchr/testify/assert"
+	"gopkg.in/yaml.v3"
+	"testing"
+)
+
+func TestCompareCallback(t *testing.T) {
+
+	left := `'{$request.query.queryUrl}':
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed`
+
+	right := left
+
+	var lNode, rNode yaml.Node
+	_ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
+
+	// create low level objects
+	var lDoc v3.Callback
+	var rDoc v3.Callback
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = lDoc.Build(lNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
+
+	// compare.
+	extChanges := CompareCallback(&lDoc, &rDoc)
+	assert.Nil(t, extChanges)
+}
+
+func TestCompareCallback_Add(t *testing.T) {
+
+	left := `'{$request.query.queryUrl}':
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed`
+
+	right := `'{$request.query.queryUrl}':
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed
+'slippers':
+    post:
+      description: toasty toes`
+
+	var lNode, rNode yaml.Node
+	_ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
+
+	// create low level objects
+	var lDoc v3.Callback
+	var rDoc v3.Callback
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = lDoc.Build(lNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
+
+	// compare.
+	extChanges := CompareCallback(&lDoc, &rDoc)
+	assert.Equal(t, 1, extChanges.TotalChanges())
+	assert.Equal(t, 0, extChanges.TotalBreakingChanges())
+	assert.Equal(t, ObjectAdded, extChanges.Changes[0].ChangeType)
+	assert.Equal(t, "slippers", extChanges.Changes[0].Property)
+}
+
+func TestCompareCallback_Modify(t *testing.T) {
+
+	left := `x-pizza: tasty
+'{$request.query.queryUrl}':
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed`
+
+	right := `x-pizza: cold
+'{$request.query.queryUrl}':
+    get:
+      description: a nice new thing, for the things.
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed`
+
+	var lNode, rNode yaml.Node
+	_ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
+
+	// create low level objects
+	var lDoc v3.Callback
+	var rDoc v3.Callback
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = lDoc.Build(lNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
+
+	// compare.
+	extChanges := CompareCallback(&lDoc, &rDoc)
+	assert.Equal(t, 2, extChanges.TotalChanges())
+	assert.Equal(t, 0, extChanges.TotalBreakingChanges())
+	assert.Equal(t, PropertyAdded, extChanges.ExpressionChanges["{$request.query.queryUrl}"].Changes[0].ChangeType)
+	assert.Equal(t, v3.GetLabel, extChanges.ExpressionChanges["{$request.query.queryUrl}"].Changes[0].Property)
+}
+
+func TestCompareCallback_Remove(t *testing.T) {
+
+	left := `'{$request.query.queryUrl}':
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed`
+
+	right := `'{$request.query.queryUrl}':
+    post:
+      requestBody:
+        description: Callback payload
+        content: 
+          'application/json':
+            schema:
+              type: int
+      responses:
+        '200':
+          description: callback successfully processed
+'slippers':
+    post:
+      description: toasty toes`
+
+	var lNode, rNode yaml.Node
+	_ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
+
+	// create low level objects
+	var lDoc v3.Callback
+	var rDoc v3.Callback
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = lDoc.Build(lNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
+
+	// compare.
+	extChanges := CompareCallback(&rDoc, &lDoc)
+	assert.Equal(t, 1, extChanges.TotalChanges())
+	assert.Equal(t, 1, extChanges.TotalBreakingChanges())
+	assert.Equal(t, ObjectRemoved, extChanges.Changes[0].ChangeType)
+	assert.Equal(t, "slippers", extChanges.Changes[0].Property)
+}

what-changed/model/comparison_functions.go

@@ -206,7 +206,7 @@ func CheckMapForChanges[T any, R any](expLeft, expRight map[low.KeyReference[str
 		rhash := rHashes[k]
 		if rhash == "" {
 			CreateChange(changes, ObjectRemoved, label,
-				lValues[k].GetValueNode(), nil, false,
+				lValues[k].GetValueNode(), nil, true,
 				lValues[k].GetValue(), nil)
 			continue
 		}
@@ -222,28 +222,14 @@ func CheckMapForChanges[T any, R any](expLeft, expRight map[low.KeyReference[str
 		lhash := lHashes[k]
 		if lhash == "" {
 			CreateChange(changes, ObjectAdded, label,
-				nil, lValues[k].GetValueNode(), false,
+				nil, rValues[k].GetValueNode(), false,
-				nil, lValues[k].GetValue())
+				nil, rValues[k].GetValue())
 			continue
 		}
 	}
 	return expChanges
 }
 
-//func CompareMapStrings(l, r low.ValueReference[string]) *Change {
-//
-//	if l.Value != r.Value {
-//		return &Change{
-//			Context:        CreateContext(l.ValueNode, r.ValueNode),
-//			ChangeType:     Modified,
-//			Original:       l.Value,
-//			New:            r.Value,
-//			Breaking:       false,
-//		}
-//	}
-//	return nil
-//}
-
 // ExtractStringValueSliceChanges will compare two low level string slices for changes.
 func ExtractStringValueSliceChanges(lParam, rParam []low.ValueReference[string],
 	changes *[]*Change, label string, breaking bool) {

what-changed/model/components.go

@@ -0,0 +1,19 @@
+// Copyright 2022 Princess B33f Heavy Industries / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package model
+
+type ComponentsChanges struct {
+	PropertyChanges
+	SchemaChanges         map[string]*SchemaChanges
+	ResponsesChanges      map[string]*SchemaChanges
+	ParameterChanges      map[string]*ParameterChanges
+	ExamplesChanges       map[string]*ExamplesChanges
+	RequestBodyChanges    map[string]*RequestBodyChanges
+	HeaderChanges         map[string]*HeaderChanges
+	SecuritySchemeChanges map[string]*SecuritySchemeChanges
+	LinkChanges           map[string]*LinkChanges
+	// todo:
+	//CallbackChanges map[string]*CallbackChanges
+	ExtensionChanges *ExtensionChanges
+}

what-changed/model/encoding_test.go

@@ -4,16 +4,16 @@
 package model
 
 import (
-    "github.com/pb33f/libopenapi/datamodel/low"
+	"github.com/pb33f/libopenapi/datamodel/low"
-    v3 "github.com/pb33f/libopenapi/datamodel/low/v3"
+	v3 "github.com/pb33f/libopenapi/datamodel/low/v3"
-    "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/assert"
-    "gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v3"
-    "testing"
+	"testing"
 )
 
 func TestCompareEncoding(t *testing.T) {
 
-    left := `contentType: application/json
+	left := `contentType: application/json
 headers:
   aHeader:
     description: a header
@@ -21,7 +21,7 @@ style: date
 explode: true
 allowReserved: true`
 
-    right := `contentType: application/json
+	right := `contentType: application/json
 headers:
   aHeader:
     description: a header
@@ -29,26 +29,26 @@ style: date
 explode: true
 allowReserved: true`
 
-    var lNode, rNode yaml.Node
+	var lNode, rNode yaml.Node
-    _ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(left), &lNode)
-    _ = yaml.Unmarshal([]byte(right), &rNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
 
-    // create low level objects
+	// create low level objects
-    var lDoc v3.Encoding
+	var lDoc v3.Encoding
-    var rDoc v3.Encoding
+	var rDoc v3.Encoding
-    _ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
-    _ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
-    _ = lDoc.Build(lNode.Content[0], nil)
+	_ = lDoc.Build(lNode.Content[0], nil)
-    _ = rDoc.Build(rNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
 
-    // compare.
+	// compare.
-    extChanges := CompareEncoding(&lDoc, &rDoc)
+	extChanges := CompareEncoding(&lDoc, &rDoc)
-    assert.Nil(t, extChanges)
+	assert.Nil(t, extChanges)
 }
 
 func TestCompareEncoding_Modified(t *testing.T) {
 
-    left := `contentType: application/xml
+	left := `contentType: application/xml
 headers:
   aHeader:
     description: a header description
@@ -56,7 +56,7 @@ style: date
 explode: false
 allowReserved: false`
 
-    right := `contentType: application/json
+	right := `contentType: application/json
 headers:
   aHeader:
     description: a header
@@ -64,33 +64,33 @@ style: date
 explode: true
 allowReserved: true`
 
-    var lNode, rNode yaml.Node
+	var lNode, rNode yaml.Node
-    _ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(left), &lNode)
-    _ = yaml.Unmarshal([]byte(right), &rNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
 
-    // create low level objects
+	// create low level objects
-    var lDoc v3.Encoding
+	var lDoc v3.Encoding
-    var rDoc v3.Encoding
+	var rDoc v3.Encoding
-    _ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
-    _ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
-    _ = lDoc.Build(lNode.Content[0], nil)
+	_ = lDoc.Build(lNode.Content[0], nil)
-    _ = rDoc.Build(rNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
 
-    // compare.
+	// compare.
-    extChanges := CompareEncoding(&lDoc, &rDoc)
+	extChanges := CompareEncoding(&lDoc, &rDoc)
-    assert.NotNil(t, extChanges)
+	assert.NotNil(t, extChanges)
-    assert.Equal(t, 4, extChanges.TotalChanges())
+	assert.Equal(t, 4, extChanges.TotalChanges())
-    assert.Equal(t, 2, extChanges.TotalBreakingChanges())
+	assert.Equal(t, 2, extChanges.TotalBreakingChanges())
 
 }
 
 func TestCompareEncoding_Added(t *testing.T) {
 
-    left := `contentType: application/json
+	left := `contentType: application/json
 explode: true
 allowReserved: true`
 
-    right := `contentType: application/json
+	right := `contentType: application/json
 headers:
   aHeader:
     description: a header
@@ -98,34 +98,34 @@ style: date
 explode: true
 allowReserved: true`
 
-    var lNode, rNode yaml.Node
+	var lNode, rNode yaml.Node
-    _ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(left), &lNode)
-    _ = yaml.Unmarshal([]byte(right), &rNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
 
-    // create low level objects
+	// create low level objects
-    var lDoc v3.Encoding
+	var lDoc v3.Encoding
-    var rDoc v3.Encoding
+	var rDoc v3.Encoding
-    _ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
-    _ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
-    _ = lDoc.Build(lNode.Content[0], nil)
+	_ = lDoc.Build(lNode.Content[0], nil)
-    _ = rDoc.Build(rNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
 
-    // compare.
+	// compare.
-    extChanges := CompareEncoding(&lDoc, &rDoc)
+	extChanges := CompareEncoding(&lDoc, &rDoc)
-    assert.NotNil(t, extChanges)
+	assert.NotNil(t, extChanges)
-    assert.Equal(t, 1, extChanges.TotalChanges())
+	assert.Equal(t, 1, extChanges.TotalChanges())
-    assert.Equal(t, 0, extChanges.TotalBreakingChanges())
+	assert.Equal(t, 0, extChanges.TotalBreakingChanges())
-    assert.Equal(t, ObjectAdded, extChanges.Changes[0].ChangeType)
+	assert.Equal(t, ObjectAdded, extChanges.Changes[0].ChangeType)
-    assert.Equal(t, v3.HeadersLabel, extChanges.Changes[0].Property)
+	assert.Equal(t, v3.HeadersLabel, extChanges.Changes[0].Property)
 }
 
 func TestCompareEncoding_Removed(t *testing.T) {
 
-    left := `contentType: application/json
+	left := `contentType: application/json
 explode: true
 allowReserved: true`
 
-    right := `contentType: application/json
+	right := `contentType: application/json
 headers:
   aHeader:
     description: a header
@@ -133,22 +133,22 @@ style: date
 explode: true
 allowReserved: true`
 
-    var lNode, rNode yaml.Node
+	var lNode, rNode yaml.Node
-    _ = yaml.Unmarshal([]byte(left), &lNode)
+	_ = yaml.Unmarshal([]byte(left), &lNode)
-    _ = yaml.Unmarshal([]byte(right), &rNode)
+	_ = yaml.Unmarshal([]byte(right), &rNode)
 
-    // create low level objects
+	// create low level objects
-    var lDoc v3.Encoding
+	var lDoc v3.Encoding
-    var rDoc v3.Encoding
+	var rDoc v3.Encoding
-    _ = low.BuildModel(lNode.Content[0], &lDoc)
+	_ = low.BuildModel(lNode.Content[0], &lDoc)
-    _ = low.BuildModel(rNode.Content[0], &rDoc)
+	_ = low.BuildModel(rNode.Content[0], &rDoc)
-    _ = lDoc.Build(lNode.Content[0], nil)
+	_ = lDoc.Build(lNode.Content[0], nil)
-    _ = rDoc.Build(rNode.Content[0], nil)
+	_ = rDoc.Build(rNode.Content[0], nil)
 
-    // compare.
+	// compare.
-    extChanges := CompareEncoding(&rDoc, &lDoc)
+	extChanges := CompareEncoding(&rDoc, &lDoc)
-    assert.NotNil(t, extChanges)
+	assert.NotNil(t, extChanges)
-    assert.Equal(t, 1, extChanges.TotalChanges())
+	assert.Equal(t, 1, extChanges.TotalChanges())
-    assert.Equal(t, 0, extChanges.TotalBreakingChanges())
+	assert.Equal(t, 1, extChanges.TotalBreakingChanges())
 
 }

what-changed/model/parameter_test.go

@@ -344,7 +344,7 @@ func TestCompareParameters_V3_ExamplesRemoved(t *testing.T) {
 	// compare
 	extChanges := CompareParameters(&rDoc, &lDoc)
 	assert.Equal(t, 1, extChanges.TotalChanges())
-	assert.Equal(t, 0, extChanges.TotalBreakingChanges())
+	assert.Equal(t, 1, extChanges.TotalBreakingChanges())
 	assert.Equal(t, ObjectRemoved, extChanges.Changes[0].ChangeType)
 }