diff --git a/datamodel/low/v3/constants.go b/datamodel/low/v3/constants.go index 1955349..9e257ee 100644 --- a/datamodel/low/v3/constants.go +++ b/datamodel/low/v3/constants.go @@ -9,6 +9,7 @@ const ( SchemasLabel = "schemas" EncodingLabel = "encoding" HeadersLabel = "headers" + ExpressionLabel = "expression" ParametersLabel = "parameters" RequestBodyLabel = "requestBody" RequestBodiesLabel = "requestBodies" diff --git a/datamodel/low/v3/response_test.go b/datamodel/low/v3/response_test.go index 3969348..3ffca2f 100644 --- a/datamodel/low/v3/response_test.go +++ b/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) +// +//} diff --git a/datamodel/low/v3/responses.go b/datamodel/low/v3/responses.go index 4b7de3c..7bad3dc 100644 --- a/datamodel/low/v3/responses.go +++ b/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, diff --git a/datamodel/low/v3/security_scheme_test.go b/datamodel/low/v3/security_scheme_test.go index aaa3fc8..0558efb 100644 --- a/datamodel/low/v3/security_scheme_test.go +++ b/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) diff --git a/datamodel/low/v3/server_test.go b/datamodel/low/v3/server_test.go index ee74d6f..0162298 100644 --- a/datamodel/low/v3/server_test.go +++ b/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) { diff --git a/datamodel/low/v3/server_variable.go b/datamodel/low/v3/server_variable.go index 18795e9..d08a8d3 100644 --- a/datamodel/low/v3/server_variable.go +++ b/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) } diff --git a/what-changed/model/callback.go b/what-changed/model/callback.go new file mode 100644 index 0000000..8151a3e --- /dev/null +++ b/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 +} diff --git a/what-changed/model/callback_test.go b/what-changed/model/callback_test.go new file mode 100644 index 0000000..70a5ed4 --- /dev/null +++ b/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) +} diff --git a/what-changed/model/comparison_functions.go b/what-changed/model/comparison_functions.go index c106b58..f277a5e 100644 --- a/what-changed/model/comparison_functions.go +++ b/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, lValues[k].GetValue()) + nil, rValues[k].GetValueNode(), false, + 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) { diff --git a/what-changed/model/components.go b/what-changed/model/components.go new file mode 100644 index 0000000..df7430a --- /dev/null +++ b/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 +} diff --git a/what-changed/model/encoding_test.go b/what-changed/model/encoding_test.go index 0191d12..919bbcd 100644 --- a/what-changed/model/encoding_test.go +++ b/what-changed/model/encoding_test.go @@ -4,16 +4,16 @@ package model import ( - "github.com/pb33f/libopenapi/datamodel/low" - v3 "github.com/pb33f/libopenapi/datamodel/low/v3" - "github.com/stretchr/testify/assert" - "gopkg.in/yaml.v3" - "testing" + "github.com/pb33f/libopenapi/datamodel/low" + v3 "github.com/pb33f/libopenapi/datamodel/low/v3" + "github.com/stretchr/testify/assert" + "gopkg.in/yaml.v3" + "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 - _ = yaml.Unmarshal([]byte(left), &lNode) - _ = yaml.Unmarshal([]byte(right), &rNode) + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) - // create low level objects - var lDoc v3.Encoding - var rDoc v3.Encoding - _ = low.BuildModel(lNode.Content[0], &lDoc) - _ = low.BuildModel(rNode.Content[0], &rDoc) - _ = lDoc.Build(lNode.Content[0], nil) - _ = rDoc.Build(rNode.Content[0], nil) + // create low level objects + var lDoc v3.Encoding + var rDoc v3.Encoding + _ = 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 := CompareEncoding(&lDoc, &rDoc) - assert.Nil(t, extChanges) + // compare. + extChanges := CompareEncoding(&lDoc, &rDoc) + 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 - _ = yaml.Unmarshal([]byte(left), &lNode) - _ = yaml.Unmarshal([]byte(right), &rNode) + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) - // create low level objects - var lDoc v3.Encoding - var rDoc v3.Encoding - _ = low.BuildModel(lNode.Content[0], &lDoc) - _ = low.BuildModel(rNode.Content[0], &rDoc) - _ = lDoc.Build(lNode.Content[0], nil) - _ = rDoc.Build(rNode.Content[0], nil) + // create low level objects + var lDoc v3.Encoding + var rDoc v3.Encoding + _ = 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 := CompareEncoding(&lDoc, &rDoc) - assert.NotNil(t, extChanges) - assert.Equal(t, 4, extChanges.TotalChanges()) - assert.Equal(t, 2, extChanges.TotalBreakingChanges()) + // compare. + extChanges := CompareEncoding(&lDoc, &rDoc) + assert.NotNil(t, extChanges) + assert.Equal(t, 4, extChanges.TotalChanges()) + 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 - _ = yaml.Unmarshal([]byte(left), &lNode) - _ = yaml.Unmarshal([]byte(right), &rNode) + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) - // create low level objects - var lDoc v3.Encoding - var rDoc v3.Encoding - _ = low.BuildModel(lNode.Content[0], &lDoc) - _ = low.BuildModel(rNode.Content[0], &rDoc) - _ = lDoc.Build(lNode.Content[0], nil) - _ = rDoc.Build(rNode.Content[0], nil) + // create low level objects + var lDoc v3.Encoding + var rDoc v3.Encoding + _ = 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 := CompareEncoding(&lDoc, &rDoc) - assert.NotNil(t, extChanges) - assert.Equal(t, 1, extChanges.TotalChanges()) - assert.Equal(t, 0, extChanges.TotalBreakingChanges()) - assert.Equal(t, ObjectAdded, extChanges.Changes[0].ChangeType) - assert.Equal(t, v3.HeadersLabel, extChanges.Changes[0].Property) + // compare. + extChanges := CompareEncoding(&lDoc, &rDoc) + assert.NotNil(t, extChanges) + assert.Equal(t, 1, extChanges.TotalChanges()) + assert.Equal(t, 0, extChanges.TotalBreakingChanges()) + assert.Equal(t, ObjectAdded, extChanges.Changes[0].ChangeType) + 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 - _ = yaml.Unmarshal([]byte(left), &lNode) - _ = yaml.Unmarshal([]byte(right), &rNode) + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) - // create low level objects - var lDoc v3.Encoding - var rDoc v3.Encoding - _ = low.BuildModel(lNode.Content[0], &lDoc) - _ = low.BuildModel(rNode.Content[0], &rDoc) - _ = lDoc.Build(lNode.Content[0], nil) - _ = rDoc.Build(rNode.Content[0], nil) + // create low level objects + var lDoc v3.Encoding + var rDoc v3.Encoding + _ = 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 := CompareEncoding(&rDoc, &lDoc) - assert.NotNil(t, extChanges) - assert.Equal(t, 1, extChanges.TotalChanges()) - assert.Equal(t, 0, extChanges.TotalBreakingChanges()) + // compare. + extChanges := CompareEncoding(&rDoc, &lDoc) + assert.NotNil(t, extChanges) + assert.Equal(t, 1, extChanges.TotalChanges()) + assert.Equal(t, 1, extChanges.TotalBreakingChanges()) } diff --git a/what-changed/model/parameter_test.go b/what-changed/model/parameter_test.go index 41f86f7..6699e53 100644 --- a/what-changed/model/parameter_test.go +++ b/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) }