diff --git a/datamodel/low/extraction_functions.go b/datamodel/low/extraction_functions.go index 3b88c86..937105c 100644 --- a/datamodel/low/extraction_functions.go +++ b/datamodel/low/extraction_functions.go @@ -559,8 +559,8 @@ func AreEqual(l, r Hashable) bool { func GenerateHashString(v any) string { if h, ok := v.(Hashable); ok { if h != nil { - return fmt.Sprintf("%x", h.Hash()) + return fmt.Sprintf(HASH, h.Hash()) } } - return fmt.Sprintf("%x", sha256.Sum256([]byte(fmt.Sprint(v)))) + return fmt.Sprintf(HASH, sha256.Sum256([]byte(fmt.Sprint(v)))) } diff --git a/datamodel/low/reference.go b/datamodel/low/reference.go index f18512c..85e17a9 100644 --- a/datamodel/low/reference.go +++ b/datamodel/low/reference.go @@ -7,6 +7,10 @@ import ( "gopkg.in/yaml.v3" ) +const ( + HASH = "%x" +) + // Buildable is an interface for any struct that can be 'built out'. This means that a struct can accept // a root node and a reference to the index that carries data about any references used. // diff --git a/datamodel/low/v2/scopes.go b/datamodel/low/v2/scopes.go index b320f6a..572de7c 100644 --- a/datamodel/low/v2/scopes.go +++ b/datamodel/low/v2/scopes.go @@ -4,10 +4,13 @@ package v2 import ( + "crypto/sha256" + "fmt" "github.com/pb33f/libopenapi/datamodel/low" "github.com/pb33f/libopenapi/index" "github.com/pb33f/libopenapi/utils" "gopkg.in/yaml.v3" + "strings" ) // Scopes is a low-level representation of a Swagger / OpenAPI 2 OAuth2 Scopes object. @@ -31,6 +34,9 @@ func (s *Scopes) Build(root *yaml.Node, idx *index.SpecIndex) error { if utils.IsNodeMap(root) { for k := range root.Content { if k%2 == 0 { + if strings.Contains(root.Content[k].Value, "x-") { + continue + } valueMap[low.KeyReference[string]{ Value: root.Content[k].Value, KeyNode: root.Content[k], @@ -44,3 +50,15 @@ func (s *Scopes) Build(root *yaml.Node, idx *index.SpecIndex) error { } return nil } + +// Hash will return a consistent SHA256 Hash of the Scopes object +func (s *Scopes) Hash() [32]byte { + var f []string + for i := range s.Values { + f = append(f, fmt.Sprintf("%s-%s", i.Value, s.Values[i].Value)) + } + for k := range s.Extensions { + f = append(f, fmt.Sprintf("%s-%v", k.Value, s.Extensions[k].Value)) + } + return sha256.Sum256([]byte(strings.Join(f, "|"))) +} diff --git a/datamodel/low/v2/security_scheme.go b/datamodel/low/v2/security_scheme.go index 8360b96..47fc406 100644 --- a/datamodel/low/v2/security_scheme.go +++ b/datamodel/low/v2/security_scheme.go @@ -4,9 +4,12 @@ package v2 import ( + "crypto/sha256" + "fmt" "github.com/pb33f/libopenapi/datamodel/low" "github.com/pb33f/libopenapi/index" "gopkg.in/yaml.v3" + "strings" ) // SecurityScheme is a low-level representation of a Swagger / OpenAPI 2 SecurityScheme object. @@ -38,3 +41,36 @@ func (ss *SecurityScheme) Build(root *yaml.Node, idx *index.SpecIndex) error { ss.Scopes = scopes return nil } + +// Hash will return a consistent SHA256 Hash of the SecurityScheme object +func (ss *SecurityScheme) Hash() [32]byte { + var f []string + if !ss.Type.IsEmpty() { + f = append(f, ss.Type.Value) + } + if !ss.Description.IsEmpty() { + f = append(f, ss.Description.Value) + } + if !ss.Name.IsEmpty() { + f = append(f, ss.Name.Value) + } + if !ss.In.IsEmpty() { + f = append(f, ss.In.Value) + } + if !ss.Flow.IsEmpty() { + f = append(f, ss.Flow.Value) + } + if !ss.AuthorizationUrl.IsEmpty() { + f = append(f, ss.AuthorizationUrl.Value) + } + if !ss.TokenUrl.IsEmpty() { + f = append(f, ss.TokenUrl.Value) + } + if !ss.Scopes.IsEmpty() { + f = append(f, low.GenerateHashString(ss.Scopes.Value)) + } + for k := range ss.Extensions { + f = append(f, fmt.Sprintf("%s-%v", k.Value, ss.Extensions[k].Value)) + } + return sha256.Sum256([]byte(strings.Join(f, "|"))) +} diff --git a/datamodel/low/v3/constants.go b/datamodel/low/v3/constants.go index f4a1bed..2718ce6 100644 --- a/datamodel/low/v3/constants.go +++ b/datamodel/low/v3/constants.go @@ -101,4 +101,5 @@ const ( ExplodeLabel = "explode" ContentTypeLabel = "contentType" SecurityDefinitionLabel = "securityDefinition" + Scopes = "scopes" ) diff --git a/datamodel/low/v3/oauth_flows.go b/datamodel/low/v3/oauth_flows.go index 000c4df..c6639f1 100644 --- a/datamodel/low/v3/oauth_flows.go +++ b/datamodel/low/v3/oauth_flows.go @@ -4,9 +4,12 @@ package v3 import ( + "crypto/sha256" + "fmt" "github.com/pb33f/libopenapi/datamodel/low" "github.com/pb33f/libopenapi/index" "gopkg.in/yaml.v3" + "strings" ) // OAuthFlows represents a low-level OpenAPI 3+ OAuthFlows object. @@ -52,7 +55,27 @@ func (o *OAuthFlows) Build(root *yaml.Node, idx *index.SpecIndex) error { } o.AuthorizationCode = v return nil +} +// Hash will return a consistent SHA256 Hash of the OAuthFlow object +func (o *OAuthFlows) Hash() [32]byte { + var f []string + if !o.Implicit.IsEmpty() { + f = append(f, low.GenerateHashString(o.Implicit.Value)) + } + if !o.Password.IsEmpty() { + f = append(f, low.GenerateHashString(o.Password.Value)) + } + if !o.ClientCredentials.IsEmpty() { + f = append(f, low.GenerateHashString(o.ClientCredentials.Value)) + } + if !o.AuthorizationCode.IsEmpty() { + f = append(f, low.GenerateHashString(o.AuthorizationCode.Value)) + } + for k := range o.Extensions { + f = append(f, fmt.Sprintf("%s-%v", k.Value, o.Extensions[k].Value)) + } + return sha256.Sum256([]byte(strings.Join(f, "|"))) } // OAuthFlow represents a low-level OpenAPI 3+ OAuthFlow object. @@ -80,3 +103,24 @@ func (o *OAuthFlow) Build(root *yaml.Node, idx *index.SpecIndex) error { o.Extensions = low.ExtractExtensions(root) return nil } + +// Hash will return a consistent SHA256 Hash of the OAuthFlow object +func (o *OAuthFlow) Hash() [32]byte { + var f []string + if !o.AuthorizationUrl.IsEmpty() { + f = append(f, o.AuthorizationUrl.Value) + } + if !o.TokenUrl.IsEmpty() { + f = append(f, o.TokenUrl.Value) + } + if !o.RefreshUrl.IsEmpty() { + f = append(f, o.RefreshUrl.Value) + } + for i := range o.Scopes.Value { + f = append(f, fmt.Sprintf("%s-%s", i.Value, o.Scopes.Value[i].Value)) + } + for k := range o.Extensions { + f = append(f, fmt.Sprintf("%s-%v", k.Value, o.Extensions[k].Value)) + } + return sha256.Sum256([]byte(strings.Join(f, "|"))) +} diff --git a/datamodel/low/v3/security_scheme.go b/datamodel/low/v3/security_scheme.go index 5d847df..e7ec035 100644 --- a/datamodel/low/v3/security_scheme.go +++ b/datamodel/low/v3/security_scheme.go @@ -5,6 +5,7 @@ package v3 import ( "crypto/sha256" + "fmt" "github.com/pb33f/libopenapi/datamodel/low" "github.com/pb33f/libopenapi/index" "github.com/pb33f/libopenapi/utils" @@ -66,12 +67,39 @@ func (ss *SecurityScheme) Build(root *yaml.Node, idx *index.SpecIndex) error { if oa.Value != nil { ss.Flows = oa } - return nil } +// Hash will return a consistent SHA256 Hash of the SecurityScheme object func (ss *SecurityScheme) Hash() [32]byte { var f []string + if !ss.Type.IsEmpty() { + f = append(f, ss.Type.Value) + } + if !ss.Description.IsEmpty() { + f = append(f, ss.Description.Value) + } + if !ss.Name.IsEmpty() { + f = append(f, ss.Name.Value) + } + if !ss.In.IsEmpty() { + f = append(f, ss.In.Value) + } + if !ss.Scheme.IsEmpty() { + f = append(f, ss.Scheme.Value) + } + if !ss.BearerFormat.IsEmpty() { + f = append(f, ss.BearerFormat.Value) + } + if !ss.Flows.IsEmpty() { + f = append(f, low.GenerateHashString(ss.Flows.Value)) + } + if !ss.OpenIdConnectUrl.IsEmpty() { + f = append(f, ss.OpenIdConnectUrl.Value) + } + for k := range ss.Extensions { + f = append(f, fmt.Sprintf("%s-%v", k.Value, ss.Extensions[k].Value)) + } return sha256.Sum256([]byte(strings.Join(f, "|"))) } diff --git a/what-changed/model/comparison_functions.go b/what-changed/model/comparison_functions.go index 32419bc..b1aa15d 100644 --- a/what-changed/model/comparison_functions.go +++ b/what-changed/model/comparison_functions.go @@ -230,6 +230,20 @@ func CheckMapForChanges[T any, R any](expLeft, expRight map[low.KeyReference[str 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) { lKeys := make([]string, len(lParam)) diff --git a/what-changed/model/header.go b/what-changed/model/header.go index 8e9bae8..c487ec5 100644 --- a/what-changed/model/header.go +++ b/what-changed/model/header.go @@ -241,8 +241,5 @@ func CompareHeaders(l, r any) *HeaderChanges { } CheckProperties(props) hc.Changes = changes - if hc.TotalChanges() <= 0 { - return nil - } return hc } diff --git a/what-changed/model/scopes.go b/what-changed/model/scopes.go new file mode 100644 index 0000000..a36e26b --- /dev/null +++ b/what-changed/model/scopes.go @@ -0,0 +1,61 @@ +// 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/v2" + v3 "github.com/pb33f/libopenapi/datamodel/low/v3" +) + +type ScopesChanges struct { + PropertyChanges + ExtensionChanges *ExtensionChanges +} + +func (s *ScopesChanges) TotalChanges() int { + c := s.PropertyChanges.TotalChanges() + if s.ExtensionChanges != nil { + c += s.ExtensionChanges.TotalChanges() + } + return c +} + +func (s *ScopesChanges) TotalBreakingChanges() int { + return s.PropertyChanges.TotalBreakingChanges() +} + +func CompareScopes(l, r *v2.Scopes) *ScopesChanges { + if low.AreEqual(l, r) { + return nil + } + var changes []*Change + for v := range l.Values { + if r != nil && r.FindScope(v.Value) == nil { + CreateChange(&changes, ObjectRemoved, v3.Scopes, + l.Values[v].ValueNode, nil, true, + v.Value, nil) + continue + } + if r != nil && r.FindScope(v.Value) != nil { + if l.Values[v].Value != r.FindScope(v.Value).Value { + CreateChange(&changes, Modified, v3.Scopes, + l.Values[v].ValueNode, r.FindScope(v.Value).ValueNode, true, + l.Values[v].Value, r.FindScope(v.Value).Value) + } + } + } + for v := range r.Values { + if l != nil && l.FindScope(v.Value) == nil { + CreateChange(&changes, ObjectAdded, v3.Scopes, + nil, r.Values[v].ValueNode, false, + nil, v.Value) + } + } + + sc := new(ScopesChanges) + sc.Changes = changes + sc.ExtensionChanges = CompareExtensions(l.Extensions, r.Extensions) + return sc +} diff --git a/what-changed/model/scopes_test.go b/what-changed/model/scopes_test.go new file mode 100644 index 0000000..43ab578 --- /dev/null +++ b/what-changed/model/scopes_test.go @@ -0,0 +1,125 @@ +// Copyright 2022 Princess B33f Heavy Industries / Dave Shanley +// SPDX-License-Identifier: MIT + +package model + +import ( + "github.com/pb33f/libopenapi/datamodel/low" + v2 "github.com/pb33f/libopenapi/datamodel/low/v2" + "github.com/stretchr/testify/assert" + "gopkg.in/yaml.v3" + "testing" +) + +func TestCompareScopes(t *testing.T) { + + left := `pizza: pie +lemon: sky +x-nugget: chicken` + right := `pizza: pie +lemon: sky +x-nugget: chicken` + + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) + + // create low level objects + var lDoc v2.Scopes + var rDoc v2.Scopes + _ = low.BuildModel(&lNode, &lDoc) + _ = low.BuildModel(&rNode, &rDoc) + _ = lDoc.Build(lNode.Content[0], nil) + _ = rDoc.Build(rNode.Content[0], nil) + + // compare. + extChanges := CompareScopes(&lDoc, &rDoc) + assert.Nil(t, extChanges) +} + +func TestCompareScopes_Modified(t *testing.T) { + + left := `pizza: sky +lemon: sky +x-nugget: chicken` + right := `pizza: pie +lemon: sky +x-nugget: chicken` + + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) + + // create low level objects + var lDoc v2.Scopes + var rDoc v2.Scopes + _ = low.BuildModel(&lNode, &lDoc) + _ = low.BuildModel(&rNode, &rDoc) + _ = lDoc.Build(lNode.Content[0], nil) + _ = rDoc.Build(rNode.Content[0], nil) + + // compare. + extChanges := CompareScopes(&lDoc, &rDoc) + assert.Equal(t, 1, extChanges.TotalChanges()) + assert.Equal(t, 1, extChanges.TotalBreakingChanges()) + assert.Equal(t, Modified, extChanges.Changes[0].ChangeType) + assert.Equal(t, "pie", extChanges.Changes[0].New) +} + +func TestCompareScopes_Added(t *testing.T) { + + left := `pizza: sky +x-nugget: chicken` + right := `pizza: sky +lemon: sky +x-nugget: chicken` + + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) + + // create low level objects + var lDoc v2.Scopes + var rDoc v2.Scopes + _ = low.BuildModel(&lNode, &lDoc) + _ = low.BuildModel(&rNode, &rDoc) + _ = lDoc.Build(lNode.Content[0], nil) + _ = rDoc.Build(rNode.Content[0], nil) + + // compare. + extChanges := CompareScopes(&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, "sky", extChanges.Changes[0].New) + assert.Equal(t, "lemon", extChanges.Changes[0].NewObject) +} + +func TestCompareScopes_Removed_ChangeExt(t *testing.T) { + + left := `pizza: sky +x-nugget: chicken` + right := `pizza: sky +lemon: sky +x-nugget: soup` + + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) + + // create low level objects + var lDoc v2.Scopes + var rDoc v2.Scopes + _ = low.BuildModel(&lNode, &lDoc) + _ = low.BuildModel(&rNode, &rDoc) + _ = lDoc.Build(lNode.Content[0], nil) + _ = rDoc.Build(rNode.Content[0], nil) + + // compare. + extChanges := CompareScopes(&rDoc, &lDoc) + assert.Equal(t, 2, extChanges.TotalChanges()) + assert.Equal(t, 1, extChanges.TotalBreakingChanges()) + assert.Equal(t, ObjectRemoved, extChanges.Changes[0].ChangeType) + assert.Equal(t, "sky", extChanges.Changes[0].Original) + assert.Equal(t, "lemon", extChanges.Changes[0].OriginalObject) +} diff --git a/what-changed/model/security_requirement_test.go b/what-changed/model/security_requirement_test.go index 7305130..cba8cce 100644 --- a/what-changed/model/security_requirement_test.go +++ b/what-changed/model/security_requirement_test.go @@ -346,3 +346,36 @@ biscuit: assert.Equal(t, ObjectRemoved, extChanges.Changes[0].ChangeType) assert.Equal(t, "rich tea", extChanges.Changes[0].Original) } + +func TestCompareSecurityRequirement_Add(t *testing.T) { + + left := ` +biscuit: + - biscotti + - rich tea` + + right := `punch: + - nice +cheese: + - pizza + - pie +biscuit: + - biscotti + - rich tea` + + var lNode, rNode yaml.Node + _ = yaml.Unmarshal([]byte(left), &lNode) + _ = yaml.Unmarshal([]byte(right), &rNode) + + // create low level objects + var lDoc v2.SecurityRequirement + var rDoc v2.SecurityRequirement + _ = low.BuildModel(&lNode, &lDoc) + _ = low.BuildModel(&rNode, &rDoc) + _ = lDoc.Build(lNode.Content[0], nil) + _ = rDoc.Build(rNode.Content[0], nil) + + // compare + extChanges := CompareSecurityRequirement(&lDoc, &rDoc) + assert.Nil(t, extChanges) +}