Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 .codecov.yml coverage: status: patch: default: target: 80%	66 B	2025-05-25 12:27
📄 .gitattributes *.go text eol=lf	18 B	2025-05-25 12:27
📁 .github	-	2025-05-25 12:27
📄 .gitignore secrets.yml coverage.out coverage.txt *.cov .idea	50 B	2025-05-25 12:27
📄 .golangci.yml linters-settings: govet: check-shadowing: true golint: min-confidence: 0 gocyclo: min-complexity: 45 maligned: suggest-new: true dupl: threshold: 200 goconst: min-len: 2 min-occurrences: 3 linters: enable-all: true disable: - maligned - unparam - lll - gochecknoinits - gochecknoglobals - funlen - godox - gocognit - whitespace - wsl - wrapcheck - testpackage - nlreturn - gomnd - exhaustivestruct - goerr113 - errorlint - nestif - godot - gofumpt - paralleltest - tparallel - thelper - ifshort - exhaustruct - varnamelen - gci - depguard - errchkjson - inamedparam - nonamedreturns - musttag - ireturn - forcetypeassert - cyclop # deprecated linters - deadcode - interfacer - scopelint - varcheck - structcheck - golint - nosnakecase	952 B	2025-05-25 12:27
📄 CODE_OF_CONDUCT.md # Contributor Covenant Code of Conduct ## Our Pledge In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation. ## Our Standards Examples of behavior that contributes to creating a positive environment include: * Using welcoming and inclusive language * Being respectful of differing viewpoints and experiences * Gracefully accepting constructive criticism * Focusing on what is best for the community * Showing empathy towards other community members Examples of unacceptable behavior by participants include: * The use of sexualized language or imagery and unwelcome sexual attention or advances * Trolling, insulting/derogatory comments, and personal or political attacks * Public or private harassment * Publishing others' private information, such as a physical or electronic address, without explicit permission * Other conduct which could reasonably be considered inappropriate in a professional setting ## Our Responsibilities Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior. Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful. ## Scope This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers. ## Enforcement Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at ivan+abuse@flanders.co.nz. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately. Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership. ## Attribution This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version] [homepage]: http://contributor-covenant.org [version]: http://contributor-covenant.org/version/1/4/	3.16 KB	2025-05-25 12:27
📄 LICENSE Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.	11.09 KB	2025-05-25 12:27
📄 README.md # OpenAPI analysis [![Build Status](https://github.com/go-openapi/analysis/actions/workflows/go-test.yml/badge.svg)](https://github.com/go-openapi/analysis/actions?query=workflow%3A"go+test") [![codecov](https://codecov.io/gh/go-openapi/analysis/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/analysis) [![Slack Status](https://slackin.goswagger.io/badge.svg)](https://slackin.goswagger.io) [![license](http://img.shields.io/badge/license-Apache%20v2-orange.svg)](https://raw.githubusercontent.com/go-openapi/analysis/master/LICENSE) [![Go Reference](https://pkg.go.dev/badge/github.com/go-openapi/analysis.svg)](https://pkg.go.dev/github.com/go-openapi/analysis) [![Go Report Card](https://goreportcard.com/badge/github.com/go-openapi/analysis)](https://goreportcard.com/report/github.com/go-openapi/analysis) A foundational library to analyze an OAI specification document for easier reasoning about the content. ## What's inside? * An analyzer providing methods to walk the functional content of a specification * A spec flattener producing a self-contained document bundle, while preserving `$ref`s * A spec merger ("mixin") to merge several spec documents into a primary spec * A spec "fixer" ensuring that response descriptions are non empty [Documentation](https://pkg.go.dev/github.com/go-openapi/analysis) ## FAQ * Does this library support OpenAPI 3? > No. > This package currently only supports OpenAPI 2.0 (aka Swagger 2.0). > There is no plan to make it evolve toward supporting OpenAPI 3.x. > This [discussion thread](https://github.com/go-openapi/spec/issues/21) relates the full story.	1.59 KB	2025-05-25 12:27
📄 analyzer.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "fmt" slashpath "path" "strconv" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/spec" "github.com/go-openapi/swag" ) type referenceAnalysis struct { schemas map[string]spec.Ref responses map[string]spec.Ref parameters map[string]spec.Ref items map[string]spec.Ref headerItems map[string]spec.Ref parameterItems map[string]spec.Ref allRefs map[string]spec.Ref pathItems map[string]spec.Ref } func (r referenceAnalysis) addRef(key string, ref spec.Ref) { r.allRefs["#"+key] = ref } func (r referenceAnalysis) addItemsRef(key string, items spec.Items, location string) { r.items["#"+key] = items.Ref r.addRef(key, items.Ref) if location == "header" { // NOTE: in swagger 2.0, headers and parameters (but not body param schemas) are simple schemas // and $ref are not supported here. However it is possible to analyze this. r.headerItems["#"+key] = items.Ref } else { r.parameterItems["#"+key] = items.Ref } } func (r referenceAnalysis) addSchemaRef(key string, ref SchemaRef) { r.schemas["#"+key] = ref.Schema.Ref r.addRef(key, ref.Schema.Ref) } func (r referenceAnalysis) addResponseRef(key string, resp spec.Response) { r.responses["#"+key] = resp.Ref r.addRef(key, resp.Ref) } func (r referenceAnalysis) addParamRef(key string, param spec.Parameter) { r.parameters["#"+key] = param.Ref r.addRef(key, param.Ref) } func (r referenceAnalysis) addPathItemRef(key string, pathItem spec.PathItem) { r.pathItems["#"+key] = pathItem.Ref r.addRef(key, pathItem.Ref) } type patternAnalysis struct { parameters map[string]string headers map[string]string items map[string]string schemas map[string]string allPatterns map[string]string } func (p patternAnalysis) addPattern(key, pattern string) { p.allPatterns["#"+key] = pattern } func (p patternAnalysis) addParameterPattern(key, pattern string) { p.parameters["#"+key] = pattern p.addPattern(key, pattern) } func (p patternAnalysis) addHeaderPattern(key, pattern string) { p.headers["#"+key] = pattern p.addPattern(key, pattern) } func (p patternAnalysis) addItemsPattern(key, pattern string) { p.items["#"+key] = pattern p.addPattern(key, pattern) } func (p patternAnalysis) addSchemaPattern(key, pattern string) { p.schemas["#"+key] = pattern p.addPattern(key, pattern) } type enumAnalysis struct { parameters map[string][]interface{} headers map[string][]interface{} items map[string][]interface{} schemas map[string][]interface{} allEnums map[string][]interface{} } func (p enumAnalysis) addEnum(key string, enum []interface{}) { p.allEnums["#"+key] = enum } func (p enumAnalysis) addParameterEnum(key string, enum []interface{}) { p.parameters["#"+key] = enum p.addEnum(key, enum) } func (p enumAnalysis) addHeaderEnum(key string, enum []interface{}) { p.headers["#"+key] = enum p.addEnum(key, enum) } func (p enumAnalysis) addItemsEnum(key string, enum []interface{}) { p.items["#"+key] = enum p.addEnum(key, enum) } func (p enumAnalysis) addSchemaEnum(key string, enum []interface{}) { p.schemas["#"+key] = enum p.addEnum(key, enum) } // New takes a swagger spec object and returns an analyzed spec document. // The analyzed document contains a number of indices that make it easier to // reason about semantics of a swagger specification for use in code generation // or validation etc. func New(doc spec.Swagger) Spec { a := &Spec{ spec: doc, references: referenceAnalysis{}, patterns: patternAnalysis{}, enums: enumAnalysis{}, } a.reset() a.initialize() return a } // Spec is an analyzed specification object. It takes a swagger spec object and turns it into a registry // with a bunch of utility methods to act on the information in the spec. type Spec struct { spec spec.Swagger consumes map[string]struct{} produces map[string]struct{} authSchemes map[string]struct{} operations map[string]map[string]spec.Operation references referenceAnalysis patterns patternAnalysis enums enumAnalysis allSchemas map[string]SchemaRef allOfs map[string]SchemaRef } func (s Spec) reset() { s.consumes = make(map[string]struct{}, 150) s.produces = make(map[string]struct{}, 150) s.authSchemes = make(map[string]struct{}, 150) s.operations = make(map[string]map[string]spec.Operation, 150) s.allSchemas = make(map[string]SchemaRef, 150) s.allOfs = make(map[string]SchemaRef, 150) s.references.schemas = make(map[string]spec.Ref, 150) s.references.pathItems = make(map[string]spec.Ref, 150) s.references.responses = make(map[string]spec.Ref, 150) s.references.parameters = make(map[string]spec.Ref, 150) s.references.items = make(map[string]spec.Ref, 150) s.references.headerItems = make(map[string]spec.Ref, 150) s.references.parameterItems = make(map[string]spec.Ref, 150) s.references.allRefs = make(map[string]spec.Ref, 150) s.patterns.parameters = make(map[string]string, 150) s.patterns.headers = make(map[string]string, 150) s.patterns.items = make(map[string]string, 150) s.patterns.schemas = make(map[string]string, 150) s.patterns.allPatterns = make(map[string]string, 150) s.enums.parameters = make(map[string][]interface{}, 150) s.enums.headers = make(map[string][]interface{}, 150) s.enums.items = make(map[string][]interface{}, 150) s.enums.schemas = make(map[string][]interface{}, 150) s.enums.allEnums = make(map[string][]interface{}, 150) } func (s Spec) reload() { s.reset() s.initialize() } func (s Spec) initialize() { for _, c := range s.spec.Consumes { s.consumes[c] = struct{}{} } for _, c := range s.spec.Produces { s.produces[c] = struct{}{} } for _, ss := range s.spec.Security { for k := range ss { s.authSchemes[k] = struct{}{} } } for path, pathItem := range s.AllPaths() { s.analyzeOperations(path, &pathItem) //#nosec } for name, parameter := range s.spec.Parameters { refPref := slashpath.Join("/parameters", jsonpointer.Escape(name)) if parameter.Items != nil { s.analyzeItems("items", parameter.Items, refPref, "parameter") } if parameter.In == "body" && parameter.Schema != nil { s.analyzeSchema("schema", parameter.Schema, refPref) } if parameter.Pattern != "" { s.patterns.addParameterPattern(refPref, parameter.Pattern) } if len(parameter.Enum) > 0 { s.enums.addParameterEnum(refPref, parameter.Enum) } } for name, response := range s.spec.Responses { refPref := slashpath.Join("/responses", jsonpointer.Escape(name)) for k, v := range response.Headers { hRefPref := slashpath.Join(refPref, "headers", k) if v.Items != nil { s.analyzeItems("items", v.Items, hRefPref, "header") } if v.Pattern != "" { s.patterns.addHeaderPattern(hRefPref, v.Pattern) } if len(v.Enum) > 0 { s.enums.addHeaderEnum(hRefPref, v.Enum) } } if response.Schema != nil { s.analyzeSchema("schema", response.Schema, refPref) } } for name := range s.spec.Definitions { schema := s.spec.Definitions[name] s.analyzeSchema(name, &schema, "/definitions") } // TODO: after analyzing all things and flattening schemas etc // resolve all the collected references to their final representations // best put in a separate method because this could get expensive } func (s Spec) analyzeOperations(path string, pi spec.PathItem) { // TODO: resolve refs here? // Currently, operations declared via pathItem $ref are known only after expansion op := pi if pi.Ref.String() != "" { key := slashpath.Join("/paths", jsonpointer.Escape(path)) s.references.addPathItemRef(key, pi) } s.analyzeOperation("GET", path, op.Get) s.analyzeOperation("PUT", path, op.Put) s.analyzeOperation("POST", path, op.Post) s.analyzeOperation("PATCH", path, op.Patch) s.analyzeOperation("DELETE", path, op.Delete) s.analyzeOperation("HEAD", path, op.Head) s.analyzeOperation("OPTIONS", path, op.Options) for i, param := range op.Parameters { refPref := slashpath.Join("/paths", jsonpointer.Escape(path), "parameters", strconv.Itoa(i)) if param.Ref.String() != "" { s.references.addParamRef(refPref, &param) //#nosec } if param.Pattern != "" { s.patterns.addParameterPattern(refPref, param.Pattern) } if len(param.Enum) > 0 { s.enums.addParameterEnum(refPref, param.Enum) } if param.Items != nil { s.analyzeItems("items", param.Items, refPref, "parameter") } if param.Schema != nil { s.analyzeSchema("schema", param.Schema, refPref) } } } func (s Spec) analyzeItems(name string, items spec.Items, prefix, location string) { if items == nil { return } refPref := slashpath.Join(prefix, name) s.analyzeItems(name, items.Items, refPref, location) if items.Ref.String() != "" { s.references.addItemsRef(refPref, items, location) } if items.Pattern != "" { s.patterns.addItemsPattern(refPref, items.Pattern) } if len(items.Enum) > 0 { s.enums.addItemsEnum(refPref, items.Enum) } } func (s Spec) analyzeParameter(prefix string, i int, param spec.Parameter) { refPref := slashpath.Join(prefix, "parameters", strconv.Itoa(i)) if param.Ref.String() != "" { s.references.addParamRef(refPref, &param) //#nosec } if param.Pattern != "" { s.patterns.addParameterPattern(refPref, param.Pattern) } if len(param.Enum) > 0 { s.enums.addParameterEnum(refPref, param.Enum) } s.analyzeItems("items", param.Items, refPref, "parameter") if param.In == "body" && param.Schema != nil { s.analyzeSchema("schema", param.Schema, refPref) } } func (s Spec) analyzeOperation(method, path string, op spec.Operation) { if op == nil { return } for _, c := range op.Consumes { s.consumes[c] = struct{}{} } for _, c := range op.Produces { s.produces[c] = struct{}{} } for _, ss := range op.Security { for k := range ss { s.authSchemes[k] = struct{}{} } } if _, ok := s.operations[method]; !ok { s.operations[method] = make(map[string]spec.Operation) } s.operations[method][path] = op prefix := slashpath.Join("/paths", jsonpointer.Escape(path), strings.ToLower(method)) for i, param := range op.Parameters { s.analyzeParameter(prefix, i, param) } if op.Responses == nil { return } if op.Responses.Default != nil { s.analyzeDefaultResponse(prefix, op.Responses.Default) } for k, res := range op.Responses.StatusCodeResponses { s.analyzeResponse(prefix, k, res) } } func (s Spec) analyzeDefaultResponse(prefix string, res spec.Response) { refPref := slashpath.Join(prefix, "responses", "default") if res.Ref.String() != "" { s.references.addResponseRef(refPref, res) } for k, v := range res.Headers { hRefPref := slashpath.Join(refPref, "headers", k) s.analyzeItems("items", v.Items, hRefPref, "header") if v.Pattern != "" { s.patterns.addHeaderPattern(hRefPref, v.Pattern) } } if res.Schema != nil { s.analyzeSchema("schema", res.Schema, refPref) } } func (s Spec) analyzeResponse(prefix string, k int, res spec.Response) { refPref := slashpath.Join(prefix, "responses", strconv.Itoa(k)) if res.Ref.String() != "" { s.references.addResponseRef(refPref, &res) //#nosec } for k, v := range res.Headers { hRefPref := slashpath.Join(refPref, "headers", k) s.analyzeItems("items", v.Items, hRefPref, "header") if v.Pattern != "" { s.patterns.addHeaderPattern(hRefPref, v.Pattern) } if len(v.Enum) > 0 { s.enums.addHeaderEnum(hRefPref, v.Enum) } } if res.Schema != nil { s.analyzeSchema("schema", res.Schema, refPref) } } func (s Spec) analyzeSchema(name string, schema spec.Schema, prefix string) { refURI := slashpath.Join(prefix, jsonpointer.Escape(name)) schRef := SchemaRef{ Name: name, Schema: schema, Ref: spec.MustCreateRef("#" + refURI), TopLevel: prefix == "/definitions", } s.allSchemas["#"+refURI] = schRef if schema.Ref.String() != "" { s.references.addSchemaRef(refURI, schRef) } if schema.Pattern != "" { s.patterns.addSchemaPattern(refURI, schema.Pattern) } if len(schema.Enum) > 0 { s.enums.addSchemaEnum(refURI, schema.Enum) } for k, v := range schema.Definitions { v := v s.analyzeSchema(k, &v, slashpath.Join(refURI, "definitions")) } for k, v := range schema.Properties { v := v s.analyzeSchema(k, &v, slashpath.Join(refURI, "properties")) } for k, v := range schema.PatternProperties { v := v // NOTE: swagger 2.0 does not support PatternProperties. // However it is possible to analyze this in a schema s.analyzeSchema(k, &v, slashpath.Join(refURI, "patternProperties")) } for i := range schema.AllOf { v := &schema.AllOf[i] s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "allOf")) } if len(schema.AllOf) > 0 { s.allOfs["#"+refURI] = schRef } for i := range schema.AnyOf { v := &schema.AnyOf[i] // NOTE: swagger 2.0 does not support anyOf constructs. // However it is possible to analyze this in a schema s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "anyOf")) } for i := range schema.OneOf { v := &schema.OneOf[i] // NOTE: swagger 2.0 does not support oneOf constructs. // However it is possible to analyze this in a schema s.analyzeSchema(strconv.Itoa(i), v, slashpath.Join(refURI, "oneOf")) } if schema.Not != nil { // NOTE: swagger 2.0 does not support "not" constructs. // However it is possible to analyze this in a schema s.analyzeSchema("not", schema.Not, refURI) } if schema.AdditionalProperties != nil && schema.AdditionalProperties.Schema != nil { s.analyzeSchema("additionalProperties", schema.AdditionalProperties.Schema, refURI) } if schema.AdditionalItems != nil && schema.AdditionalItems.Schema != nil { // NOTE: swagger 2.0 does not support AdditionalItems. // However it is possible to analyze this in a schema s.analyzeSchema("additionalItems", schema.AdditionalItems.Schema, refURI) } if schema.Items != nil { if schema.Items.Schema != nil { s.analyzeSchema("items", schema.Items.Schema, refURI) } for i := range schema.Items.Schemas { sch := &schema.Items.Schemas[i] s.analyzeSchema(strconv.Itoa(i), sch, slashpath.Join(refURI, "items")) } } } // SecurityRequirement is a representation of a security requirement for an operation type SecurityRequirement struct { Name string Scopes []string } // SecurityRequirementsFor gets the security requirements for the operation func (s Spec) SecurityRequirementsFor(operation spec.Operation) [][]SecurityRequirement { if s.spec.Security == nil && operation.Security == nil { return nil } schemes := s.spec.Security if operation.Security != nil { schemes = operation.Security } result := [][]SecurityRequirement{} for _, scheme := range schemes { if len(scheme) == 0 { // append a zero object for anonymous result = append(result, []SecurityRequirement{{}}) continue } var reqs []SecurityRequirement for k, v := range scheme { if v == nil { v = []string{} } reqs = append(reqs, SecurityRequirement{Name: k, Scopes: v}) } result = append(result, reqs) } return result } // SecurityDefinitionsForRequirements gets the matching security definitions for a set of requirements func (s Spec) SecurityDefinitionsForRequirements(requirements []SecurityRequirement) map[string]spec.SecurityScheme { result := make(map[string]spec.SecurityScheme) for _, v := range requirements { if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { if definition != nil { result[v.Name] = definition } } } return result } // SecurityDefinitionsFor gets the matching security definitions for a set of requirements func (s Spec) SecurityDefinitionsFor(operation spec.Operation) map[string]spec.SecurityScheme { requirements := s.SecurityRequirementsFor(operation) if len(requirements) == 0 { return nil } result := make(map[string]spec.SecurityScheme) for _, reqs := range requirements { for _, v := range reqs { if v.Name == "" { // optional requirement continue } if _, ok := result[v.Name]; ok { // duplicate requirement continue } if definition, ok := s.spec.SecurityDefinitions[v.Name]; ok { if definition != nil { result[v.Name] = definition } } } } return result } // ConsumesFor gets the mediatypes for the operation func (s Spec) ConsumesFor(operation spec.Operation) []string { if len(operation.Consumes) == 0 { cons := make(map[string]struct{}, len(s.spec.Consumes)) for _, k := range s.spec.Consumes { cons[k] = struct{}{} } return s.structMapKeys(cons) } cons := make(map[string]struct{}, len(operation.Consumes)) for _, c := range operation.Consumes { cons[c] = struct{}{} } return s.structMapKeys(cons) } // ProducesFor gets the mediatypes for the operation func (s Spec) ProducesFor(operation spec.Operation) []string { if len(operation.Produces) == 0 { prod := make(map[string]struct{}, len(s.spec.Produces)) for _, k := range s.spec.Produces { prod[k] = struct{}{} } return s.structMapKeys(prod) } prod := make(map[string]struct{}, len(operation.Produces)) for _, c := range operation.Produces { prod[c] = struct{}{} } return s.structMapKeys(prod) } func mapKeyFromParam(param spec.Parameter) string { return fmt.Sprintf("%s#%s", param.In, fieldNameFromParam(param)) } func fieldNameFromParam(param spec.Parameter) string { // TODO: this should be x-go-name if nm, ok := param.Extensions.GetString("go-name"); ok { return nm } return swag.ToGoName(param.Name) } // ErrorOnParamFunc is a callback function to be invoked // whenever an error is encountered while resolving references // on parameters. // // This function takes as input the spec.Parameter which triggered the // error and the error itself. // // If the callback function returns false, the calling function should bail. // // If it returns true, the calling function should continue evaluating parameters. // A nil ErrorOnParamFunc must be evaluated as equivalent to panic(). type ErrorOnParamFunc func(spec.Parameter, error) bool func (s Spec) paramsAsMap(parameters []spec.Parameter, res map[string]spec.Parameter, callmeOnError ErrorOnParamFunc) { for _, param := range parameters { pr := param if pr.Ref.String() == "" { res[mapKeyFromParam(&pr)] = pr continue } // resolve $ref if callmeOnError == nil { callmeOnError = func(_ spec.Parameter, err error) bool { panic(err) } } obj, _, err := pr.Ref.GetPointer().Get(s.spec) if err != nil { if callmeOnError(param, fmt.Errorf("invalid reference: %q", pr.Ref.String())) { continue } break } objAsParam, ok := obj.(spec.Parameter) if !ok { if callmeOnError(param, fmt.Errorf("resolved reference is not a parameter: %q", pr.Ref.String())) { continue } break } pr = objAsParam res[mapKeyFromParam(&pr)] = pr } } // ParametersFor the specified operation id. // // Assumes parameters properly resolve references if any and that // such references actually resolve to a parameter object. // Otherwise, panics. func (s Spec) ParametersFor(operationID string) []spec.Parameter { return s.SafeParametersFor(operationID, nil) } // SafeParametersFor the specified operation id. // // Does not assume parameters properly resolve references or that // such references actually resolve to a parameter object. // // Upon error, invoke a ErrorOnParamFunc callback with the erroneous // parameters. If the callback is set to nil, panics upon errors. func (s Spec) SafeParametersFor(operationID string, callmeOnError ErrorOnParamFunc) []spec.Parameter { gatherParams := func(pi spec.PathItem, op spec.Operation) []spec.Parameter { bag := make(map[string]spec.Parameter) s.paramsAsMap(pi.Parameters, bag, callmeOnError) s.paramsAsMap(op.Parameters, bag, callmeOnError) var res []spec.Parameter for _, v := range bag { res = append(res, v) } return res } for _, pi := range s.spec.Paths.Paths { if pi.Get != nil && pi.Get.ID == operationID { return gatherParams(&pi, pi.Get) //#nosec } if pi.Head != nil && pi.Head.ID == operationID { return gatherParams(&pi, pi.Head) //#nosec } if pi.Options != nil && pi.Options.ID == operationID { return gatherParams(&pi, pi.Options) //#nosec } if pi.Post != nil && pi.Post.ID == operationID { return gatherParams(&pi, pi.Post) //#nosec } if pi.Patch != nil && pi.Patch.ID == operationID { return gatherParams(&pi, pi.Patch) //#nosec } if pi.Put != nil && pi.Put.ID == operationID { return gatherParams(&pi, pi.Put) //#nosec } if pi.Delete != nil && pi.Delete.ID == operationID { return gatherParams(&pi, pi.Delete) //#nosec } } return nil } // ParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that // apply for the method and path. // // Assumes parameters properly resolve references if any and that // such references actually resolve to a parameter object. // Otherwise, panics. func (s Spec) ParamsFor(method, path string) map[string]spec.Parameter { return s.SafeParamsFor(method, path, nil) } // SafeParamsFor the specified method and path. Aggregates them with the defaults etc, so it's all the params that // apply for the method and path. // // Does not assume parameters properly resolve references or that // such references actually resolve to a parameter object. // // Upon error, invoke a ErrorOnParamFunc callback with the erroneous // parameters. If the callback is set to nil, panics upon errors. func (s Spec) SafeParamsFor(method, path string, callmeOnError ErrorOnParamFunc) map[string]spec.Parameter { res := make(map[string]spec.Parameter) if pi, ok := s.spec.Paths.Paths[path]; ok { s.paramsAsMap(pi.Parameters, res, callmeOnError) s.paramsAsMap(s.operations[strings.ToUpper(method)][path].Parameters, res, callmeOnError) } return res } // OperationForName gets the operation for the given id func (s Spec) OperationForName(operationID string) (string, string, spec.Operation, bool) { for method, pathItem := range s.operations { for path, op := range pathItem { if operationID == op.ID { return method, path, op, true } } } return "", "", nil, false } // OperationFor the given method and path func (s Spec) OperationFor(method, path string) (spec.Operation, bool) { if mp, ok := s.operations[strings.ToUpper(method)]; ok { op, fn := mp[path] return op, fn } return nil, false } // Operations gathers all the operations specified in the spec document func (s Spec) Operations() map[string]map[string]spec.Operation { return s.operations } func (s Spec) structMapKeys(mp map[string]struct{}) []string { if len(mp) == 0 { return nil } result := make([]string, 0, len(mp)) for k := range mp { result = append(result, k) } return result } // AllPaths returns all the paths in the swagger spec func (s Spec) AllPaths() map[string]spec.PathItem { if s.spec == nil \|\| s.spec.Paths == nil { return nil } return s.spec.Paths.Paths } // OperationIDs gets all the operation ids based on method an dpath func (s Spec) OperationIDs() []string { if len(s.operations) == 0 { return nil } result := make([]string, 0, len(s.operations)) for method, v := range s.operations { for p, o := range v { if o.ID != "" { result = append(result, o.ID) } else { result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) } } } return result } // OperationMethodPaths gets all the operation ids based on method an dpath func (s Spec) OperationMethodPaths() []string { if len(s.operations) == 0 { return nil } result := make([]string, 0, len(s.operations)) for method, v := range s.operations { for p := range v { result = append(result, fmt.Sprintf("%s %s", strings.ToUpper(method), p)) } } return result } // RequiredConsumes gets all the distinct consumes that are specified in the specification document func (s Spec) RequiredConsumes() []string { return s.structMapKeys(s.consumes) } // RequiredProduces gets all the distinct produces that are specified in the specification document func (s Spec) RequiredProduces() []string { return s.structMapKeys(s.produces) } // RequiredSecuritySchemes gets all the distinct security schemes that are specified in the swagger spec func (s Spec) RequiredSecuritySchemes() []string { return s.structMapKeys(s.authSchemes) } // SchemaRef is a reference to a schema type SchemaRef struct { Name string Ref spec.Ref Schema spec.Schema TopLevel bool } // SchemasWithAllOf returns schema references to all schemas that are defined // with an allOf key func (s Spec) SchemasWithAllOf() (result []SchemaRef) { for _, v := range s.allOfs { result = append(result, v) } return } // AllDefinitions returns schema references for all the definitions that were discovered func (s Spec) AllDefinitions() (result []SchemaRef) { for _, v := range s.allSchemas { result = append(result, v) } return } // AllDefinitionReferences returns json refs for all the discovered schemas func (s Spec) AllDefinitionReferences() (result []string) { for _, v := range s.references.schemas { result = append(result, v.String()) } return } // AllParameterReferences returns json refs for all the discovered parameters func (s Spec) AllParameterReferences() (result []string) { for _, v := range s.references.parameters { result = append(result, v.String()) } return } // AllResponseReferences returns json refs for all the discovered responses func (s Spec) AllResponseReferences() (result []string) { for _, v := range s.references.responses { result = append(result, v.String()) } return } // AllPathItemReferences returns the references for all the items func (s Spec) AllPathItemReferences() (result []string) { for _, v := range s.references.pathItems { result = append(result, v.String()) } return } // AllItemsReferences returns the references for all the items in simple schemas (parameters or headers). // // NOTE: since Swagger 2.0 forbids $ref in simple params, this should always yield an empty slice for a valid // Swagger 2.0 spec. func (s Spec) AllItemsReferences() (result []string) { for _, v := range s.references.items { result = append(result, v.String()) } return } // AllReferences returns all the references found in the document, with possible duplicates func (s Spec) AllReferences() (result []string) { for _, v := range s.references.allRefs { result = append(result, v.String()) } return } // AllRefs returns all the unique references found in the document func (s Spec) AllRefs() (result []spec.Ref) { set := make(map[string]struct{}) for _, v := range s.references.allRefs { a := v.String() if a == "" { continue } if _, ok := set[a]; !ok { set[a] = struct{}{} result = append(result, v) } } return } func cloneStringMap(source map[string]string) map[string]string { res := make(map[string]string, len(source)) for k, v := range source { res[k] = v } return res } func cloneEnumMap(source map[string][]interface{}) map[string][]interface{} { res := make(map[string][]interface{}, len(source)) for k, v := range source { res[k] = v } return res } // ParameterPatterns returns all the patterns found in parameters // the map is cloned to avoid accidental changes func (s Spec) ParameterPatterns() map[string]string { return cloneStringMap(s.patterns.parameters) } // HeaderPatterns returns all the patterns found in response headers // the map is cloned to avoid accidental changes func (s Spec) HeaderPatterns() map[string]string { return cloneStringMap(s.patterns.headers) } // ItemsPatterns returns all the patterns found in simple array items // the map is cloned to avoid accidental changes func (s Spec) ItemsPatterns() map[string]string { return cloneStringMap(s.patterns.items) } // SchemaPatterns returns all the patterns found in schemas // the map is cloned to avoid accidental changes func (s Spec) SchemaPatterns() map[string]string { return cloneStringMap(s.patterns.schemas) } // AllPatterns returns all the patterns found in the spec // the map is cloned to avoid accidental changes func (s Spec) AllPatterns() map[string]string { return cloneStringMap(s.patterns.allPatterns) } // ParameterEnums returns all the enums found in parameters // the map is cloned to avoid accidental changes func (s Spec) ParameterEnums() map[string][]interface{} { return cloneEnumMap(s.enums.parameters) } // HeaderEnums returns all the enums found in response headers // the map is cloned to avoid accidental changes func (s Spec) HeaderEnums() map[string][]interface{} { return cloneEnumMap(s.enums.headers) } // ItemsEnums returns all the enums found in simple array items // the map is cloned to avoid accidental changes func (s Spec) ItemsEnums() map[string][]interface{} { return cloneEnumMap(s.enums.items) } // SchemaEnums returns all the enums found in schemas // the map is cloned to avoid accidental changes func (s Spec) SchemaEnums() map[string][]interface{} { return cloneEnumMap(s.enums.schemas) } // AllEnums returns all the enums found in the spec // the map is cloned to avoid accidental changes func (s Spec) AllEnums() map[string][]interface{} { return cloneEnumMap(s.enums.allEnums) }	29.28 KB	2025-05-25 12:27
📄 analyzer_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "fmt" "path/filepath" "sort" "strconv" "testing" "github.com/go-openapi/analysis/internal/antest" "github.com/go-openapi/spec" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const ( someOperation = "someOperation" anotherOperation = "anotherOperation" ) func TestAnalyzer_All(t testing.T) { t.Parallel() formatParam := spec.QueryParam("format").Typed("string", "") limitParam := spec.QueryParam("limit").Typed("integer", "int32") limitParam.Extensions = spec.Extensions(map[string]interface{}{}) limitParam.Extensions.Add("go-name", "Limit") skipParam := spec.QueryParam("skip").Typed("integer", "int32") pi := spec.PathItem{} pi.Parameters = []spec.Parameter{limitParam} op := &spec.Operation{} op.Consumes = []string{"application/x-yaml"} op.Produces = []string{"application/x-yaml"} op.Security = []map[string][]string{ {"oauth2": {}}, {"basic": nil}, } op.ID = someOperation op.Parameters = []spec.Parameter{skipParam} pi.Get = op pi2 := spec.PathItem{} pi2.Parameters = []spec.Parameter{limitParam} op2 := &spec.Operation{} op2.ID = anotherOperation op2.Parameters = []spec.Parameter{skipParam} pi2.Get = op2 spec := makeFixturepec(pi, pi2, formatParam) analyzer := New(spec) assert.Len(t, analyzer.consumes, 2) assert.Len(t, analyzer.produces, 2) assert.Len(t, analyzer.operations, 1) assert.Equal(t, analyzer.operations["GET"]["/"], spec.Paths.Paths["/"].Get) expected := []string{"application/x-yaml"} sort.Strings(expected) consumes := analyzer.ConsumesFor(spec.Paths.Paths["/"].Get) sort.Strings(consumes) assert.Equal(t, expected, consumes) produces := analyzer.ProducesFor(spec.Paths.Paths["/"].Get) sort.Strings(produces) assert.Equal(t, expected, produces) expected = []string{"application/json"} sort.Strings(expected) consumes = analyzer.ConsumesFor(spec.Paths.Paths["/items"].Get) sort.Strings(consumes) assert.Equal(t, expected, consumes) produces = analyzer.ProducesFor(spec.Paths.Paths["/items"].Get) sort.Strings(produces) assert.Equal(t, expected, produces) expectedSchemes := [][]SecurityRequirement{ { {Name: "oauth2", Scopes: []string{}}, {Name: "basic", Scopes: nil}, }, } schemes := analyzer.SecurityRequirementsFor(spec.Paths.Paths["/"].Get) assert.Equal(t, schemeNames(expectedSchemes), schemeNames(schemes)) securityDefinitions := analyzer.SecurityDefinitionsFor(spec.Paths.Paths["/"].Get) assert.Equal(t, spec.SecurityDefinitions["basic"], securityDefinitions["basic"]) assert.Equal(t, spec.SecurityDefinitions["oauth2"], securityDefinitions["oauth2"]) parameters := analyzer.ParamsFor("GET", "/") assert.Len(t, parameters, 2) operations := analyzer.OperationIDs() assert.Len(t, operations, 2) producers := analyzer.RequiredProduces() assert.Len(t, producers, 2) consumers := analyzer.RequiredConsumes() assert.Len(t, consumers, 2) authSchemes := analyzer.RequiredSecuritySchemes() assert.Len(t, authSchemes, 3) ops := analyzer.Operations() assert.Len(t, ops, 1) assert.Len(t, ops["GET"], 2) op, ok := analyzer.OperationFor("get", "/") assert.True(t, ok) assert.NotNil(t, op) op, ok = analyzer.OperationFor("delete", "/") assert.False(t, ok) assert.Nil(t, op) // check for duplicates in sec. requirements for operation pi.Get.Security = []map[string][]string{ {"oauth2": {}}, {"basic": nil}, {"basic": nil}, } spec = makeFixturepec(pi, pi2, formatParam) analyzer = New(spec) securityDefinitions = analyzer.SecurityDefinitionsFor(spec.Paths.Paths["/"].Get) assert.Len(t, securityDefinitions, 2) assert.Equal(t, spec.SecurityDefinitions["basic"], securityDefinitions["basic"]) assert.Equal(t, spec.SecurityDefinitions["oauth2"], securityDefinitions["oauth2"]) // check for empty (optional) in sec. requirements for operation pi.Get.Security = []map[string][]string{ {"oauth2": {}}, {"": nil}, {"basic": nil}, } spec = makeFixturepec(pi, pi2, formatParam) analyzer = New(spec) securityDefinitions = analyzer.SecurityDefinitionsFor(spec.Paths.Paths["/"].Get) assert.Len(t, securityDefinitions, 2) assert.Equal(t, spec.SecurityDefinitions["basic"], securityDefinitions["basic"]) assert.Equal(t, spec.SecurityDefinitions["oauth2"], securityDefinitions["oauth2"]) } func TestAnalyzer_DefinitionAnalysis(t testing.T) { t.Parallel() doc := antest.LoadOrFail(t, filepath.Join("fixtures", "definitions.yml")) analyzer := New(doc) definitions := analyzer.allSchemas require.NotNil(t, definitions) for _, toPin := range []string{ "#/parameters/someParam/schema", "#/paths/~1some~1where~1{id}/parameters/1/schema", "#/paths/~1some~1where~1{id}/get/parameters/1/schema", // responses "#/responses/someResponse/schema", "#/paths/~1some~1where~1{id}/get/responses/default/schema", "#/paths/~1some~1where~1{id}/get/responses/200/schema", // definitions "#/definitions/tag", "#/definitions/tag/properties/id", "#/definitions/tag/properties/value", "#/definitions/tag/definitions/category", "#/definitions/tag/definitions/category/properties/id", "#/definitions/tag/definitions/category/properties/value", "#/definitions/withAdditionalProps", "#/definitions/withAdditionalProps/additionalProperties", "#/definitions/withAdditionalItems", "#/definitions/withAdditionalItems/items/0", "#/definitions/withAdditionalItems/items/1", "#/definitions/withAdditionalItems/additionalItems", "#/definitions/withNot", "#/definitions/withNot/not", "#/definitions/withAnyOf", "#/definitions/withAnyOf/anyOf/0", "#/definitions/withAnyOf/anyOf/1", "#/definitions/withAllOf", "#/definitions/withAllOf/allOf/0", "#/definitions/withAllOf/allOf/1", "#/definitions/withOneOf/oneOf/0", "#/definitions/withOneOf/oneOf/1", } { key := toPin t.Run(fmt.Sprintf("ref %q exists", key), func(t testing.T) { t.Parallel() assertSchemaRefExists(t, definitions, key) }) } allOfs := analyzer.allOfs assert.Len(t, allOfs, 1) assert.Contains(t, allOfs, "#/definitions/withAllOf") } func TestAnalyzer_ReferenceAnalysis(t testing.T) { t.Parallel() doc := antest.LoadOrFail(t, filepath.Join("fixtures", "references.yml")) an := New(doc) definitions := an.references require.NotNil(t, definitions) require.NotNil(t, definitions.parameters) require.NotNil(t, definitions.responses) require.NotNil(t, definitions.pathItems) require.NotNil(t, definitions.schemas) require.NotNil(t, definitions.parameterItems) require.NotNil(t, definitions.headerItems) require.NotNil(t, definitions.allRefs) for _, fixture := range []struct { Input map[string]spec.Ref ExpectedKeys []string }{ { Input: definitions.parameters, ExpectedKeys: []string{ "#/paths/~1some~1where~1{id}/parameters/0", "#/paths/~1some~1where~1{id}/get/parameters/0", }, }, { Input: definitions.pathItems, ExpectedKeys: []string{ "#/paths/~1other~1place", }, }, { Input: definitions.responses, ExpectedKeys: []string{ "#/paths/~1some~1where~1{id}/get/responses/404", }, }, { Input: definitions.schemas, ExpectedKeys: []string{ "#/responses/notFound/schema", "#/paths/~1some~1where~1{id}/get/responses/200/schema", "#/definitions/tag/properties/audit", }, }, { // Supported non-swagger 2.0 constructs ($ref in simple schema items) Input: definitions.allRefs, ExpectedKeys: []string{ "#/paths/~1some~1where~1{id}/get/parameters/1/items", "#/paths/~1some~1where~1{id}/get/parameters/2/items", "#/paths/~1some~1where~1{id}/get/responses/default/headers/x-array-header/items", }, }, { Input: definitions.parameterItems, ExpectedKeys: []string{ "#/paths/~1some~1where~1{id}/get/parameters/1/items", "#/paths/~1some~1where~1{id}/get/parameters/2/items", }, }, { Input: definitions.headerItems, ExpectedKeys: []string{ "#/paths/~1some~1where~1{id}/get/responses/default/headers/x-array-header/items", }, }, } { input := fixture.Input for _, toPin := range fixture.ExpectedKeys { key := toPin t.Run(fmt.Sprintf("ref %q exists", key), func(t testing.T) { t.Parallel() assertRefExists(t, input, key) }) } } assert.Lenf(t, an.AllItemsReferences(), 3, "Expected 3 items references in this spec") } type expectedPattern struct { Key string Pattern string } func TestAnalyzer_PatternAnalysis(t testing.T) { t.Parallel() doc := antest.LoadOrFail(t, filepath.Join("fixtures", "patterns.yml")) an := New(doc) pt := an.patterns require.NotNil(t, pt) require.NotNil(t, pt.parameters) require.NotNil(t, pt.headers) require.NotNil(t, pt.schemas) require.NotNil(t, pt.items) for _, toPin := range []struct { Input map[string]string ExpectedKeys []expectedPattern }{ { Input: pt.parameters, ExpectedKeys: []expectedPattern{ {Key: "#/parameters/idParam", Pattern: "a[A-Za-Z0-9]+"}, {Key: "#/paths/~1some~1where~1{id}/parameters/1", Pattern: "b[A-Za-z0-9]+"}, {Key: "#/paths/~1some~1where~1{id}/get/parameters/0", Pattern: "[abc][0-9]+"}, }, }, { Input: pt.headers, ExpectedKeys: []expectedPattern{ {Key: "#/responses/notFound/headers/ContentLength", Pattern: "[0-9]+"}, {Key: "#/paths/~1some~1where~1{id}/get/responses/200/headers/X-Request-Id", Pattern: "d[A-Za-z0-9]+"}, }, }, { Input: pt.schemas, ExpectedKeys: []expectedPattern{ {Key: "#/paths/~1other~1place/post/parameters/0/schema/properties/value", Pattern: "e[A-Za-z0-9]+"}, {Key: "#/paths/~1other~1place/post/responses/200/schema/properties/data", Pattern: "[0-9]+[abd]"}, {Key: "#/definitions/named", Pattern: "f[A-Za-z0-9]+"}, {Key: "#/definitions/tag/properties/value", Pattern: "g[A-Za-z0-9]+"}, }, }, { Input: pt.items, ExpectedKeys: []expectedPattern{ {Key: "#/paths/~1some~1where~1{id}/get/parameters/1/items", Pattern: "c[A-Za-z0-9]+"}, {Key: "#/paths/~1other~1place/post/responses/default/headers/Via/items", Pattern: "[A-Za-z]+"}, }, }, } { fixture := toPin for _, toPinExpected := range fixture.ExpectedKeys { expected := toPinExpected t.Run(fmt.Sprintf("pattern at %q exists", expected.Key), func(t testing.T) { t.Parallel() assertPattern(t, fixture.Input, expected.Key, expected.Pattern) }) } } // patternProperties (beyond Swagger 2.0) _, ok := an.spec.Definitions["withPatternProperties"] assert.True(t, ok) _, ok = an.allSchemas["#/definitions/withPatternProperties/patternProperties/^prop[0-9]+$"] assert.True(t, ok) } func TestAnalyzer_ParamsAsMap(t testing.T) { t.Parallel() s := prepareTestParamsValid() require.NotNil(t, s) m := make(map[string]spec.Parameter) pi, ok := s.spec.Paths.Paths["/items"] require.True(t, ok) s.paramsAsMap(pi.Parameters, m, nil) assert.Len(t, m, 1) p, ok := m["query#Limit"] require.True(t, ok) assert.Equal(t, "limit", p.Name) // An invalid spec, but passes this step (errors are figured out at a higher level) s = prepareTestParamsInvalid(t, "fixture-1289-param.yaml") require.NotNil(t, s) m = make(map[string]spec.Parameter) pi, ok = s.spec.Paths.Paths["/fixture"] require.True(t, ok) pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.paramsAsMap(pi.Parameters, m, nil) assert.Len(t, m, 1) p, ok = m["body#DespicableMe"] require.True(t, ok) assert.Equal(t, "despicableMe", p.Name) } func TestAnalyzer_ParamsAsMapWithCallback(t testing.T) { t.Parallel() s := prepareTestParamsInvalid(t, "fixture-342.yaml") require.NotNil(t, s) // No bail out callback m := make(map[string]spec.Parameter) e := []string{} pi, ok := s.spec.Paths.Paths["/fixture"] require.True(t, ok) pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.paramsAsMap(pi.Parameters, m, func(_ spec.Parameter, err error) bool { e = append(e, err.Error()) return true // Continue }) assert.Contains(t, e, `resolved reference is not a parameter: "#/definitions/sample_info/properties/sid"`) assert.Contains(t, e, `invalid reference: "#/definitions/sample_info/properties/sids"`) // bail out callback m = make(map[string]spec.Parameter) e = []string{} pi, ok = s.spec.Paths.Paths["/fixture"] require.True(t, ok) pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.paramsAsMap(pi.Parameters, m, func(_ spec.Parameter, err error) bool { e = append(e, err.Error()) return false // Bail }) // We got one then bail assert.Len(t, e, 1) // Bail after ref failure: exercising another path s = prepareTestParamsInvalid(t, "fixture-342-2.yaml") require.NotNil(t, s) // bail callback m = make(map[string]spec.Parameter) e = []string{} pi, ok = s.spec.Paths.Paths["/fixture"] require.True(t, ok) pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.paramsAsMap(pi.Parameters, m, func(_ spec.Parameter, err error) bool { e = append(e, err.Error()) return false // Bail }) // We got one then bail assert.Len(t, e, 1) // Bail after ref failure: exercising another path s = prepareTestParamsInvalid(t, "fixture-342-3.yaml") require.NotNil(t, s) // bail callback m = make(map[string]spec.Parameter) e = []string{} pi, ok = s.spec.Paths.Paths["/fixture"] require.True(t, ok) pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.paramsAsMap(pi.Parameters, m, func(_ spec.Parameter, err error) bool { e = append(e, err.Error()) return false // Bail }) // We got one then bail assert.Len(t, e, 1) } func TestAnalyzer_ParamsAsMapPanic(t testing.T) { t.Parallel() for _, toPin := range []string{ "fixture-342.yaml", "fixture-342-2.yaml", "fixture-342-3.yaml", } { fixture := toPin t.Run("panic_"+fixture, func(t testing.T) { t.Parallel() s := prepareTestParamsInvalid(t, fixture) require.NotNil(t, s) panickerParamsAsMap := func() { m := make(map[string]spec.Parameter) if pi, ok := s.spec.Paths.Paths["/fixture"]; ok { pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.paramsAsMap(pi.Parameters, m, nil) } } assert.Panics(t, panickerParamsAsMap) }) } } func TestAnalyzer_SafeParamsFor(t testing.T) { t.Parallel() s := prepareTestParamsInvalid(t, "fixture-342.yaml") require.NotNil(t, s) e := []string{} pi, ok := s.spec.Paths.Paths["/fixture"] require.True(t, ok) pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters errFunc := func(_ spec.Parameter, err error) bool { e = append(e, err.Error()) return true // Continue } for range s.SafeParamsFor("Get", "/fixture", errFunc) { require.Fail(t, "There should be no safe parameter in this testcase") } assert.Contains(t, e, `resolved reference is not a parameter: "#/definitions/sample_info/properties/sid"`) assert.Contains(t, e, `invalid reference: "#/definitions/sample_info/properties/sids"`) } func TestAnalyzer_ParamsFor(t testing.T) { t.Parallel() // Valid example s := prepareTestParamsValid() require.NotNil(t, s) params := s.ParamsFor("Get", "/items") assert.NotEmpty(t, params) panickerParamsFor := func() { s := prepareTestParamsInvalid(t, "fixture-342.yaml") pi, ok := s.spec.Paths.Paths["/fixture"] if ok { pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters s.ParamsFor("Get", "/fixture") } } // Invalid example assert.Panics(t, panickerParamsFor) } func TestAnalyzer_SafeParametersFor(t testing.T) { t.Parallel() s := prepareTestParamsInvalid(t, "fixture-342.yaml") require.NotNil(t, s) e := []string{} pi, ok := s.spec.Paths.Paths["/fixture"] require.True(t, ok) errFunc := func(_ spec.Parameter, err error) bool { e = append(e, err.Error()) return true // Continue } pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters for range s.SafeParametersFor("fixtureOp", errFunc) { require.Fail(t, "There should be no safe parameter in this testcase") } assert.Contains(t, e, `resolved reference is not a parameter: "#/definitions/sample_info/properties/sid"`) assert.Contains(t, e, `invalid reference: "#/definitions/sample_info/properties/sids"`) } func TestAnalyzer_ParametersFor(t testing.T) { t.Parallel() // Valid example s := prepareTestParamsValid() params := s.ParamsFor("Get", "/items") assert.NotEmpty(t, params) panickerParametersFor := func() { s := prepareTestParamsInvalid(t, "fixture-342.yaml") if s == nil { return } pi, ok := s.spec.Paths.Paths["/fixture"] if ok { pi.Parameters = pi.PathItemProps.Get.OperationProps.Parameters // func (s Spec) ParametersFor(operationID string) []spec.Parameter { s.ParametersFor("fixtureOp") } } // Invalid example assert.Panics(t, panickerParametersFor) } func TestAnalyzer_SecurityDefinitionsFor(t testing.T) { t.Parallel() spec := prepareTestParamsAuth() pi1 := spec.spec.Paths.Paths["/"].Get pi2 := spec.spec.Paths.Paths["/items"].Get defs1 := spec.SecurityDefinitionsFor(pi1) require.Contains(t, defs1, "oauth2") require.Contains(t, defs1, "basic") require.NotContains(t, defs1, "apiKey") defs2 := spec.SecurityDefinitionsFor(pi2) require.Contains(t, defs2, "oauth2") require.Contains(t, defs2, "basic") require.Contains(t, defs2, "apiKey") } func TestAnalyzer_SecurityRequirements(t testing.T) { t.Parallel() spec := prepareTestParamsAuth() pi1 := spec.spec.Paths.Paths["/"].Get pi2 := spec.spec.Paths.Paths["/items"].Get scopes := []string{"the-scope"} reqs1 := spec.SecurityRequirementsFor(pi1) require.Len(t, reqs1, 2) require.Len(t, reqs1[0], 1) require.Equal(t, "oauth2", reqs1[0][0].Name) require.Equal(t, reqs1[0][0].Scopes, scopes) require.Len(t, reqs1[1], 1) require.Equal(t, "basic", reqs1[1][0].Name) require.Empty(t, reqs1[1][0].Scopes) reqs2 := spec.SecurityRequirementsFor(pi2) require.Len(t, reqs2, 3) require.Len(t, reqs2[0], 1) require.Equal(t, "oauth2", reqs2[0][0].Name) require.Equal(t, scopes, reqs2[0][0].Scopes) require.Len(t, reqs2[1], 1) require.Empty(t, reqs2[1][0].Name) require.Empty(t, reqs2[1][0].Scopes) require.Len(t, reqs2[2], 2) require.Contains(t, reqs2[2], SecurityRequirement{Name: "basic", Scopes: []string{}}) require.Empty(t, reqs2[2][0].Scopes) require.Contains(t, reqs2[2], SecurityRequirement{Name: "apiKey", Scopes: []string{}}) require.Empty(t, reqs2[2][1].Scopes) } func TestAnalyzer_SecurityRequirementsDefinitions(t testing.T) { t.Parallel() spec := prepareTestParamsAuth() pi1 := spec.spec.Paths.Paths["/"].Get pi2 := spec.spec.Paths.Paths["/items"].Get reqs1 := spec.SecurityRequirementsFor(pi1) defs11 := spec.SecurityDefinitionsForRequirements(reqs1[0]) require.Contains(t, defs11, "oauth2") defs12 := spec.SecurityDefinitionsForRequirements(reqs1[1]) require.Contains(t, defs12, "basic") require.NotContains(t, defs12, "apiKey") reqs2 := spec.SecurityRequirementsFor(pi2) defs21 := spec.SecurityDefinitionsForRequirements(reqs2[0]) require.Len(t, defs21, 1) require.Contains(t, defs21, "oauth2") require.NotContains(t, defs21, "basic") require.NotContains(t, defs21, "apiKey") defs22 := spec.SecurityDefinitionsForRequirements(reqs2[1]) require.NotNil(t, defs22) require.Empty(t, defs22) defs23 := spec.SecurityDefinitionsForRequirements(reqs2[2]) require.Len(t, defs23, 2) require.NotContains(t, defs23, "oauth2") require.Contains(t, defs23, "basic") require.Contains(t, defs23, "apiKey") } func TestAnalyzer_MoreParamAnalysis(t testing.T) { t.Parallel() bp := filepath.Join("fixtures", "parameters", "fixture-parameters.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) res := an.AllPatterns() assert.Lenf(t, res, 6, "Expected 6 patterns in this spec") res = an.SchemaPatterns() assert.Lenf(t, res, 1, "Expected 1 schema pattern in this spec") res = an.HeaderPatterns() assert.Lenf(t, res, 2, "Expected 2 header pattern in this spec") res = an.ItemsPatterns() assert.Lenf(t, res, 2, "Expected 2 items pattern in this spec") res = an.ParameterPatterns() assert.Lenf(t, res, 1, "Expected 1 simple param pattern in this spec") refs := an.AllRefs() assert.Lenf(t, refs, 10, "Expected 10 reference usage in this spec") references := an.AllReferences() assert.Lenf(t, references, 14, "Expected 14 reference usage in this spec") references = an.AllItemsReferences() assert.Emptyf(t, references, "Expected 0 items reference in this spec") references = an.AllPathItemReferences() assert.Lenf(t, references, 1, "Expected 1 pathItem reference in this spec") references = an.AllResponseReferences() assert.Lenf(t, references, 3, "Expected 3 response references in this spec") references = an.AllParameterReferences() assert.Lenf(t, references, 6, "Expected 6 parameter references in this spec") schemaRefs := an.AllDefinitions() assert.Lenf(t, schemaRefs, 14, "Expected 14 schema definitions in this spec") schemaRefs = an.SchemasWithAllOf() assert.Lenf(t, schemaRefs, 1, "Expected 1 schema with AllOf definition in this spec") method, path, op, found := an.OperationForName("postSomeWhere") assert.Equal(t, "POST", method) assert.Equal(t, "/some/where", path) require.NotNil(t, op) require.True(t, found) sec := an.SecurityRequirementsFor(op) assert.Nil(t, sec) secScheme := an.SecurityDefinitionsFor(op) assert.Nil(t, secScheme) bag := an.ParametersFor("postSomeWhere") assert.Lenf(t, bag, 6, "Expected 6 parameters for this operation") method, path, op, found = an.OperationForName("notFound") assert.Equal(t, "", method) assert.Equal(t, "", path) assert.Nil(t, op) assert.False(t, found) // does not take ops under pathItem $ref ops := an.OperationMethodPaths() assert.Lenf(t, ops, 3, "Expected 3 ops") ops = an.OperationIDs() assert.Lenf(t, ops, 3, "Expected 3 ops") assert.Contains(t, ops, "postSomeWhere") assert.Contains(t, ops, "GET /some/where/else") assert.Contains(t, ops, "GET /some/where") } func TestAnalyzer_EdgeCases(t testing.T) { t.Parallel() // check return values are consistent in some nil/empty edge cases sp := Spec{} res1 := sp.AllPaths() assert.Nil(t, res1) res2 := sp.OperationIDs() assert.Nil(t, res2) res3 := sp.OperationMethodPaths() assert.Nil(t, res3) res4 := sp.structMapKeys(nil) assert.Nil(t, res4) res5 := sp.structMapKeys(make(map[string]struct{}, 10)) assert.Nil(t, res5) // check AllRefs() skips empty $refs sp.references.allRefs = make(map[string]spec.Ref, 3) for i := 0; i < 3; i++ { sp.references.allRefs["ref"+strconv.Itoa(i)] = spec.Ref{} } assert.Len(t, sp.references.allRefs, 3) res6 := sp.AllRefs() assert.Empty(t, res6) // check AllRefs() skips duplicate $refs sp.references.allRefs["refToOne"] = spec.MustCreateRef("#/ref1") sp.references.allRefs["refToOneAgain"] = spec.MustCreateRef("#/ref1") res7 := sp.AllRefs() assert.NotNil(t, res7) assert.Len(t, res7, 1) } func TestAnalyzer_EnumAnalysis(t testing.T) { t.Parallel() doc := antest.LoadOrFail(t, filepath.Join("fixtures", "enums.yml")) an := New(doc) en := an.enums // parameters assertEnum(t, en.parameters, "#/parameters/idParam", []interface{}{"aA", "b9", "c3"}) assertEnum(t, en.parameters, "#/paths/~1some~1where~1{id}/parameters/1", []interface{}{"bA", "ba", "b9"}) assertEnum(t, en.parameters, "#/paths/~1some~1where~1{id}/get/parameters/0", []interface{}{"a0", "b1", "c2"}) // responses assertEnum(t, en.headers, "#/responses/notFound/headers/ContentLength", []interface{}{"1234", "123"}) assertEnum(t, en.headers, "#/paths/~1some~1where~1{id}/get/responses/200/headers/X-Request-Id", []interface{}{"dA", "d9"}) // definitions assertEnum(t, en.schemas, "#/paths/~1other~1place/post/parameters/0/schema/properties/value", []interface{}{"eA", "e9"}) assertEnum(t, en.schemas, "#/paths/~1other~1place/post/responses/200/schema/properties/data", []interface{}{"123a", "123b", "123d"}) assertEnum(t, en.schemas, "#/definitions/named", []interface{}{"fA", "f9"}) assertEnum(t, en.schemas, "#/definitions/tag/properties/value", []interface{}{"gA", "ga", "g9"}) assertEnum(t, en.schemas, "#/definitions/record", []interface{}{`{"createdAt": "2018-08-31"}`, `{"createdAt": "2018-09-30"}`}) // array enum assertEnum(t, en.parameters, "#/paths/~1some~1where~1{id}/get/parameters/1", []interface{}{[]interface{}{"cA", "cz", "c9"}, []interface{}{"cA", "cz"}, []interface{}{"cz", "c9"}}) // items assertEnum(t, en.items, "#/paths/~1some~1where~1{id}/get/parameters/1/items", []interface{}{"cA", "cz", "c9"}) assertEnum(t, en.items, "#/paths/~1other~1place/post/responses/default/headers/Via/items", []interface{}{"AA", "Ab"}) res := an.AllEnums() assert.Lenf(t, res, 14, "Expected 14 enums in this spec, but got %d", len(res)) res = an.ParameterEnums() assert.Lenf(t, res, 4, "Expected 4 enums in this spec, but got %d", len(res)) res = an.SchemaEnums() assert.Lenf(t, res, 6, "Expected 6 schema enums in this spec, but got %d", len(res)) res = an.HeaderEnums() assert.Lenf(t, res, 2, "Expected 2 header enums in this spec, but got %d", len(res)) res = an.ItemsEnums() assert.Lenf(t, res, 2, "Expected 2 items enums in this spec, but got %d", len(res)) } /* helpers for the Analyzer test suite / func schemeNames(schemes [][]SecurityRequirement) []string { var names []string for _, scheme := range schemes { for _, v := range scheme { names = append(names, v.Name) } } sort.Strings(names) return names } func makeFixturepec(pi, pi2 spec.PathItem, formatParam spec.Parameter) spec.Swagger { return &spec.Swagger{ SwaggerProps: spec.SwaggerProps{ Consumes: []string{"application/json"}, Produces: []string{"application/json"}, Security: []map[string][]string{ {"apikey": nil}, }, SecurityDefinitions: map[string]spec.SecurityScheme{ "basic": spec.BasicAuth(), "apiKey": spec.APIKeyAuth("api_key", "query"), "oauth2": spec.OAuth2AccessToken("http://authorize.com", "http://token.com"), }, Parameters: map[string]spec.Parameter{"format": formatParam}, Paths: &spec.Paths{ Paths: map[string]spec.PathItem{ "/": pi, "/items": pi2, }, }, }, } } func assertEnum(t testing.TB, data map[string][]interface{}, key string, enum []interface{}) { require.Contains(t, data, key) assert.Equal(t, enum, data[key]) } func assertRefExists(t testing.TB, data map[string]spec.Ref, key string) bool { _, ok := data[key] return assert.Truef(t, ok, "expected %q to exist in the ref bag", key) } func assertSchemaRefExists(t testing.TB, data map[string]SchemaRef, key string) bool { _, ok := data[key] return assert.Truef(t, ok, "expected %q to exist in schema ref bag", key) } func assertPattern(t testing.TB, data map[string]string, key, pattern string) bool { if assert.Contains(t, data, key) { return assert.Equal(t, pattern, data[key]) } return false } func prepareTestParamsAuth() Spec { formatParam := spec.QueryParam("format").Typed("string", "") limitParam := spec.QueryParam("limit").Typed("integer", "int32") limitParam.Extensions = spec.Extensions(map[string]interface{}{}) limitParam.Extensions.Add("go-name", "Limit") skipParam := spec.QueryParam("skip").Typed("integer", "int32") pi := spec.PathItem{} pi.Parameters = []spec.Parameter{limitParam} op := &spec.Operation{} op.Consumes = []string{"application/x-yaml"} op.Produces = []string{"application/x-yaml"} op.Security = []map[string][]string{ {"oauth2": {"the-scope"}}, {"basic": nil}, } op.ID = someOperation op.Parameters = []spec.Parameter{skipParam} pi.Get = op pi2 := spec.PathItem{} pi2.Parameters = []spec.Parameter{limitParam} op2 := &spec.Operation{} op2.ID = anotherOperation op2.Security = []map[string][]string{ {"oauth2": {"the-scope"}}, {}, { "basic": {}, "apiKey": {}, }, } op2.Parameters = []spec.Parameter{skipParam} pi2.Get = op2 oauth := spec.OAuth2AccessToken("http://authorize.com", "http://token.com") oauth.AddScope("the-scope", "the scope gives access to ...") spec := &spec.Swagger{ SwaggerProps: spec.SwaggerProps{ Consumes: []string{"application/json"}, Produces: []string{"application/json"}, Security: []map[string][]string{ {"apikey": nil}, }, SecurityDefinitions: map[string]spec.SecurityScheme{ "basic": spec.BasicAuth(), "apiKey": spec.APIKeyAuth("api_key", "query"), "oauth2": oauth, }, Parameters: map[string]spec.Parameter{"format": formatParam}, Paths: &spec.Paths{ Paths: map[string]spec.PathItem{ "/": pi, "/items": pi2, }, }, }, } analyzer := New(spec) return analyzer } func prepareTestParamsValid() Spec { formatParam := spec.QueryParam("format").Typed("string", "") limitParam := spec.QueryParam("limit").Typed("integer", "int32") limitParam.Extensions = spec.Extensions(map[string]interface{}{}) limitParam.Extensions.Add("go-name", "Limit") skipParam := spec.QueryParam("skip").Typed("integer", "int32") pi := spec.PathItem{} pi.Parameters = []spec.Parameter{limitParam} op := &spec.Operation{} op.Consumes = []string{"application/x-yaml"} op.Produces = []string{"application/x-yaml"} op.Security = []map[string][]string{ {"oauth2": {}}, {"basic": nil}, } op.ID = someOperation op.Parameters = []spec.Parameter{skipParam} pi.Get = op pi2 := spec.PathItem{} pi2.Parameters = []spec.Parameter{limitParam} op2 := &spec.Operation{} op2.ID = anotherOperation op2.Parameters = []spec.Parameter{skipParam} pi2.Get = op2 spec := makeFixturepec(pi, pi2, formatParam) analyzer := New(spec) return analyzer } func prepareTestParamsInvalid(t testing.TB, fixture string) Spec { bp := filepath.Join("fixtures", fixture) spec := antest.LoadOrFail(t, bp) analyzer := New(spec) return analyzer }	29.61 KB	2025-05-25 12:27
📄 debug.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "os" "github.com/go-openapi/analysis/internal/debug" ) var debugLog = debug.GetLogger("analysis", os.Getenv("SWAGGER_DEBUG") != "")	762 B	2025-05-25 12:27
📄 doc.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. /* Package analysis provides methods to work with a Swagger specification document from package go-openapi/spec. ## Analyzing a specification An analysed specification object (type Spec) provides methods to work with swagger definition. ## Flattening or expanding a specification Flattening a specification bundles all remote $ref in the main spec document. Depending on flattening options, additional preprocessing may take place: - full flattening: replacing all inline complex constructs by a named entry in #/definitions - expand: replace all $ref's in the document by their expanded content ## Merging several specifications Mixin several specifications merges all Swagger constructs, and warns about found conflicts. ## Fixing a specification Unmarshalling a specification with golang json unmarshalling may lead to some unwanted result on present but empty fields. ## Analyzing a Swagger schema Swagger schemas are analyzed to determine their complexity and qualify their content. */ package analysis	1.58 KB	2025-05-25 12:27
📄 fixer.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import "github.com/go-openapi/spec" // FixEmptyResponseDescriptions replaces empty ("") response // descriptions in the input with "(empty)" to ensure that the // resulting Swagger is stays valid. The problem appears to arise // from reading in valid specs that have a explicit response // description of "" (valid, response.description is required), but // due to zero values being omitted upon re-serializing (omitempty) we // lose them unless we stick some chars in there. func FixEmptyResponseDescriptions(s spec.Swagger) { for k, v := range s.Responses { FixEmptyDesc(&v) //#nosec s.Responses[k] = v } if s.Paths == nil { return } for _, v := range s.Paths.Paths { if v.Get != nil { FixEmptyDescs(v.Get.Responses) } if v.Put != nil { FixEmptyDescs(v.Put.Responses) } if v.Post != nil { FixEmptyDescs(v.Post.Responses) } if v.Delete != nil { FixEmptyDescs(v.Delete.Responses) } if v.Options != nil { FixEmptyDescs(v.Options.Responses) } if v.Head != nil { FixEmptyDescs(v.Head.Responses) } if v.Patch != nil { FixEmptyDescs(v.Patch.Responses) } } } // FixEmptyDescs adds "(empty)" as the description for any Response in // the given Responses object that doesn't already have one. func FixEmptyDescs(rs spec.Responses) { FixEmptyDesc(rs.Default) for k, v := range rs.StatusCodeResponses { FixEmptyDesc(&v) //#nosec rs.StatusCodeResponses[k] = v } } // FixEmptyDesc adds "(empty)" as the description to the given // Response object if it doesn't already have one and isn't a // ref. No-op on nil input. func FixEmptyDesc(rs *spec.Response) { if rs == nil \|\| rs.Description != "" \|\| rs.Ref.Ref.GetURL() != nil { return } rs.Description = "(empty)" }	2.29 KB	2025-05-25 12:27
📄 fixer_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "path/filepath" "strconv" "testing" "github.com/go-openapi/analysis/internal/antest" "github.com/go-openapi/spec" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestFixer_EmptyResponseDescriptions(t testing.T) { t.Parallel() bp := filepath.Join("fixtures", "fixer", "fixer.yaml") sp := antest.LoadOrFail(t, bp) FixEmptyResponseDescriptions(sp) for path, pathItem := range sp.Paths.Paths { require.NotNil(t, pathItem, "expected a fixture with all path items provided in: %s", path) if path == "/noDesc" { // scope for fixed descriptions assertAllVerbs(t, pathItem, true) } else { // scope for unchanged descriptions assertAllVerbs(t, pathItem, false) } } for r, toPin := range sp.Responses { resp := toPin assert.Truef(t, assertResponse(t, "/responses/"+r, &resp, true), "expected a fixed empty description in response %s", r) } } func assertAllVerbs(t testing.TB, pathItem spec.PathItem, isEmpty bool) { msg := "expected %s description for %s" var mode string if isEmpty { mode = "a fixed empty" } else { mode = "an unmodified" } assert.Truef(t, assertResponseInOperation(t, pathItem.Get, isEmpty), msg, mode, "GET") assert.Truef(t, assertResponseInOperation(t, pathItem.Put, isEmpty), msg, mode, "PUT") assert.Truef(t, assertResponseInOperation(t, pathItem.Post, isEmpty), msg, mode, "POST") assert.Truef(t, assertResponseInOperation(t, pathItem.Delete, isEmpty), msg, mode, "DELETE") assert.Truef(t, assertResponseInOperation(t, pathItem.Options, isEmpty), msg, mode, "OPTIONS") assert.Truef(t, assertResponseInOperation(t, pathItem.Patch, isEmpty), msg, mode, "PATCH") assert.Truef(t, assertResponseInOperation(t, pathItem.Head, isEmpty), msg, mode, "HEAD") } func assertResponseInOperation(t testing.TB, op spec.Operation, isEmpty bool) bool { require.NotNilf(t, op, "expected a fixture with all REST verbs set") if op.Responses == nil { return true } if op.Responses.Default != nil { return assert.Truef(t, assertResponse(t, "default", op.Responses.Default, isEmpty), "unexpected description in response %s for operation", "default") } for code, resp := range op.Responses.StatusCodeResponses { pin := resp return assert.Truef(t, assertResponse(t, strconv.Itoa(code), &pin, isEmpty), "unexpected description in response %d for operation", code) } return true } func assertResponse(t testing.TB, path string, resp *spec.Response, isEmpty bool) bool { var expected string if isEmpty { expected = "(empty)" } else { expected = "my description" } if resp.Ref.String() != "" { expected = "" } if !assert.Equalf(t, expected, resp.Description, "unexpected description for resp. %s", path) { return false } return true }	3.32 KB	2025-05-25 12:27
📁 fixtures	-	2025-05-25 12:27
📄 flatten.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "fmt" "log" "path" "sort" "strings" "github.com/go-openapi/analysis/internal/flatten/normalize" "github.com/go-openapi/analysis/internal/flatten/operations" "github.com/go-openapi/analysis/internal/flatten/replace" "github.com/go-openapi/analysis/internal/flatten/schutils" "github.com/go-openapi/analysis/internal/flatten/sortref" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/spec" ) const definitionsPath = "#/definitions" // newRef stores information about refs created during the flattening process type newRef struct { key string newName string path string isOAIGen bool resolved bool schema spec.Schema parents []string } // context stores intermediary results from flatten type context struct { newRefs map[string]newRef warnings []string resolved map[string]string } func newContext() context { return &context{ newRefs: make(map[string]newRef, 150), warnings: make([]string, 0), resolved: make(map[string]string, 50), } } // Flatten an analyzed spec and produce a self-contained spec bundle. // // There is a minimal and a full flattening mode. // // Minimally flattening a spec means: // - Expanding parameters, responses, path items, parameter items and header items (references to schemas are left // unscathed) // - Importing external (http, file) references so they become internal to the document // - Moving every JSON pointer to a $ref to a named definition (i.e. the reworked spec does not contain pointers // like "$ref": "#/definitions/myObject/allOfs/1") // // A minimally flattened spec thus guarantees the following properties: // - all $refs point to a local definition (i.e. '#/definitions/...') // - definitions are unique // // NOTE: arbitrary JSON pointers (other than $refs to top level definitions) are rewritten as definitions if they // represent a complex schema or express commonality in the spec. // Otherwise, they are simply expanded. // Self-referencing JSON pointers cannot resolve to a type and trigger an error. // // Minimal flattening is necessary and sufficient for codegen rendering using go-swagger. // // Fully flattening a spec means: // - Moving every complex inline schema to be a definition with an auto-generated name in a depth-first fashion. // // By complex, we mean every JSON object with some properties. // Arrays, when they do not define a tuple, // or empty objects with or without additionalProperties, are not considered complex and remain inline. // // NOTE: rewritten schemas get a vendor extension x-go-gen-location so we know from which part of the spec definitions // have been created. // // Available flattening options: // - Minimal: stops flattening after minimal $ref processing, leaving schema constructs untouched // - Expand: expand all $ref's in the document (inoperant if Minimal set to true) // - Verbose: croaks about name conflicts detected // - RemoveUnused: removes unused parameters, responses and definitions after expansion/flattening // // NOTE: expansion removes all $ref save circular $ref, which remain in place // // TODO: additional options // - ProgagateNameExtensions: ensure that created entries properly follow naming rules when their parent have set a // x-go-name extension // - LiftAllOfs: // - limit the flattening of allOf members when simple objects // - merge allOf with validation only // - merge allOf with extensions only // - ... func Flatten(opts FlattenOpts) error { debugLog("FlattenOpts: %#v", opts) opts.flattenContext = newContext() // 1. Recursively expand responses, parameters, path items and items in simple schemas. // // This simplifies the spec and leaves only the $ref's in schema objects. if err := expand(&opts); err != nil { return err } // 2. Strip the current document from absolute $ref's that actually a in the root, // so we can recognize them as proper definitions // // In particular, this works around issue go-openapi/spec#76: leading absolute file in $ref is stripped if err := normalizeRef(&opts); err != nil { return err } // 3. Optionally remove shared parameters and responses already expanded (now unused). // // Operation parameters (i.e. under paths) remain. if opts.RemoveUnused { removeUnusedShared(&opts) } // 4. Import all remote references. if err := importReferences(&opts); err != nil { return err } // 5. full flattening: rewrite inline schemas (schemas that aren't simple types or arrays or maps) if !opts.Minimal && !opts.Expand { if err := nameInlinedSchemas(&opts); err != nil { return err } } // 6. Rewrite JSON pointers other than $ref to named definitions // and attempt to resolve conflicting names whenever possible. if err := stripPointersAndOAIGen(&opts); err != nil { return err } // 7. Strip the spec from unused definitions if opts.RemoveUnused { removeUnused(&opts) } // 8. Issue warning notifications, if any opts.croak() // TODO: simplify known schema patterns to flat objects with properties // examples: // - lift simple allOf object, // - empty allOf with validation only or extensions only // - rework allOf arrays // - rework allOf additionalProperties return nil } func expand(opts FlattenOpts) error { if err := spec.ExpandSpec(opts.Swagger(), opts.ExpandOpts(!opts.Expand)); err != nil { return err } opts.Spec.reload() // re-analyze return nil } // normalizeRef strips the current file from any absolute file $ref. This works around issue go-openapi/spec#76: // leading absolute file in $ref is stripped func normalizeRef(opts FlattenOpts) error { debugLog("normalizeRef") altered := false for k, w := range opts.Spec.references.allRefs { if !strings.HasPrefix(w.String(), opts.BasePath+definitionsPath) { // may be a mix of / and \, depending on OS continue } altered = true debugLog("stripping absolute path for: %s", w.String()) // strip the base path from definition if err := replace.UpdateRef(opts.Swagger(), k, spec.MustCreateRef(path.Join(definitionsPath, path.Base(w.String())))); err != nil { return err } } if altered { opts.Spec.reload() // re-analyze } return nil } func removeUnusedShared(opts FlattenOpts) { opts.Swagger().Parameters = nil opts.Swagger().Responses = nil opts.Spec.reload() // re-analyze } func importReferences(opts FlattenOpts) error { var ( imported bool err error ) for !imported && err == nil { // iteratively import remote references until none left. // This inlining deals with name conflicts by introducing auto-generated names ("OAIGen") imported, err = importExternalReferences(opts) opts.Spec.reload() // re-analyze } return err } // nameInlinedSchemas replaces every complex inline construct by a named definition. func nameInlinedSchemas(opts FlattenOpts) error { debugLog("nameInlinedSchemas") namer := &InlineSchemaNamer{ Spec: opts.Swagger(), Operations: operations.AllOpRefsByRef(opts.Spec, nil), flattenContext: opts.flattenContext, opts: opts, } depthFirst := sortref.DepthFirst(opts.Spec.allSchemas) for _, key := range depthFirst { sch := opts.Spec.allSchemas[key] if sch.Schema == nil \|\| sch.Schema.Ref.String() != "" \|\| sch.TopLevel { continue } asch, err := Schema(SchemaOpts{Schema: sch.Schema, Root: opts.Swagger(), BasePath: opts.BasePath}) if err != nil { return fmt.Errorf("schema analysis [%s]: %w", key, err) } if asch.isAnalyzedAsComplex() { // move complex schemas to definitions if err := namer.Name(key, sch.Schema, asch); err != nil { return err } } } opts.Spec.reload() // re-analyze return nil } func removeUnused(opts FlattenOpts) { for removeUnusedSinglePass(opts) { // continue until no unused definition remains } } func removeUnusedSinglePass(opts FlattenOpts) (hasRemoved bool) { expected := make(map[string]struct{}) for k := range opts.Swagger().Definitions { expected[path.Join(definitionsPath, jsonpointer.Escape(k))] = struct{}{} } for _, k := range opts.Spec.AllDefinitionReferences() { delete(expected, k) } for k := range expected { hasRemoved = true debugLog("removing unused definition %s", path.Base(k)) if opts.Verbose { log.Printf("info: removing unused definition: %s", path.Base(k)) } delete(opts.Swagger().Definitions, path.Base(k)) } opts.Spec.reload() // re-analyze return hasRemoved } func importKnownRef(entry sortref.RefRevIdx, refStr, newName string, opts FlattenOpts) error { // rewrite ref with already resolved external ref (useful for cyclical refs): // rewrite external refs to local ones debugLog("resolving known ref [%s] to %s", refStr, newName) for _, key := range entry.Keys { if err := replace.UpdateRef(opts.Swagger(), key, spec.MustCreateRef(path.Join(definitionsPath, newName))); err != nil { return err } } return nil } func importNewRef(entry sortref.RefRevIdx, refStr string, opts FlattenOpts) error { var ( isOAIGen bool newName string ) debugLog("resolving schema from remote $ref [%s]", refStr) sch, err := spec.ResolveRefWithBase(opts.Swagger(), &entry.Ref, opts.ExpandOpts(false)) if err != nil { return fmt.Errorf("could not resolve schema: %w", err) } // at this stage only $ref analysis matters partialAnalyzer := &Spec{ references: referenceAnalysis{}, patterns: patternAnalysis{}, enums: enumAnalysis{}, } partialAnalyzer.reset() partialAnalyzer.analyzeSchema("", sch, "/") // now rewrite those refs with rebase for key, ref := range partialAnalyzer.references.allRefs { if err := replace.UpdateRef(sch, key, spec.MustCreateRef(normalize.RebaseRef(entry.Ref.String(), ref.String()))); err != nil { return fmt.Errorf("failed to rewrite ref for key %q at %s: %w", key, entry.Ref.String(), err) } } // generate a unique name - isOAIGen means that a naming conflict was resolved by changing the name newName, isOAIGen = uniqifyName(opts.Swagger().Definitions, nameFromRef(entry.Ref, opts)) debugLog("new name for [%s]: %s - with name conflict:%t", strings.Join(entry.Keys, ", "), newName, isOAIGen) opts.flattenContext.resolved[refStr] = newName // rewrite the external refs to local ones for _, key := range entry.Keys { if err := replace.UpdateRef(opts.Swagger(), key, spec.MustCreateRef(path.Join(definitionsPath, newName))); err != nil { return err } // keep track of created refs resolved := false if _, ok := opts.flattenContext.newRefs[key]; ok { resolved = opts.flattenContext.newRefs[key].resolved } debugLog("keeping track of ref: %s (%s), resolved: %t", key, newName, resolved) opts.flattenContext.newRefs[key] = &newRef{ key: key, newName: newName, path: path.Join(definitionsPath, newName), isOAIGen: isOAIGen, resolved: resolved, schema: sch, } } // add the resolved schema to the definitions schutils.Save(opts.Swagger(), newName, sch) return nil } // importExternalReferences iteratively digs remote references and imports them into the main schema. // // At every iteration, new remotes may be found when digging deeper: they are rebased to the current schema before being imported. // // This returns true when no more remote references can be found. func importExternalReferences(opts FlattenOpts) (bool, error) { debugLog("importExternalReferences") groupedRefs := sortref.ReverseIndex(opts.Spec.references.schemas, opts.BasePath) sortedRefStr := make([]string, 0, len(groupedRefs)) if opts.flattenContext == nil { opts.flattenContext = newContext() } // sort $ref resolution to ensure deterministic name conflict resolution for refStr := range groupedRefs { sortedRefStr = append(sortedRefStr, refStr) } sort.Strings(sortedRefStr) complete := true for _, refStr := range sortedRefStr { entry := groupedRefs[refStr] if entry.Ref.HasFragmentOnly { continue } complete = false newName := opts.flattenContext.resolved[refStr] if newName != "" { if err := importKnownRef(entry, refStr, newName, opts); err != nil { return false, err } continue } // resolve schemas if err := importNewRef(entry, refStr, opts); err != nil { return false, err } } // maintains ref index entries for k := range opts.flattenContext.newRefs { r := opts.flattenContext.newRefs[k] // update tracking with resolved schemas if r.schema.Ref.String() != "" { ref := spec.MustCreateRef(r.path) sch, err := spec.ResolveRefWithBase(opts.Swagger(), &ref, opts.ExpandOpts(false)) if err != nil { return false, fmt.Errorf("could not resolve schema: %w", err) } r.schema = sch } if r.path == k { continue } // update tracking with renamed keys: got a cascade of refs renamed := r renamed.key = r.path opts.flattenContext.newRefs[renamed.path] = &renamed // indirect ref r.newName = path.Base(k) r.schema = spec.RefSchema(r.path) r.path = k r.isOAIGen = strings.Contains(k, "OAIGen") } return complete, nil } // stripPointersAndOAIGen removes anonymous JSON pointers from spec and chain with name conflicts handler. // This loops until the spec has no such pointer and all name conflicts have been reduced as much as possible. func stripPointersAndOAIGen(opts FlattenOpts) error { // name all JSON pointers to anonymous documents if err := namePointers(opts); err != nil { return err } // remove unnecessary OAIGen ref (created when flattening external refs creates name conflicts) hasIntroducedPointerOrInline, ers := stripOAIGen(opts) if ers != nil { return ers } // iterate as pointer or OAIGen resolution may introduce inline schemas or pointers for hasIntroducedPointerOrInline { if !opts.Minimal { opts.Spec.reload() // re-analyze if err := nameInlinedSchemas(opts); err != nil { return err } } if err := namePointers(opts); err != nil { return err } // restrip and re-analyze var err error if hasIntroducedPointerOrInline, err = stripOAIGen(opts); err != nil { return err } } return nil } // stripOAIGen strips the spec from unnecessary OAIGen constructs, initially created to dedupe flattened definitions. // // A dedupe is deemed unnecessary whenever: // - the only conflict is with its (single) parent: OAIGen is merged into its parent (reinlining) // - there is a conflict with multiple parents: merge OAIGen in first parent, the rewrite other parents to point to // the first parent. // // This function returns true whenever it re-inlined a complex schema, so the caller may chose to iterate // pointer and name resolution again. func stripOAIGen(opts FlattenOpts) (bool, error) { debugLog("stripOAIGen") replacedWithComplex := false // figure out referers of OAIGen definitions (doing it before the ref start mutating) for _, r := range opts.flattenContext.newRefs { updateRefParents(opts.Spec.references.allRefs, r) } for k := range opts.flattenContext.newRefs { r := opts.flattenContext.newRefs[k] debugLog("newRefs[%s]: isOAIGen: %t, resolved: %t, name: %s, path:%s, #parents: %d, parents: %v, ref: %s", k, r.isOAIGen, r.resolved, r.newName, r.path, len(r.parents), r.parents, r.schema.Ref.String()) if !r.isOAIGen \|\| len(r.parents) == 0 { continue } hasReplacedWithComplex, err := stripOAIGenForRef(opts, k, r) if err != nil { return replacedWithComplex, err } replacedWithComplex = replacedWithComplex \|\| hasReplacedWithComplex } debugLog("replacedWithComplex: %t", replacedWithComplex) opts.Spec.reload() // re-analyze return replacedWithComplex, nil } // updateRefParents updates all parents of an updated $ref func updateRefParents(allRefs map[string]spec.Ref, r newRef) { if !r.isOAIGen \|\| r.resolved { // bail on already resolved entries (avoid looping) return } for k, v := range allRefs { if r.path != v.String() { continue } found := false for _, p := range r.parents { if p == k { found = true break } } if !found { r.parents = append(r.parents, k) } } } func stripOAIGenForRef(opts FlattenOpts, k string, r newRef) (bool, error) { replacedWithComplex := false pr := sortref.TopmostFirst(r.parents) // rewrite first parent schema in hierarchical then lexicographical order debugLog("rewrite first parent %s with schema", pr[0]) if err := replace.UpdateRefWithSchema(opts.Swagger(), pr[0], r.schema); err != nil { return false, err } if pa, ok := opts.flattenContext.newRefs[pr[0]]; ok && pa.isOAIGen { // update parent in ref index entry debugLog("update parent entry: %s", pr[0]) pa.schema = r.schema pa.resolved = false replacedWithComplex = true } // rewrite other parents to point to first parent if len(pr) > 1 { for _, p := range pr[1:] { replacingRef := spec.MustCreateRef(pr[0]) // set complex when replacing ref is an anonymous jsonpointer: further processing may be required replacedWithComplex = replacedWithComplex \|\| path.Dir(replacingRef.String()) != definitionsPath debugLog("rewrite parent with ref: %s", replacingRef.String()) // NOTE: it is possible at this stage to introduce json pointers (to non-definitions places). // Those are stripped later on. if err := replace.UpdateRef(opts.Swagger(), p, replacingRef); err != nil { return false, err } if pa, ok := opts.flattenContext.newRefs[p]; ok && pa.isOAIGen { // update parent in ref index debugLog("update parent entry: %s", p) pa.schema = r.schema pa.resolved = false replacedWithComplex = true } } } // remove OAIGen definition debugLog("removing definition %s", path.Base(r.path)) delete(opts.Swagger().Definitions, path.Base(r.path)) // propagate changes in ref index for keys which have this one as a parent for kk, value := range opts.flattenContext.newRefs { if kk == k \|\| !value.isOAIGen \|\| value.resolved { continue } found := false newParents := make([]string, 0, len(value.parents)) for _, parent := range value.parents { switch { case parent == r.path: found = true parent = pr[0] case strings.HasPrefix(parent, r.path+"/"): found = true parent = path.Join(pr[0], strings.TrimPrefix(parent, r.path)) } newParents = append(newParents, parent) } if found { value.parents = newParents } } // mark naming conflict as resolved debugLog("marking naming conflict resolved for key: %s", r.key) opts.flattenContext.newRefs[r.key].isOAIGen = false opts.flattenContext.newRefs[r.key].resolved = true // determine if the previous substitution did inline a complex schema if r.schema != nil && r.schema.Ref.String() == "" { // inline schema asch, err := Schema(SchemaOpts{Schema: r.schema, Root: opts.Swagger(), BasePath: opts.BasePath}) if err != nil { return false, err } debugLog("re-inlined schema: parent: %s, %t", pr[0], asch.isAnalyzedAsComplex()) replacedWithComplex = replacedWithComplex \|\| !(path.Dir(pr[0]) == definitionsPath) && asch.isAnalyzedAsComplex() } return replacedWithComplex, nil } // namePointers replaces all JSON pointers to anonymous documents by a $ref to a new named definitions. // // This is carried on depth-first. Pointers to $refs which are top level definitions are replaced by the $ref itself. // Pointers to simple types are expanded, unless they express commonality (i.e. several such $ref are used). func namePointers(opts FlattenOpts) error { debugLog("name pointers") refsToReplace := make(map[string]SchemaRef, len(opts.Spec.references.schemas)) for k, ref := range opts.Spec.references.allRefs { debugLog("name pointers: %q => %#v", k, ref) if path.Dir(ref.String()) == definitionsPath { // this a ref to a top-level definition: ok continue } result, err := replace.DeepestRef(opts.Swagger(), opts.ExpandOpts(false), ref) if err != nil { return fmt.Errorf("at %s, %w", k, err) } replacingRef := result.Ref sch := result.Schema if opts.flattenContext != nil { opts.flattenContext.warnings = append(opts.flattenContext.warnings, result.Warnings...) } debugLog("planning pointer to replace at %s: %s, resolved to: %s", k, ref.String(), replacingRef.String()) refsToReplace[k] = SchemaRef{ Name: k, // caller Ref: replacingRef, // called Schema: sch, TopLevel: path.Dir(replacingRef.String()) == definitionsPath, } } depthFirst := sortref.DepthFirst(refsToReplace) namer := &InlineSchemaNamer{ Spec: opts.Swagger(), Operations: operations.AllOpRefsByRef(opts.Spec, nil), flattenContext: opts.flattenContext, opts: opts, } for _, key := range depthFirst { v := refsToReplace[key] // update current replacement, which may have been updated by previous changes of deeper elements result, erd := replace.DeepestRef(opts.Swagger(), opts.ExpandOpts(false), v.Ref) if erd != nil { return fmt.Errorf("at %s, %w", key, erd) } if opts.flattenContext != nil { opts.flattenContext.warnings = append(opts.flattenContext.warnings, result.Warnings...) } v.Ref = result.Ref v.Schema = result.Schema v.TopLevel = path.Dir(result.Ref.String()) == definitionsPath debugLog("replacing pointer at %s: resolved to: %s", key, v.Ref.String()) if v.TopLevel { debugLog("replace pointer %s by canonical definition: %s", key, v.Ref.String()) // if the schema is a $ref to a top level definition, just rewrite the pointer to this $ref if err := replace.UpdateRef(opts.Swagger(), key, v.Ref); err != nil { return err } continue } if err := flattenAnonPointer(key, v, refsToReplace, namer, opts); err != nil { return err } } opts.Spec.reload() // re-analyze return nil } func flattenAnonPointer(key string, v SchemaRef, refsToReplace map[string]SchemaRef, namer InlineSchemaNamer, opts *FlattenOpts) error { // this is a JSON pointer to an anonymous document (internal or external): // create a definition for this schema when: // - it is a complex schema // - or it is pointed by more than one $ref (i.e. expresses commonality) // otherwise, expand the pointer (single reference to a simple type) // // The named definition for this follows the target's key, not the caller's debugLog("namePointers at %s for %s", key, v.Ref.String()) // qualify the expanded schema asch, ers := Schema(SchemaOpts{Schema: v.Schema, Root: opts.Swagger(), BasePath: opts.BasePath}) if ers != nil { return fmt.Errorf("schema analysis [%s]: %w", key, ers) } callers := make([]string, 0, 64) debugLog("looking for callers") an := New(opts.Swagger()) for k, w := range an.references.allRefs { r, err := replace.DeepestRef(opts.Swagger(), opts.ExpandOpts(false), w) if err != nil { return fmt.Errorf("at %s, %w", key, err) } if opts.flattenContext != nil { opts.flattenContext.warnings = append(opts.flattenContext.warnings, r.Warnings...) } if r.Ref.String() == v.Ref.String() { callers = append(callers, k) } } debugLog("callers for %s: %d", v.Ref.String(), len(callers)) if len(callers) == 0 { // has already been updated and resolved return nil } parts := sortref.KeyParts(v.Ref.String()) debugLog("number of callers for %s: %d", v.Ref.String(), len(callers)) // identifying edge case when the namer did nothing because we point to a non-schema object // no definition is created and we expand the $ref for all callers debugLog("decide what to do with the schema pointed to: asch.IsSimpleSchema=%t, len(callers)=%d, parts.IsSharedParam=%t, parts.IsSharedResponse=%t", asch.IsSimpleSchema, len(callers), parts.IsSharedParam(), parts.IsSharedResponse(), ) if (!asch.IsSimpleSchema \|\| len(callers) > 1) && !parts.IsSharedParam() && !parts.IsSharedResponse() { debugLog("replace JSON pointer at [%s] by definition: %s", key, v.Ref.String()) if err := namer.Name(v.Ref.String(), v.Schema, asch); err != nil { return err } // regular case: we named the $ref as a definition, and we move all callers to this new $ref for _, caller := range callers { if caller == key { continue } // move $ref for next to resolve debugLog("identified caller of %s at [%s]", v.Ref.String(), caller) c := refsToReplace[caller] c.Ref = v.Ref refsToReplace[caller] = c } return nil } // everything that is a simple schema and not factorizable is expanded debugLog("expand JSON pointer for key=%s", key) if err := replace.UpdateRefWithSchema(opts.Swagger(), key, v.Schema); err != nil { return err } // NOTE: there is no other caller to update return nil }	24.63 KB	2025-05-25 12:27
📄 flatten_name.go package analysis import ( "fmt" "path" "sort" "strings" "github.com/go-openapi/analysis/internal/flatten/operations" "github.com/go-openapi/analysis/internal/flatten/replace" "github.com/go-openapi/analysis/internal/flatten/schutils" "github.com/go-openapi/analysis/internal/flatten/sortref" "github.com/go-openapi/spec" "github.com/go-openapi/swag" ) // InlineSchemaNamer finds a new name for an inlined type type InlineSchemaNamer struct { Spec spec.Swagger Operations map[string]operations.OpRef flattenContext context opts FlattenOpts } // Name yields a new name for the inline schema func (isn InlineSchemaNamer) Name(key string, schema spec.Schema, aschema AnalyzedSchema) error { debugLog("naming inlined schema at %s", key) parts := sortref.KeyParts(key) for _, name := range namesFromKey(parts, aschema, isn.Operations) { if name == "" { continue } // create unique name mangle := mangler(isn.opts) newName, isOAIGen := uniqifyName(isn.Spec.Definitions, mangle(name)) // clone schema sch := schutils.Clone(schema) // replace values on schema debugLog("rewriting schema to ref: key=%s with new name: %s", key, newName) if err := replace.RewriteSchemaToRef(isn.Spec, key, spec.MustCreateRef(path.Join(definitionsPath, newName))); err != nil { return fmt.Errorf("error while creating definition %q from inline schema: %w", newName, err) } // rewrite any dependent $ref pointing to this place, // when not already pointing to a top-level definition. // // NOTE: this is important if such referers use arbitrary JSON pointers. an := New(isn.Spec) for k, v := range an.references.allRefs { r, erd := replace.DeepestRef(isn.opts.Swagger(), isn.opts.ExpandOpts(false), v) if erd != nil { return fmt.Errorf("at %s, %w", k, erd) } if isn.opts.flattenContext != nil { isn.opts.flattenContext.warnings = append(isn.opts.flattenContext.warnings, r.Warnings...) } if r.Ref.String() != key && (r.Ref.String() != path.Join(definitionsPath, newName) \|\| path.Dir(v.String()) == definitionsPath) { continue } debugLog("found a $ref to a rewritten schema: %s points to %s", k, v.String()) // rewrite $ref to the new target if err := replace.UpdateRef(isn.Spec, k, spec.MustCreateRef(path.Join(definitionsPath, newName))); err != nil { return err } } // NOTE: this extension is currently not used by go-swagger (provided for information only) sch.AddExtension("x-go-gen-location", GenLocation(parts)) // save cloned schema to definitions schutils.Save(isn.Spec, newName, sch) // keep track of created refs if isn.flattenContext == nil { continue } debugLog("track created ref: key=%s, newName=%s, isOAIGen=%t", key, newName, isOAIGen) resolved := false if _, ok := isn.flattenContext.newRefs[key]; ok { resolved = isn.flattenContext.newRefs[key].resolved } isn.flattenContext.newRefs[key] = &newRef{ key: key, newName: newName, path: path.Join(definitionsPath, newName), isOAIGen: isOAIGen, resolved: resolved, schema: sch, } } return nil } // uniqifyName yields a unique name for a definition func uniqifyName(definitions spec.Definitions, name string) (string, bool) { isOAIGen := false if name == "" { name = "oaiGen" isOAIGen = true } if len(definitions) == 0 { return name, isOAIGen } unq := true for k := range definitions { if strings.EqualFold(k, name) { unq = false break } } if unq { return name, isOAIGen } name += "OAIGen" isOAIGen = true var idx int unique := name _, known := definitions[unique] for known { idx++ unique = fmt.Sprintf("%s%d", name, idx) _, known = definitions[unique] } return unique, isOAIGen } func namesFromKey(parts sortref.SplitKey, aschema AnalyzedSchema, operations map[string]operations.OpRef) []string { var ( baseNames [][]string startIndex int ) switch { case parts.IsOperation(): baseNames, startIndex = namesForOperation(parts, operations) case parts.IsDefinition(): baseNames, startIndex = namesForDefinition(parts) default: // this a non-standard pointer: build a name by concatenating its parts baseNames = [][]string{parts} startIndex = len(baseNames) + 1 } result := make([]string, 0, len(baseNames)) for _, segments := range baseNames { nm := parts.BuildName(segments, startIndex, partAdder(aschema)) if nm == "" { continue } result = append(result, nm) } sort.Strings(result) debugLog("names from parts: %v => %v", parts, result) return result } func namesForParam(parts sortref.SplitKey, operations map[string]operations.OpRef) ([][]string, int) { var ( baseNames [][]string startIndex int ) piref := parts.PathItemRef() if piref.String() != "" && parts.IsOperationParam() { if op, ok := operations[piref.String()]; ok { startIndex = 5 baseNames = append(baseNames, []string{op.ID, "params", "body"}) } } else if parts.IsSharedOperationParam() { pref := parts.PathRef() for k, v := range operations { if strings.HasPrefix(k, pref.String()) { startIndex = 4 baseNames = append(baseNames, []string{v.ID, "params", "body"}) } } } return baseNames, startIndex } func namesForOperation(parts sortref.SplitKey, operations map[string]operations.OpRef) ([][]string, int) { var ( baseNames [][]string startIndex int ) // params if parts.IsOperationParam() \|\| parts.IsSharedOperationParam() { baseNames, startIndex = namesForParam(parts, operations) } // responses if parts.IsOperationResponse() { piref := parts.PathItemRef() if piref.String() != "" { if op, ok := operations[piref.String()]; ok { startIndex = 6 baseNames = append(baseNames, []string{op.ID, parts.ResponseName(), "body"}) } } } return baseNames, startIndex } func namesForDefinition(parts sortref.SplitKey) ([][]string, int) { nm := parts.DefinitionName() if nm != "" { return [][]string{{parts.DefinitionName()}}, 2 } return [][]string{}, 0 } // partAdder knows how to interpret a schema when it comes to build a name from parts func partAdder(aschema AnalyzedSchema) sortref.PartAdder { return func(part string) []string { segments := make([]string, 0, 2) if part == "items" \|\| part == "additionalItems" { if aschema.IsTuple \|\| aschema.IsTupleWithExtra { segments = append(segments, "tuple") } else { segments = append(segments, "items") } if part == "additionalItems" { segments = append(segments, part) } return segments } segments = append(segments, part) return segments } } func mangler(o FlattenOpts) func(string) string { if o.KeepNames { return func(in string) string { return in } } return swag.ToJSONName } func nameFromRef(ref spec.Ref, o FlattenOpts) string { mangle := mangler(o) u := ref.GetURL() if u.Fragment != "" { return mangle(path.Base(u.Fragment)) } if u.Path != "" { bn := path.Base(u.Path) if bn != "" && bn != "/" { ext := path.Ext(bn) if ext != "" { return mangle(bn[:len(bn)-len(ext)]) } return mangle(bn) } } return mangle(strings.ReplaceAll(u.Host, ".", " ")) } // GenLocation indicates from which section of the specification (models or operations) a definition has been created. // // This is reflected in the output spec with a "x-go-gen-location" extension. At the moment, this is provided // for information only. func GenLocation(parts sortref.SplitKey) string { switch { case parts.IsOperation(): return "operations" case parts.IsDefinition(): return "models" default: return "" } }	7.46 KB	2025-05-25 12:27
📄 flatten_name_test.go package analysis import ( "path/filepath" "strings" "testing" "github.com/go-openapi/analysis/internal/antest" "github.com/go-openapi/analysis/internal/flatten/operations" "github.com/go-openapi/analysis/internal/flatten/sortref" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/spec" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestName_FromRef(t testing.T) { t.Parallel() values := []struct{ Source, Expected string }{ {"#/definitions/errorModel", "errorModel"}, {"http://somewhere.com/definitions/errorModel", "errorModel"}, {"http://somewhere.com/definitions/errorModel.json", "errorModel"}, {"/definitions/errorModel", "errorModel"}, {"/definitions/errorModel.json", "errorModel"}, {"http://somewhere.com", "somewhereCom"}, {"#", ""}, } for _, v := range values { assert.Equal(t, v.Expected, nameFromRef(spec.MustCreateRef(v.Source), &FlattenOpts{})) } } func TestName_FromRefMangle(t testing.T) { t.Parallel() values := []struct{ Source, Expected, ExpectedKeepName string }{ {"#/definitions/ErrorModel", "errorModel", "ErrorModel"}, {"#/definitions/Error_Model", "errorModel", "Error_Model"}, {"http://somewhere.com/definitions/errorModel", "errorModel", "errorModel"}, {"http://somewhere.com/definitions/ErrorModel.json", "errorModel", "ErrorModel"}, {"/definitions/ErrorModel", "errorModel", "ErrorModel"}, {"/definitions/ErrorModel.json", "errorModel", "ErrorModel"}, {"http://somewhere.com", "somewhereCom", "somewhere com"}, {"#", "", ""}, } for _, v := range values { assert.Equal(t, v.Expected, nameFromRef(spec.MustCreateRef(v.Source), &FlattenOpts{})) assert.Equal(t, v.ExpectedKeepName, nameFromRef(spec.MustCreateRef(v.Source), &FlattenOpts{KeepNames: true})) } } func TestName_Definition(t testing.T) { values := []struct { Source, Expected string Definitions spec.Definitions }{ {"#/definitions/errorModel", "errorModel", map[string]spec.Schema(nil)}, {"http://somewhere.com/definitions/errorModel", "errorModel", map[string]spec.Schema(nil)}, {"#/definitions/errorModel", "errorModel", map[string]spec.Schema{"apples": spec.StringProperty()}}, {"#/definitions/errorModel", "errorModelOAIGen", map[string]spec.Schema{"errorModel": spec.StringProperty()}}, {"#/definitions/errorModel", "errorModelOAIGen1", map[string]spec.Schema{"errorModel": spec.StringProperty(), "errorModelOAIGen": spec.StringProperty()}}, {"#", "oaiGen", nil}, } for _, v := range values { u, _ := uniqifyName(v.Definitions, nameFromRef(spec.MustCreateRef(v.Source), &FlattenOpts{})) assert.Equal(t, v.Expected, u) } } func TestName_SplitKey(t testing.T) { type KeyFlag uint64 const ( isOperation KeyFlag = 1 << iota isDefinition isSharedOperationParam isOperationParam isOperationResponse isDefaultResponse isStatusCodeResponse ) values := []struct { Key string Flags KeyFlag PathItemRef spec.Ref PathRef spec.Ref Name string }{ { "#/paths/~1some~1where~1{id}/parameters/1/schema", isOperation \| isSharedOperationParam, spec.Ref{}, spec.MustCreateRef("#/paths/~1some~1where~1{id}"), "", }, { "#/paths/~1some~1where~1{id}/get/parameters/2/schema", isOperation \| isOperationParam, spec.MustCreateRef("#/paths/~1some~1where~1{id}/GET"), spec.MustCreateRef("#/paths/~1some~1where~1{id}"), "", }, { "#/paths/~1some~1where~1{id}/get/responses/default/schema", isOperation \| isOperationResponse \| isDefaultResponse, spec.MustCreateRef("#/paths/~1some~1where~1{id}/GET"), spec.MustCreateRef("#/paths/~1some~1where~1{id}"), "Default", }, { "#/paths/~1some~1where~1{id}/get/responses/200/schema", isOperation \| isOperationResponse \| isStatusCodeResponse, spec.MustCreateRef("#/paths/~1some~1where~1{id}/GET"), spec.MustCreateRef("#/paths/~1some~1where~1{id}"), "OK", }, { "#/definitions/namedAgain", isDefinition, spec.Ref{}, spec.Ref{}, "namedAgain", }, { "#/definitions/datedRecords/items/1", isDefinition, spec.Ref{}, spec.Ref{}, "datedRecords", }, { "#/definitions/datedRecords/items/1", isDefinition, spec.Ref{}, spec.Ref{}, "datedRecords", }, { "#/definitions/datedTaggedRecords/items/1", isDefinition, spec.Ref{}, spec.Ref{}, "datedTaggedRecords", }, { "#/definitions/datedTaggedRecords/additionalItems", isDefinition, spec.Ref{}, spec.Ref{}, "datedTaggedRecords", }, { "#/definitions/otherRecords/items", isDefinition, spec.Ref{}, spec.Ref{}, "otherRecords", }, { "#/definitions/tags/additionalProperties", isDefinition, spec.Ref{}, spec.Ref{}, "tags", }, { "#/definitions/namedThing/properties/name", isDefinition, spec.Ref{}, spec.Ref{}, "namedThing", }, } for i, v := range values { parts := sortref.KeyParts(v.Key) pref := parts.PathRef() piref := parts.PathItemRef() assert.Equal(t, v.PathRef.String(), pref.String(), "pathRef: %s at %d", v.Key, i) assert.Equal(t, v.PathItemRef.String(), piref.String(), "pathItemRef: %s at %d", v.Key, i) if v.Flags&isOperation != 0 { assert.True(t, parts.IsOperation(), "isOperation: %s at %d", v.Key, i) } else { assert.False(t, parts.IsOperation(), "isOperation: %s at %d", v.Key, i) } if v.Flags&isDefinition != 0 { assert.True(t, parts.IsDefinition(), "isDefinition: %s at %d", v.Key, i) assert.Equal(t, v.Name, parts.DefinitionName(), "definition name: %s at %d", v.Key, i) } else { assert.False(t, parts.IsDefinition(), "isDefinition: %s at %d", v.Key, i) if v.Name != "" { assert.Equal(t, v.Name, parts.ResponseName(), "response name: %s at %d", v.Key, i) } } if v.Flags&isOperationParam != 0 { assert.True(t, parts.IsOperationParam(), "isOperationParam: %s at %d", v.Key, i) } else { assert.False(t, parts.IsOperationParam(), "isOperationParam: %s at %d", v.Key, i) } if v.Flags&isSharedOperationParam != 0 { assert.True(t, parts.IsSharedOperationParam(), "isSharedOperationParam: %s at %d", v.Key, i) } else { assert.False(t, parts.IsSharedOperationParam(), "isSharedOperationParam: %s at %d", v.Key, i) } if v.Flags&isOperationResponse != 0 { assert.True(t, parts.IsOperationResponse(), "isOperationResponse: %s at %d", v.Key, i) } else { assert.False(t, parts.IsOperationResponse(), "isOperationResponse: %s at %d", v.Key, i) } if v.Flags&isDefaultResponse != 0 { assert.True(t, parts.IsDefaultResponse(), "isDefaultResponse: %s at %d", v.Key, i) } else { assert.False(t, parts.IsDefaultResponse(), "isDefaultResponse: %s at %d", v.Key, i) } if v.Flags&isStatusCodeResponse != 0 { assert.True(t, parts.IsStatusCodeResponse(), "isStatusCodeResponse: %s at %d", v.Key, i) } else { assert.False(t, parts.IsStatusCodeResponse(), "isStatusCodeResponse: %s at %d", v.Key, i) } } } func TestName_NamesFromKey(t testing.T) { bp := filepath.Join("fixtures", "inline_schemas.yml") sp := antest.LoadOrFail(t, bp) values := []struct { Key string Names []string }{ {"#/paths/~1some~1where~1{id}/parameters/1/schema", []string{"GetSomeWhereID params body", "PostSomeWhereID params body"}}, {"#/paths/~1some~1where~1{id}/get/parameters/2/schema", []string{"GetSomeWhereID params body"}}, {"#/paths/~1some~1where~1{id}/get/responses/default/schema", []string{"GetSomeWhereID Default body"}}, {"#/paths/~1some~1where~1{id}/get/responses/200/schema", []string{"GetSomeWhereID OK body"}}, {"#/definitions/namedAgain", []string{"namedAgain"}}, {"#/definitions/datedTag/allOf/1", []string{"datedTag allOf 1"}}, {"#/definitions/datedRecords/items/1", []string{"datedRecords tuple 1"}}, {"#/definitions/datedTaggedRecords/items/1", []string{"datedTaggedRecords tuple 1"}}, {"#/definitions/datedTaggedRecords/additionalItems", []string{"datedTaggedRecords tuple additionalItems"}}, {"#/definitions/otherRecords/items", []string{"otherRecords items"}}, {"#/definitions/tags/additionalProperties", []string{"tags additionalProperties"}}, {"#/definitions/namedThing/properties/name", []string{"namedThing name"}}, } for i, v := range values { ptr, err := jsonpointer.New(definitionPtr(v.Key)[1:]) require.NoError(t, err) vv, _, err := ptr.Get(sp) require.NoError(t, err) switch tv := vv.(type) { case spec.Schema: aschema, err := Schema(SchemaOpts{Schema: tv, Root: sp, BasePath: bp}) require.NoError(t, err) names := namesFromKey(sortref.KeyParts(v.Key), aschema, operations.AllOpRefsByRef(New(sp), nil)) assert.Equal(t, v.Names, names, "for %s at %d", v.Key, i) case spec.Schema: aschema, err := Schema(SchemaOpts{Schema: &tv, Root: sp, BasePath: bp}) require.NoError(t, err) names := namesFromKey(sortref.KeyParts(v.Key), aschema, operations.AllOpRefsByRef(New(sp), nil)) assert.Equal(t, v.Names, names, "for %s at %d", v.Key, i) default: assert.Fail(t, "unknown type", "got %T", vv) } } } func TestName_BuildNameWithReservedKeyWord(t testing.T) { s := sortref.SplitKey([]string{"definitions", "fullview", "properties", "properties"}) startIdx := 2 segments := []string{"fullview"} newName := s.BuildName(segments, startIdx, partAdder(nil)) assert.Equal(t, "fullview properties", newName) s = sortref.SplitKey([]string{"definitions", "fullview", "properties", "properties", "properties", "properties", "properties", "properties"}) newName = s.BuildName(segments, startIdx, partAdder(nil)) assert.Equal(t, "fullview"+strings.Repeat(" properties", 3), newName) } func TestName_InlinedSchemas(t testing.T) { values := []struct { Key string Location string Ref spec.Ref }{ {"#/paths/~1some~1where~1{id}/get/parameters/2/schema/properties/record/items/2/properties/name", "#/definitions/getSomeWhereIdParamsBodyRecordItems2/properties/name", spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecordItems2Name"), }, {"#/paths/~1some~1where~1{id}/get/parameters/2/schema/properties/record/items/1", "#/definitions/getSomeWhereIdParamsBodyRecord/items/1", spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecordItems1"), }, {"#/paths/~1some~1where~1{id}/get/parameters/2/schema/properties/record/items/2", "#/definitions/getSomeWhereIdParamsBodyRecord/items/2", spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecordItems2"), }, {"#/paths/~1some~1where~1{id}/get/responses/200/schema/properties/record/items/2/properties/name", "#/definitions/getSomeWhereIdOKBodyRecordItems2/properties/name", spec.MustCreateRef("#/definitions/getSomeWhereIdOKBodyRecordItems2Name"), }, {"#/paths/~1some~1where~1{id}/get/responses/200/schema/properties/record/items/1", "#/definitions/getSomeWhereIdOKBodyRecord/items/1", spec.MustCreateRef("#/definitions/getSomeWhereIdOKBodyRecordItems1"), }, {"#/paths/~1some~1where~1{id}/get/responses/200/schema/properties/record/items/2", "#/definitions/getSomeWhereIdOKBodyRecord/items/2", spec.MustCreateRef("#/definitions/getSomeWhereIdOKBodyRecordItems2"), }, {"#/paths/~1some~1where~1{id}/get/responses/200/schema/properties/record", "#/definitions/getSomeWhereIdOKBody/properties/record", spec.MustCreateRef("#/definitions/getSomeWhereIdOKBodyRecord"), }, {"#/paths/~1some~1where~1{id}/get/responses/200/schema", "#/paths/~1some~1where~1{id}/get/responses/200/schema", spec.MustCreateRef("#/definitions/getSomeWhereIdOKBody"), }, {"#/paths/~1some~1where~1{id}/get/responses/default/schema/properties/record/items/2/properties/name", "#/definitions/getSomeWhereIdDefaultBodyRecordItems2/properties/name", spec.MustCreateRef("#/definitions/getSomeWhereIdDefaultBodyRecordItems2Name"), }, {"#/paths/~1some~1where~1{id}/get/responses/default/schema/properties/record/items/1", "#/definitions/getSomeWhereIdDefaultBodyRecord/items/1", spec.MustCreateRef("#/definitions/getSomeWhereIdDefaultBodyRecordItems1"), }, {"#/paths/~1some~1where~1{id}/get/responses/default/schema/properties/record/items/2", "#/definitions/getSomeWhereIdDefaultBodyRecord/items/2", spec.MustCreateRef("#/definitions/getSomeWhereIdDefaultBodyRecordItems2"), }, {"#/paths/~1some~1where~1{id}/get/responses/default/schema/properties/record", "#/definitions/getSomeWhereIdDefaultBody/properties/record", spec.MustCreateRef("#/definitions/getSomeWhereIdDefaultBodyRecord"), }, {"#/paths/~1some~1where~1{id}/get/responses/default/schema", "#/paths/~1some~1where~1{id}/get/responses/default/schema", spec.MustCreateRef("#/definitions/getSomeWhereIdDefaultBody"), }, // maps: // {"#/definitions/nestedThing/properties/record/items/2/allOf/1/additionalProperties", // "#/definitions/nestedThingRecordItems2AllOf1/additionalProperties", // spec.MustCreateRef("#/definitions/nestedThingRecordItems2AllOf1AdditionalProperties"), // }, // {"#/definitions/nestedThing/properties/record/items/2/allOf/1", // "#/definitions/nestedThingRecordItems2/allOf/1", // spec.MustCreateRef("#/definitions/nestedThingRecordItems2AllOf1"), // }, {"#/definitions/nestedThing/properties/record/items/2/properties/name", "#/definitions/nestedThingRecordItems2/properties/name", spec.MustCreateRef("#/definitions/nestedThingRecordItems2Name"), }, {"#/definitions/nestedThing/properties/record/items/1", "#/definitions/nestedThingRecord/items/1", spec.MustCreateRef("#/definitions/nestedThingRecordItems1"), }, {"#/definitions/nestedThing/properties/record/items/2", "#/definitions/nestedThingRecord/items/2", spec.MustCreateRef("#/definitions/nestedThingRecordItems2"), }, {"#/definitions/datedRecords/items/1", "#/definitions/datedRecords/items/1", spec.MustCreateRef("#/definitions/datedRecordsItems1"), }, {"#/definitions/datedTaggedRecords/items/1", "#/definitions/datedTaggedRecords/items/1", spec.MustCreateRef("#/definitions/datedTaggedRecordsItems1"), }, {"#/definitions/namedThing/properties/name", "#/definitions/namedThing/properties/name", spec.MustCreateRef("#/definitions/namedThingName"), }, {"#/definitions/nestedThing/properties/record", "#/definitions/nestedThing/properties/record", spec.MustCreateRef("#/definitions/nestedThingRecord"), }, {"#/definitions/records/items/0", "#/definitions/records/items/0", spec.MustCreateRef("#/definitions/recordsItems0"), }, {"#/definitions/datedTaggedRecords/additionalItems", "#/definitions/datedTaggedRecords/additionalItems", spec.MustCreateRef("#/definitions/datedTaggedRecordsItemsAdditionalItems"), }, {"#/definitions/otherRecords/items", "#/definitions/otherRecords/items", spec.MustCreateRef("#/definitions/otherRecordsItems"), }, {"#/definitions/tags/additionalProperties", "#/definitions/tags/additionalProperties", spec.MustCreateRef("#/definitions/tagsAdditionalProperties"), }, } bp := filepath.Join("fixtures", "nested_inline_schemas.yml") sp := antest.LoadOrFail(t, bp) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{ RelativeBase: bp, SkipSchemas: true, })) require.NoError(t, nameInlinedSchemas(&FlattenOpts{ Spec: New(sp), BasePath: bp, })) for i, v := range values { ptr, err := jsonpointer.New(v.Location[1:]) require.NoErrorf(t, err, "at %d for %s", i, v.Key) vv, _, err := ptr.Get(sp) require.NoErrorf(t, err, "at %d for %s", i, v.Key) switch tv := vv.(type) { case spec.Schema: assert.Equal(t, v.Ref.String(), tv.Ref.String(), "at %d for %s", i, v.Key) case spec.Schema: assert.Equal(t, v.Ref.String(), tv.Ref.String(), "at %d for %s", i, v.Key) case spec.SchemaOrBool: var sRef spec.Ref if tv != nil && tv.Schema != nil { sRef = tv.Schema.Ref } assert.Equal(t, v.Ref.String(), sRef.String(), "at %d for %s", i, v.Key) case spec.SchemaOrArray: var sRef spec.Ref if tv != nil && tv.Schema != nil { sRef = tv.Schema.Ref } assert.Equal(t, v.Ref.String(), sRef.String(), "at %d for %s", i, v.Key) default: assert.Fail(t, "unknown type", "got %T", vv) } } for k, rr := range New(sp).allSchemas { if strings.HasPrefix(k, "#/responses") \|\| strings.HasPrefix(k, "#/parameters") { continue } if rr.Schema == nil \|\| rr.Schema.Ref.String() != "" \|\| rr.TopLevel { continue } asch, err := Schema(SchemaOpts{Schema: rr.Schema, Root: sp, BasePath: bp}) require.NoErrorf(t, err, "for key: %s", k) if !asch.IsSimpleSchema && !asch.IsArray && !asch.IsMap { assert.Fail(t, "not a top level schema", "for key: %s", k) } } } func TestFlattenSchema_UnitGuards(t testing.T) { t.Parallel() parts := sortref.KeyParts("#/nowhere/arbitrary/pointer") res := GenLocation(parts) assert.Equal(t, "", res) } func definitionPtr(key string) string { if !strings.HasPrefix(key, "#/definitions") { return key } return strings.Join(strings.Split(key, "/")[:3], "/") }	16.63 KB	2025-05-25 12:27
📄 flatten_options.go package analysis import ( "log" "github.com/go-openapi/spec" ) // FlattenOpts configuration for flattening a swagger specification. // // The BasePath parameter is used to locate remote relative $ref found in the specification. // This path is a file: it points to the location of the root document and may be either a local // file path or a URL. // // If none specified, relative references (e.g. "$ref": "folder/schema.yaml#/definitions/...") // found in the spec are searched from the current working directory. type FlattenOpts struct { Spec Spec // The analyzed spec to work with flattenContext context // Internal context to track flattening activity BasePath string // The location of the root document for this spec to resolve relative $ref // Flattening options Expand bool // When true, skip flattening the spec and expand it instead (if Minimal is false) Minimal bool // When true, do not decompose complex structures such as allOf Verbose bool // enable some reporting on possible name conflicts detected RemoveUnused bool // When true, remove unused parameters, responses and definitions after expansion/flattening ContinueOnError bool // Continue when spec expansion issues are found KeepNames bool // Do not attempt to jsonify names from references when flattening /* Extra keys / _ struct{} // require keys } // ExpandOpts creates a spec.ExpandOptions to configure expanding a specification document. func (f FlattenOpts) ExpandOpts(skipSchemas bool) spec.ExpandOptions { return &spec.ExpandOptions{ RelativeBase: f.BasePath, SkipSchemas: skipSchemas, ContinueOnError: f.ContinueOnError, } } // Swagger gets the swagger specification for this flatten operation func (f FlattenOpts) Swagger() spec.Swagger { return f.Spec.spec } // croak logs notifications and warnings about valid, but possibly unwanted constructs resulting // from flattening a spec func (f FlattenOpts) croak() { if !f.Verbose { return } reported := make(map[string]bool, len(f.flattenContext.newRefs)) for _, v := range f.Spec.references.allRefs { // warns about duplicate handling for _, r := range f.flattenContext.newRefs { if r.isOAIGen && r.path == v.String() { reported[r.newName] = true } } } for k := range reported { log.Printf("warning: duplicate flattened definition name resolved as %s", k) } // warns about possible type mismatches uniqueMsg := make(map[string]bool) for _, msg := range f.flattenContext.warnings { if _, ok := uniqueMsg[msg]; ok { continue } log.Printf("warning: %s", msg) uniqueMsg[msg] = true } }	2.59 KB	2025-05-25 12:27
📄 flatten_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "bytes" "encoding/json" "fmt" "io" "log" "os" "path" "path/filepath" "regexp" "strings" "testing" "github.com/go-openapi/analysis/internal/antest" "github.com/go-openapi/analysis/internal/flatten/operations" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/spec" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( rex = regexp.MustCompile(`"\$ref":\s"(.+)"`) oairex = regexp.MustCompile(`oiagen`) ) type refFixture struct { Key string Ref spec.Ref Location string Expected interface{} } func makeRefFixtures() []refFixture { return []refFixture{ {Key: "#/parameters/someParam/schema", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/paths/~1some~1where~1{id}/parameters/1/schema", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/paths/~1some~1where~1{id}/get/parameters/2/schema", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/responses/someResponse/schema", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/paths/~1some~1where~1{id}/get/responses/default/schema", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/paths/~1some~1where~1{id}/get/responses/200/schema", Ref: spec.MustCreateRef("#/definitions/tag")}, {Key: "#/definitions/namedAgain", Ref: spec.MustCreateRef("#/definitions/named")}, {Key: "#/definitions/datedTag/allOf/1", Ref: spec.MustCreateRef("#/definitions/tag")}, {Key: "#/definitions/datedRecords/items/1", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/definitions/datedTaggedRecords/items/1", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/definitions/datedTaggedRecords/additionalItems", Ref: spec.MustCreateRef("#/definitions/tag")}, {Key: "#/definitions/otherRecords/items", Ref: spec.MustCreateRef("#/definitions/record")}, {Key: "#/definitions/tags/additionalProperties", Ref: spec.MustCreateRef("#/definitions/tag")}, {Key: "#/definitions/namedThing/properties/name", Ref: spec.MustCreateRef("#/definitions/named")}, } } func TestFlatten_ImportExternalReferences(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) // this fixture is the same as external_definitions.yml, but no more // checks if invalid construct is supported (i.e. $ref in parameters items) bp := filepath.Join(".", "fixtures", "external_definitions_valid.yml") sp := antest.LoadOrFail(t, bp) opts := &FlattenOpts{ Spec: New(sp), BasePath: bp, } // NOTE(fredbi): now we no more expand, but merely resolve and iterate until there is no more ext ref // so calling importExternalReferences is not idempotent _, erx := importExternalReferences(opts) require.NoError(t, erx) require.Len(t, sp.Definitions, 11) require.Contains(t, sp.Definitions, "tag") require.Contains(t, sp.Definitions, "named") require.Contains(t, sp.Definitions, "record") for idx, toPin := range makeRefFixtures() { i := idx v := toPin sp := sp // the pointer passed to Get(node) must be pinned t.Run(fmt.Sprintf("import check ref [%d]: %q", i, v.Key), func(t testing.T) { t.Parallel() ptr, err := jsonpointer.New(v.Key[1:]) require.NoErrorf(t, err, "error on jsonpointer.New(%q)", v.Key[1:]) vv, _, err := ptr.Get(sp) require.NoErrorf(t, err, "error on ptr.Get(p for key=%s)", v.Key[1:]) switch tv := vv.(type) { case spec.Schema: require.Equal(t, v.Ref.String(), tv.Ref.String(), "for %s", v.Key) case spec.Schema: require.Equal(t, v.Ref.String(), tv.Ref.String(), "for %s", v.Key) case spec.SchemaOrBool: require.Equal(t, v.Ref.String(), tv.Schema.Ref.String(), "for %s", v.Key) case spec.SchemaOrArray: require.Equal(t, v.Ref.String(), tv.Schema.Ref.String(), "for %s", v.Key) default: require.Fail(t, "unknown type", "got %T", vv) } }) } // check the complete result for clarity jazon := antest.AsJSON(t, sp) expected, err := os.ReadFile(filepath.Join("fixtures", "expected", "external-references-1.json")) require.NoError(t, err) assert.JSONEq(t, string(expected), jazon) // iterate again: this time all external schema $ref's should be reinlined opts.Spec.reload() _, err = importExternalReferences(&FlattenOpts{ Spec: New(sp), BasePath: bp, }) require.NoError(t, err) opts.Spec.reload() for _, ref := range opts.Spec.references.schemas { require.True(t, ref.HasFragmentOnly) } // now try complete flatten, with unused definitions removed sp = antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: true})) jazon = antest.AsJSON(t, an.spec) expected, err = os.ReadFile(filepath.Join("fixtures", "expected", "external-references-2.json")) require.NoError(t, err) assert.JSONEq(t, string(expected), jazon) } func makeFlattenFixtures() []refFixture { return []refFixture{ { Key: "#/responses/notFound/schema", Location: "#/responses/notFound/schema", Ref: spec.MustCreateRef("#/definitions/error"), Expected: nil, }, { Key: "#/paths/~1some~1where~1{id}/parameters/0", Location: "#/paths/~1some~1where~1{id}/parameters/0/name", Ref: spec.Ref{}, Expected: "id", }, { Key: "#/paths/~1other~1place", Location: "#/paths/~1other~1place/get/operationId", Ref: spec.Ref{}, Expected: "modelOp", }, { Key: "#/paths/~1some~1where~1{id}/get/parameters/0", Location: "#/paths/~1some~1where~1{id}/get/parameters/0/name", Ref: spec.Ref{}, Expected: "limit", }, { Key: "#/paths/~1some~1where~1{id}/get/parameters/1", Location: "#/paths/~1some~1where~1{id}/get/parameters/1/name", Ref: spec.Ref{}, Expected: "some", }, { Key: "#/paths/~1some~1where~1{id}/get/parameters/2", Location: "#/paths/~1some~1where~1{id}/get/parameters/2/name", Ref: spec.Ref{}, Expected: "other", }, { Key: "#/paths/~1some~1where~1{id}/get/parameters/3", Location: "#/paths/~1some~1where~1{id}/get/parameters/3/schema", Ref: spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBody"), Expected: "", }, { Key: "#/paths/~1some~1where~1{id}/get/responses/200", Location: "#/paths/~1some~1where~1{id}/get/responses/200/schema", Ref: spec.MustCreateRef("#/definitions/getSomeWhereIdOKBody"), Expected: "", }, { Key: "#/definitions/namedAgain", Location: "", Ref: spec.MustCreateRef("#/definitions/named"), Expected: "", }, { Key: "#/definitions/namedThing/properties/name", Location: "", Ref: spec.MustCreateRef("#/definitions/named"), Expected: "", }, { Key: "#/definitions/namedThing/properties/namedAgain", Location: "", Ref: spec.MustCreateRef("#/definitions/namedAgain"), Expected: "", }, { Key: "#/definitions/datedRecords/items/1", Location: "", Ref: spec.MustCreateRef("#/definitions/record"), Expected: "", }, { Key: "#/definitions/otherRecords/items", Location: "", Ref: spec.MustCreateRef("#/definitions/record"), Expected: "", }, { Key: "#/definitions/tags/additionalProperties", Location: "", Ref: spec.MustCreateRef("#/definitions/tag"), Expected: "", }, { Key: "#/definitions/datedTag/allOf/1", Location: "", Ref: spec.MustCreateRef("#/definitions/tag"), Expected: "", }, { Key: "#/definitions/nestedThingRecord/items/1", Location: "", Ref: spec.MustCreateRef("#/definitions/nestedThingRecordItems1"), Expected: "", }, { Key: "#/definitions/nestedThingRecord/items/2", Location: "", Ref: spec.MustCreateRef("#/definitions/nestedThingRecordItems2"), Expected: "", }, { Key: "#/definitions/nestedThing/properties/record", Location: "", Ref: spec.MustCreateRef("#/definitions/nestedThingRecord"), Expected: "", }, { Key: "#/definitions/named", Location: "#/definitions/named/type", Ref: spec.Ref{}, Expected: spec.StringOrArray{"string"}, }, { Key: "#/definitions/error", Location: "#/definitions/error/properties/id/type", Ref: spec.Ref{}, Expected: spec.StringOrArray{"integer"}, }, { Key: "#/definitions/record", Location: "#/definitions/record/properties/createdAt/format", Ref: spec.Ref{}, Expected: "date-time", }, { Key: "#/definitions/getSomeWhereIdOKBody", Location: "#/definitions/getSomeWhereIdOKBody/properties/record", Ref: spec.MustCreateRef("#/definitions/nestedThing"), Expected: nil, }, { Key: "#/definitions/getSomeWhereIdParamsBody", Location: "#/definitions/getSomeWhereIdParamsBody/properties/record", Ref: spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecord"), Expected: nil, }, { Key: "#/definitions/getSomeWhereIdParamsBodyRecord", Location: "#/definitions/getSomeWhereIdParamsBodyRecord/items/1", Ref: spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecordItems1"), Expected: nil, }, { Key: "#/definitions/getSomeWhereIdParamsBodyRecord", Location: "#/definitions/getSomeWhereIdParamsBodyRecord/items/2", Ref: spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecordItems2"), Expected: nil, }, { Key: "#/definitions/getSomeWhereIdParamsBodyRecordItems2", Location: "#/definitions/getSomeWhereIdParamsBodyRecordItems2/allOf/0/format", Ref: spec.Ref{}, Expected: "date", }, { Key: "#/definitions/getSomeWhereIdParamsBodyRecordItems2Name", Location: "#/definitions/getSomeWhereIdParamsBodyRecordItems2Name/properties/createdAt/format", Ref: spec.Ref{}, Expected: "date-time", }, { Key: "#/definitions/getSomeWhereIdParamsBodyRecordItems2", Location: "#/definitions/getSomeWhereIdParamsBodyRecordItems2/properties/name", Ref: spec.MustCreateRef("#/definitions/getSomeWhereIdParamsBodyRecordItems2Name"), Expected: "date", }, } } func TestFlatten_CheckRef(t testing.T) { bp := filepath.Join("fixtures", "flatten.yml") sp := antest.LoadOrFail(t, bp) require.NoError(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp})) for idx, toPin := range makeFlattenFixtures() { i := idx v := toPin sp := sp t.Run(fmt.Sprintf("check ref after flatten %q", v.Key), func(t testing.T) { pk := v.Key[1:] if v.Location != "" { pk = v.Location[1:] } ptr, err := jsonpointer.New(pk) require.NoError(t, err, "at %d for %s", i, v.Key) d, _, err := ptr.Get(sp) require.NoError(t, err) if v.Ref.String() == "" { assert.Equal(t, v.Expected, d) return } switch s := d.(type) { case spec.Schema: assert.Equal(t, v.Ref.String(), s.Ref.String(), "at %d for %s", i, v.Key) case spec.Schema: assert.Equal(t, v.Ref.String(), s.Ref.String(), "at %d for %s", i, v.Key) case spec.SchemaOrArray: var sRef spec.Ref if s != nil && s.Schema != nil { sRef = s.Schema.Ref } assert.Equal(t, v.Ref.String(), sRef.String(), "at %d for %s", i, v.Key) case spec.SchemaOrBool: var sRef spec.Ref if s != nil && s.Schema != nil { sRef = s.Schema.Ref } assert.Equal(t, v.Ref.String(), sRef.String(), "at %d for %s", i, v.Key) default: assert.Fail(t, "unknown type", "got %T at %d for %s", d, i, v.Key) } }) } } func TestFlatten_FullWithOAIGen(t testing.T) { bp := filepath.Join("fixtures", "oaigen", "fixture-oaigen.yaml") sp := antest.LoadOrFail(t, bp) require.NoError(t, Flatten(FlattenOpts{ Spec: New(sp), BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: false, })) res := getInPath(t, sp, "/some/where", "/get/responses/204/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/uniqueName1"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/post/responses/204/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/d"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/get/responses/206/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/a"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/get/responses/304/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/transitive11"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/get/responses/205/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/b"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/post/responses/200/schema") assert.JSONEqf(t, `{"type": "integer"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/post/responses/default/schema") // pointer expanded assert.JSONEqf(t, `{"type": "integer"}`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "a") assert.JSONEqf(t, `{"type": "object", "properties": { "a": { "$ref": "#/definitions/aAOAIGen" }}}`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "aA") assert.JSONEqf(t, `{"type": "string", "format": "date"}`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "aAOAIGen") assert.JSONEqf(t, ` { "type": "object", "properties": { "b": { "type": "integer" } }, "x-go-gen-location": "models" } `, res, "Expected a simple schema for response") res = getDefinition(t, sp, "bB") assert.JSONEqf(t, `{"type": "string", "format": "date-time"}`, res, "Expected a simple schema for response") _, ok := sp.Definitions["bItems"] assert.Falsef(t, ok, "Did not expect a definition for %s", "bItems") res = getDefinition(t, sp, "d") assert.JSONEqf(t, ` { "type": "object", "properties": { "c": { "type": "integer" } } } `, res, "Expected a simple schema for response") res = getDefinition(t, sp, "b") assert.JSONEqf(t, ` { "type": "array", "items": { "$ref": "#/definitions/d" } } `, res, "Expected a ref in response") res = getDefinition(t, sp, "myBody") assert.JSONEqf(t, ` { "type": "object", "properties": { "aA": { "$ref": "#/definitions/aA" }, "prop1": { "type": "integer" } } } `, res, "Expected a simple schema for response") res = getDefinition(t, sp, "uniqueName2") assert.JSONEqf(t, `{"$ref": "#/definitions/notUniqueName2"}`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "notUniqueName2") assert.JSONEqf(t, ` { "type": "object", "properties": { "prop6": { "type": "integer" } } } `, res, "Expected a simple schema for response") res = getDefinition(t, sp, "uniqueName1") assert.JSONEqf(t, `{ "type": "object", "properties": { "prop5": { "type": "integer" }}}`, res, "Expected a simple schema for response") // allOf container: []spec.Schema res = getDefinition(t, sp, "getWithSliceContainerDefaultBody") assert.JSONEqf(t, `{ "allOf": [ { "$ref": "#/definitions/uniqueName3" }, { "$ref": "#/definitions/getWithSliceContainerDefaultBodyAllOf1" } ], "x-go-gen-location": "operations" }`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "getWithSliceContainerDefaultBodyAllOf1") assert.JSONEqf(t, `{ "type": "object", "properties": { "prop8": { "type": "string" } }, "x-go-gen-location": "models" }`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "getWithTupleContainerDefaultBody") assert.JSONEqf(t, `{ "type": "array", "items": [ { "$ref": "#/definitions/uniqueName3" }, { "$ref": "#/definitions/getWithSliceContainerDefaultBodyAllOf1" } ], "x-go-gen-location": "operations" }`, res, "Expected a simple schema for response") // with container SchemaOrArray res = getDefinition(t, sp, "getWithTupleConflictDefaultBody") assert.JSONEqf(t, `{ "type": "array", "items": [ { "$ref": "#/definitions/uniqueName4" }, { "$ref": "#/definitions/getWithTupleConflictDefaultBodyItems1" } ], "x-go-gen-location": "operations" }`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "getWithTupleConflictDefaultBodyItems1") assert.JSONEqf(t, `{ "type": "object", "properties": { "prop10": { "type": "string" } }, "x-go-gen-location": "models" }`, res, "Expected a simple schema for response") } func TestFlatten_MinimalWithOAIGen(t testing.T) { var sp spec.Swagger defer func() { if t.Failed() && sp != nil { t.Log(antest.AsJSON(t, sp)) } }() bp := filepath.Join("fixtures", "oaigen", "fixture-oaigen.yaml") sp = antest.LoadOrFail(t, bp) var logCapture bytes.Buffer log.SetOutput(&logCapture) defer log.SetOutput(os.Stdout) require.NoError(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) msg := logCapture.String() if !assert.NotContainsf(t, msg, "warning: duplicate flattened definition name resolved as aAOAIGen", "Expected log message") { t.Logf("Captured log: %s", msg) } if !assert.NotContainsf(t, msg, "warning: duplicate flattened definition name resolved as uniqueName2OAIGen", "Expected log message") { t.Logf("Captured log: %s", msg) } res := getInPath(t, sp, "/some/where", "/get/responses/204/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/uniqueName1"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/post/responses/204/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/d"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/get/responses/206/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/a"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/get/responses/304/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/transitive11"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/get/responses/205/schema") assert.JSONEqf(t, `{"$ref": "#/definitions/b"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/post/responses/200/schema") assert.JSONEqf(t, `{"type": "integer"}`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where", "/post/responses/default/schema") // This JSON pointer is expanded assert.JSONEqf(t, `{"type": "integer"}`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "aA") assert.JSONEqf(t, `{"type": "string", "format": "date"}`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "a") assert.JSONEqf(t, `{ "type": "object", "properties": { "a": { "type": "object", "properties": { "b": { "type": "integer" } } } } }`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "bB") assert.JSONEqf(t, `{"type": "string", "format": "date-time"}`, res, "Expected a simple schema for response") _, ok := sp.Definitions["bItems"] assert.Falsef(t, ok, "Did not expect a definition for %s", "bItems") res = getDefinition(t, sp, "d") assert.JSONEqf(t, `{ "type": "object", "properties": { "c": { "type": "integer" } } }`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "b") assert.JSONEqf(t, `{ "type": "array", "items": { "$ref": "#/definitions/d" } }`, res, "Expected a ref in response") res = getDefinition(t, sp, "myBody") assert.JSONEqf(t, `{ "type": "object", "properties": { "aA": { "$ref": "#/definitions/aA" }, "prop1": { "type": "integer" } } }`, res, "Expected a simple schema for response") res = getDefinition(t, sp, "uniqueName2") assert.JSONEqf(t, `{"$ref": "#/definitions/notUniqueName2"}`, res, "Expected a simple schema for response") // with allOf container: []spec.Schema res = getInPath(t, sp, "/with/slice/container", "/get/responses/default/schema") assert.JSONEqf(t, `{ "allOf": [ { "$ref": "#/definitions/uniqueName3" }, { "$ref": "#/definitions/getWithSliceContainerDefaultBodyAllOf1" } ] }`, res, "Expected a simple schema for response") // with tuple container res = getInPath(t, sp, "/with/tuple/container", "/get/responses/default/schema") assert.JSONEqf(t, `{ "type": "array", "items": [ { "$ref": "#/definitions/uniqueName3" }, { "$ref": "#/definitions/getWithSliceContainerDefaultBodyAllOf1" } ] }`, res, "Expected a simple schema for response") // with SchemaOrArray container res = getInPath(t, sp, "/with/tuple/conflict", "/get/responses/default/schema") assert.JSONEqf(t, `{ "type": "array", "items": [ { "$ref": "#/definitions/uniqueName4" }, { "type": "object", "properties": { "prop10": { "type": "string" } } } ] }`, res, "Expected a simple schema for response") } func assertNoOAIGen(t testing.T, bp string, sp spec.Swagger) (success bool) { var logCapture bytes.Buffer log.SetOutput(&logCapture) defer log.SetOutput(os.Stdout) defer func() { success = !t.Failed() }() require.NoError(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: false})) msg := logCapture.String() assert.NotContains(t, msg, "warning") for k := range sp.Definitions { require.NotContains(t, k, "OAIGen") } return } func TestFlatten_OAIGen(t testing.T) { for _, fixture := range []string{ filepath.Join("fixtures", "oaigen", "test3-swagger.yaml"), filepath.Join("fixtures", "oaigen", "test3-bis-swagger.yaml"), filepath.Join("fixtures", "oaigen", "test3-ter-swagger.yaml"), } { t.Run("flatten_oiagen_1260_"+fixture, func(t testing.T) { t.Parallel() bp := filepath.Join("fixtures", "oaigen", "test3-swagger.yaml") sp := antest.LoadOrFail(t, bp) require.Truef(t, assertNoOAIGen(t, bp, sp), "did not expect an OAIGen definition here") }) } } func TestMoreNameInlinedSchemas(t testing.T) { bp := filepath.Join("fixtures", "more_nested_inline_schemas.yml") sp := antest.LoadOrFail(t, bp) require.NoError(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: false})) res := getInPath(t, sp, "/some/where/{id}", "/post/responses/200/schema") assert.JSONEqf(t, ` { "type": "object", "additionalProperties": { "type": "object", "additionalProperties": { "type": "object", "additionalProperties": { "$ref": "#/definitions/postSomeWhereIdOKBodyAdditionalPropertiesAdditionalPropertiesAdditionalProperties" } } } }`, res, "Expected a simple schema for response") res = getInPath(t, sp, "/some/where/{id}", "/post/responses/204/schema") assert.JSONEqf(t, ` { "type": "object", "additionalProperties": { "type": "array", "items": { "type": "object", "additionalProperties": { "type": "array", "items": { "type": "object", "additionalProperties": { "type": "array", "items": { "$ref": "#/definitions/postSomeWhereIdNoContentBodyAdditionalPropertiesItemsAdditionalPropertiesItemsAdditionalPropertiesItems" } } } } } } } `, res, "Expected a simple schema for response") } func TestRemoveUnused(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "oaigen", "fixture-oaigen.yaml") sp := antest.LoadOrFail(t, bp) require.NoError(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Verbose: false, Minimal: true, RemoveUnused: true})) assert.Nil(t, sp.Parameters) assert.Nil(t, sp.Responses) bp = filepath.Join("fixtures", "parameters", "fixture-parameters.yaml") sp = antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: false, Minimal: true, RemoveUnused: true})) assert.Nil(t, sp.Parameters) assert.Nil(t, sp.Responses) op, ok := an.OperationFor("GET", "/some/where") assert.True(t, ok) assert.Lenf(t, op.Parameters, 4, "Expected 4 parameters expanded for this operation") assert.Lenf(t, an.ParamsFor("GET", "/some/where"), 7, "Expected 7 parameters (with default) expanded for this operation") op, ok = an.OperationFor("PATCH", "/some/remote") assert.True(t, ok) assert.Lenf(t, op.Parameters, 1, "Expected 1 parameter expanded for this operation") assert.Lenf(t, an.ParamsFor("PATCH", "/some/remote"), 2, "Expected 2 parameters (with default) expanded for this operation") _, ok = sp.Definitions["unused"] assert.False(t, ok, "Did not expect to find #/definitions/unused") bp = filepath.Join("fixtures", "parameters", "fixture-parameters.yaml") sp = antest.LoadOrFail(t, bp) require.NoError(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: true})) assert.Nil(t, sp.Parameters) assert.Nil(t, sp.Responses) _, ok = sp.Definitions["unused"] assert.Falsef(t, ok, "Did not expect to find #/definitions/unused") } func TestOperationIDs(t testing.T) { bp := filepath.Join("fixtures", "operations", "fixture-operations.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: false, Minimal: false, RemoveUnused: false})) t.Run("should GatherOperations", func(t testing.T) { res := operations.GatherOperations(New(sp), []string{"getSomeWhere", "getSomeWhereElse"}) assert.Containsf(t, res, "getSomeWhere", "expected to find operation") assert.Containsf(t, res, "getSomeWhereElse", "expected to find operation") assert.NotContainsf(t, res, "postSomeWhere", "did not expect to find operation") }) op, ok := an.OperationFor("GET", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("getSomeWhereElse"), 2) op, ok = an.OperationFor("POST", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("postSomeWhereElse"), 1) op, ok = an.OperationFor("PUT", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("putSomeWhereElse"), 1) op, ok = an.OperationFor("PATCH", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("patchSomeWhereElse"), 1) op, ok = an.OperationFor("DELETE", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("deleteSomeWhereElse"), 1) op, ok = an.OperationFor("HEAD", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("headSomeWhereElse"), 1) op, ok = an.OperationFor("OPTIONS", "/some/where/else") assert.True(t, ok) assert.NotNil(t, op) assert.Len(t, an.ParametersFor("optionsSomeWhereElse"), 1) assert.Empty(t, an.ParametersFor("outOfThisWorld")) } func TestFlatten_Pointers(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "pointers", "fixture-pointers.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) // re-analyse and check all $ref's point to #/definitions bn := New(sp) for _, r := range bn.AllRefs() { assert.Equal(t, definitionsPath, path.Dir(r.String())) } } // unit test guards in flatten not easily testable with actual specs func TestFlatten_ErrorHandling(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) const wantedFailure = "Expected a failure" bp := filepath.Join("fixtures", "errors", "fixture-unexpandable.yaml") // invalid spec expansion sp := antest.LoadOrFail(t, bp) require.Errorf(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Expand: true}), wantedFailure) // reload original spec sp = antest.LoadOrFail(t, bp) require.Errorf(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Expand: false}), wantedFailure) bp = filepath.Join("fixtures", "errors", "fixture-unexpandable-2.yaml") sp = antest.LoadOrFail(t, bp) require.Errorf(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Expand: false}), wantedFailure) // reload original spec sp = antest.LoadOrFail(t, bp) require.Errorf(t, Flatten(FlattenOpts{Spec: New(sp), BasePath: bp, Minimal: true, Expand: false}), wantedFailure) } func TestFlatten_PointersLoop(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "pointers", "fixture-pointers-loop.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.Error(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) } func TestFlatten_Bitbucket(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "bugs", "bitbucket.json") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) // reload original spec sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: false})) // reload original spec sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Expand: true, RemoveUnused: false})) // reload original spec sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Expand: true, RemoveUnused: true})) assert.Len(t, sp.Definitions, 2) // only 2 remaining refs after expansion: circular $ref _, ok := sp.Definitions["base_commit"] assert.True(t, ok) _, ok = sp.Definitions["repository"] assert.True(t, ok) } func TestFlatten_Issue_1602(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) // $ref as schema to #/responses or #/parameters // minimal repro test case bp := filepath.Join("fixtures", "bugs", "1602", "fixture-1602-1.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, RemoveUnused: false, })) // reload spec sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: false, Minimal: false, Expand: false, RemoveUnused: false, })) // reload spec // with prior expansion, a pseudo schema is produced sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: false, Minimal: false, Expand: true, RemoveUnused: false, })) } func TestFlatten_Issue_1602_All(t testing.T) { for _, toPin := range []string{ filepath.Join("fixtures", "bugs", "1602", "fixture-1602-full.yaml"), filepath.Join("fixtures", "bugs", "1602", "fixture-1602-1.yaml"), filepath.Join("fixtures", "bugs", "1602", "fixture-1602-2.yaml"), filepath.Join("fixtures", "bugs", "1602", "fixture-1602-3.yaml"), filepath.Join("fixtures", "bugs", "1602", "fixture-1602-4.yaml"), filepath.Join("fixtures", "bugs", "1602", "fixture-1602-5.yaml"), filepath.Join("fixtures", "bugs", "1602", "fixture-1602-6.yaml"), } { fixture := toPin t.Run("issue_1602_all_"+fixture, func(t testing.T) { t.Parallel() sp := antest.LoadOrFail(t, fixture) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: fixture, Verbose: false, Minimal: true, Expand: false, RemoveUnused: false, })) }) } } func TestFlatten_Issue_1614(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) // $ref as schema to #/responses or #/parameters // test warnings bp := filepath.Join("fixtures", "bugs", "1614", "gitea.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, RemoveUnused: false})) // check that responses subject to warning have been expanded jazon := antest.AsJSON(t, sp) assert.NotContains(t, jazon, `#/responses/forbidden`) assert.NotContains(t, jazon, `#/responses/empty`) } func TestFlatten_Issue_1621(t testing.T) { // repeated remote refs // minimal repro test case bp := filepath.Join("fixtures", "bugs", "1621", "fixture-1621.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, RemoveUnused: false, })) sch1 := sp.Paths.Paths["/v4/users/"].Get.Responses.StatusCodeResponses[200].Schema jazon := antest.AsJSON(t, sch1) assert.JSONEq(t, `{"type": "array", "items": {"$ref": "#/definitions/v4UserListItem" }}`, jazon) sch2 := sp.Paths.Paths["/v4/user/"].Get.Responses.StatusCodeResponses[200].Schema jazon = antest.AsJSON(t, sch2) assert.JSONEq(t, `{"$ref": "#/definitions/v4UserListItem"}`, jazon) sch3 := sp.Paths.Paths["/v4/users/{email}/"].Get.Responses.StatusCodeResponses[200].Schema jazon = antest.AsJSON(t, sch3) assert.JSONEq(t, `{"$ref": "#/definitions/v4UserListItem"}`, jazon) } func TestFlatten_Issue_1796(t testing.T) { // remote cyclic ref bp := filepath.Join("fixtures", "bugs", "1796", "queryIssue.json") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, RemoveUnused: false, })) // assert all $ref match "$ref": "#/definitions/something" for _, ref := range an.AllReferences() { assert.True(t, strings.HasPrefix(ref, "#/definitions")) } } func TestFlatten_Issue_1767(t testing.T) { // remote cyclic ref again bp := filepath.Join("fixtures", "bugs", "1767", "fixture-1767.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, RemoveUnused: false, })) // assert all $ref match "$ref": "#/definitions/something" for _, ref := range an.AllReferences() { assert.True(t, strings.HasPrefix(ref, "#/definitions")) } } func TestFlatten_Issue_1774(t testing.T) { // remote cyclic ref again bp := filepath.Join("fixtures", "bugs", "1774", "def_api.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: false, Expand: false, RemoveUnused: false, })) // assert all $ref match "$ref": "#/definitions/something" for _, ref := range an.AllReferences() { assert.True(t, strings.HasPrefix(ref, "#/definitions")) } } func TestFlatten_1429(t testing.T) { // nested / remote $ref in response / param schemas // issue go-swagger/go-swagger#1429 bp := filepath.Join("fixtures", "bugs", "1429", "swagger.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false, })) } func TestFlatten_1851(t testing.T) { // nested / remote $ref in response / param schemas // issue go-swagger/go-swagger#1851 bp := filepath.Join("fixtures", "bugs", "1851", "fixture-1851.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false, })) serverDefinition, ok := an.spec.Definitions["server"] assert.True(t, ok) serverStatusDefinition, ok := an.spec.Definitions["serverStatus"] assert.True(t, ok) serverStatusProperty, ok := serverDefinition.Properties["Status"] assert.True(t, ok) jazon := antest.AsJSON(t, serverStatusProperty) assert.JSONEq(t, `{"$ref": "#/definitions/serverStatus"}`, jazon) jazon = antest.AsJSON(t, serverStatusDefinition) assert.JSONEq(t, `{"type": "string", "enum": [ "OK", "Not OK" ]}`, jazon) // additional test case: this one used to work bp = filepath.Join("fixtures", "bugs", "1851", "fixture-1851-2.yaml") sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) serverDefinition, ok = an.spec.Definitions["Server"] assert.True(t, ok) serverStatusDefinition, ok = an.spec.Definitions["ServerStatus"] assert.True(t, ok) serverStatusProperty, ok = serverDefinition.Properties["Status"] assert.True(t, ok) jazon = antest.AsJSON(t, serverStatusProperty) assert.JSONEq(t, `{"$ref": "#/definitions/ServerStatus"}`, jazon) jazon = antest.AsJSON(t, serverStatusDefinition) assert.JSONEq(t, `{"type": "string", "enum": [ "OK", "Not OK" ]}`, jazon) } func TestFlatten_RemoteAbsolute(t testing.T) { for _, toPin := range []string{ // this one has simple remote ref pattern filepath.Join("fixtures", "bugs", "remote-absolute", "swagger-mini.json"), // this has no remote ref filepath.Join("fixtures", "bugs", "remote-absolute", "swagger.json"), // this one has local ref, no naming conflict (same as previous but with external ref imported) filepath.Join("fixtures", "bugs", "remote-absolute", "swagger-with-local-ref.json"), // this one has remote ref, no naming conflict (same as previous but with external ref imported) filepath.Join("fixtures", "bugs", "remote-absolute", "swagger-with-remote-only-ref.json"), } { fixture := toPin t.Run("remote_absolute_"+fixture, func(t testing.T) { t.Parallel() an := testFlattenWithDefaults(t, fixture) checkRefs(t, an.spec, true) }) } // This one has both remote and local ref with naming conflict. // This creates some "oiagen" definitions to address naming conflict, // which are removed by the oaigen pruning process (reinlined / merged with parents). an := testFlattenWithDefaults(t, filepath.Join("fixtures", "bugs", "remote-absolute", "swagger-with-ref.json")) checkRefs(t, an.spec, false) } func TestFlatten_2092(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "bugs", "2092", "swagger.yaml") rexOAIGen := regexp.MustCompile(`(?i)("\$ref":\s")(.?oaigen.?)"`) // #2092 exhibits a stability issue: repeat 100 times the process to make sure it is stable sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) firstJSONMinimal := antest.AsJSON(t, an.spec) // verify we don't have dangling oaigen refs require.Falsef(t, rexOAIGen.MatchString(firstJSONMinimal), "unmatched regexp for: %s", firstJSONMinimal) sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: false})) firstJSONFull := antest.AsJSON(t, an.spec) // verify we don't have dangling oaigen refs require.Falsef(t, rexOAIGen.MatchString(firstJSONFull), "unmatched regexp for: %s", firstJSONFull) for i := 0; i < 10; i++ { t.Run(fmt.Sprintf("issue_2092_%d", i), func(t testing.T) { t.Parallel() // verify that we produce a stable result sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false})) jazon := antest.AsJSON(t, an.spec) assert.JSONEq(t, firstJSONMinimal, jazon) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: true})) sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{Spec: an, BasePath: bp, Verbose: true, Minimal: false, RemoveUnused: false})) jazon = antest.AsJSON(t, an.spec) assert.JSONEq(t, firstJSONFull, jazon) }) } } func TestFlatten_2113(t testing.T) { // flatten $ref under path log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "bugs", "2113", "base.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Expand: true, RemoveUnused: false, })) sp = antest.LoadOrFail(t, bp) an = New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false, })) jazon := antest.AsJSON(t, sp) expected, err := os.ReadFile(filepath.Join("fixtures", "expected", "issue-2113.json")) require.NoError(t, err) require.JSONEq(t, string(expected), jazon) } func TestFlatten_2334(t testing.T) { // flatten $ref without altering case log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "bugs", "2334", "swagger.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: false, Expand: false, Minimal: true, RemoveUnused: true, KeepNames: true, })) jazon := antest.AsJSON(t, sp) assert.Contains(t, jazon, `"$ref": "#/definitions/Bar"`) assert.Contains(t, jazon, `"Bar":`) assert.Contains(t, jazon, `"Baz":`) } func TestFlatten_1898(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "bugs", "1898", "swagger.json") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Expand: false, RemoveUnused: false, })) op, ok := an.OperationFor("GET", "/example/v2/GetEvents") require.True(t, ok) resp, _, ok := op.SuccessResponse() require.True(t, ok) require.Equal(t, "#/definitions/xStreamDefinitionsV2EventMsg", resp.Schema.Ref.String()) def, ok := sp.Definitions["xStreamDefinitionsV2EventMsg"] require.True(t, ok) require.Len(t, def.Properties, 2) require.Contains(t, def.Properties, "error") require.Contains(t, def.Properties, "result") } func TestFlatten_RemoveUnused_2657(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) bp := filepath.Join("fixtures", "bugs", "2657", "schema.json") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, RemoveUnused: true, })) require.Empty(t, sp.Definitions) } func TestFlatten_Relative_2743(t testing.T) { log.SetOutput(io.Discard) defer log.SetOutput(os.Stdout) t.Run("used to work, but should NOT", func(t testing.T) { bp := filepath.Join("fixtures", "bugs", "2743", "working", "spec.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.Error(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, })) }) t.Run("used not to, but should work", func(t testing.T) { bp := filepath.Join("fixtures", "bugs", "2743", "not-working", "spec.yaml") sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, Expand: false, })) }) } func getDefinition(t testing.TB, sp spec.Swagger, key string) string { d, ok := sp.Definitions[key] require.Truef(t, ok, "Expected definition for %s", key) res, err := json.Marshal(d) if err != nil { panic(err) } return string(res) } func getInPath(t testing.TB, sp spec.Swagger, path, key string) string { ptr, erp := jsonpointer.New(key) require.NoError(t, erp, "at %s no key", key) d, _, erg := ptr.Get(sp.Paths.Paths[path]) require.NoError(t, erg, "at %s no value for %s", path, key) res, err := json.Marshal(d) if err != nil { panic(err) } return string(res) } func checkRefs(t testing.TB, spec spec.Swagger, expectNoConflict bool) { // all $ref resolve locally jazon := antest.AsJSON(t, spec) m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) for _, matched := range m { subMatch := matched[1] assert.True(t, strings.HasPrefix(subMatch, "#/definitions/"), "expected $ref to be inlined, got: %s", matched[0]) } if expectNoConflict { // no naming conflict m := oairex.FindAllStringSubmatch(jazon, -1) assert.Empty(t, m) } } func testFlattenWithDefaults(t testing.T, bp string) *Spec { sp := antest.LoadOrFail(t, bp) an := New(sp) require.NoError(t, Flatten(FlattenOpts{ Spec: an, BasePath: bp, Verbose: true, Minimal: true, RemoveUnused: false, })) return an }	44.56 KB	2025-05-25 12:27
📄 go.mod module github.com/go-openapi/analysis require ( github.com/go-openapi/jsonpointer v0.21.0 github.com/go-openapi/spec v0.21.0 github.com/go-openapi/strfmt v0.23.0 github.com/go-openapi/swag v0.23.0 github.com/stretchr/testify v1.9.0 ) require ( github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/go-openapi/errors v0.22.0 // indirect github.com/go-openapi/jsonreference v0.21.0 // indirect github.com/google/uuid v1.6.0 // indirect github.com/josharian/intern v1.0.0 // indirect github.com/mailru/easyjson v0.7.7 // indirect github.com/mitchellh/mapstructure v1.5.0 // indirect github.com/oklog/ulid v1.3.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect go.mongodb.org/mongo-driver v1.14.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) go 1.20	868 B	2025-05-25 12:27
📄 go.sum github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so= github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-openapi/errors v0.22.0 h1:c4xY/OLxUBSTiepAg3j/MHuAv5mJhnf53LLMWFB+u/w= github.com/go-openapi/errors v0.22.0/go.mod h1:J3DmZScxCDufmIMsdOuDHxJbdOGC0xtUynjIx092vXE= github.com/go-openapi/jsonpointer v0.21.0 h1:YgdVicSA9vH5RiHs9TZW5oyafXZFc6+2Vc1rr/O9oNQ= github.com/go-openapi/jsonpointer v0.21.0/go.mod h1:IUyH9l/+uyhIYQ/PXVA41Rexl+kOkAPDdXEYns6fzUY= github.com/go-openapi/jsonreference v0.21.0 h1:Rs+Y7hSXT83Jacb7kFyjn4ijOuVGSvOdF2+tg1TRrwQ= github.com/go-openapi/jsonreference v0.21.0/go.mod h1:LmZmgsrTkVg9LG4EaHeY8cBDslNPMo06cago5JNLkm4= github.com/go-openapi/spec v0.21.0 h1:LTVzPc3p/RzRnkQqLRndbAzjY0d0BCL72A6j3CdL9ZY= github.com/go-openapi/spec v0.21.0/go.mod h1:78u6VdPw81XU44qEWGhtr982gJ5BWg2c0I5XwVMotYk= github.com/go-openapi/strfmt v0.23.0 h1:nlUS6BCqcnAk0pyhi9Y+kdDVZdZMHfEKQiS4HaMgO/c= github.com/go-openapi/strfmt v0.23.0/go.mod h1:NrtIpfKtWIygRkKVsxh7XQMDQW5HKQl6S5ik2elW+K4= github.com/go-openapi/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= github.com/google/go-cmp v0.5.2 h1:X2ev0eStA3AbceY54o37/0PQ/UWqKEiiO2dKL5OPaFM= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/josharian/intern v1.0.0 h1:vlS4z54oSdjm0bgjRigI+G1HpF+tI+9rE5LLzOg8HmY= github.com/josharian/intern v1.0.0/go.mod h1:5DoeVV0s6jJacbCEi61lwdGj/aVlrQvzHFFd8Hwg//Y= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0= github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc= github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY= github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4= github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= go.mongodb.org/mongo-driver v1.14.0 h1:P98w8egYRjYe3XDjxhYJagTokP/H6HzlsnojRgZRd80= go.mongodb.org/mongo-driver v1.14.0/go.mod h1:Vzb0Mk/pa7e6cWw85R4F/endUC3u0U9jGcNU603k65c= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=	3.46 KB	2025-05-25 12:27
📁 internal	-	2025-05-25 12:27
📄 mixin.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "fmt" "reflect" "github.com/go-openapi/spec" ) // Mixin modifies the primary swagger spec by adding the paths and // definitions from the mixin specs. Top level parameters and // responses from the mixins are also carried over. Operation id // collisions are avoided by appending "Mixin<N>" but only if // needed. // // The following parts of primary are subject to merge, filling empty details // - Info // - BasePath // - Host // - ExternalDocs // // Consider calling FixEmptyResponseDescriptions() on the modified primary // if you read them from storage and they are valid to start with. // // Entries in "paths", "definitions", "parameters" and "responses" are // added to the primary in the order of the given mixins. If the entry // already exists in primary it is skipped with a warning message. // // The count of skipped entries (from collisions) is returned so any // deviation from the number expected can flag a warning in your build // scripts. Carefully review the collisions before accepting them; // consider renaming things if possible. // // No key normalization takes place (paths, type defs, // etc). Ensure they are canonical if your downstream tools do // key normalization of any form. // // Merging schemes (http, https), and consumers/producers do not account for // collisions. func Mixin(primary spec.Swagger, mixins ...spec.Swagger) []string { skipped := make([]string, 0, len(mixins)) opIDs := getOpIDs(primary) initPrimary(primary) for i, m := range mixins { skipped = append(skipped, mergeSwaggerProps(primary, m)...) skipped = append(skipped, mergeConsumes(primary, m)...) skipped = append(skipped, mergeProduces(primary, m)...) skipped = append(skipped, mergeTags(primary, m)...) skipped = append(skipped, mergeSchemes(primary, m)...) skipped = append(skipped, mergeSecurityDefinitions(primary, m)...) skipped = append(skipped, mergeSecurityRequirements(primary, m)...) skipped = append(skipped, mergeDefinitions(primary, m)...) // merging paths requires a map of operationIDs to work with skipped = append(skipped, mergePaths(primary, m, opIDs, i)...) skipped = append(skipped, mergeParameters(primary, m)...) skipped = append(skipped, mergeResponses(primary, m)...) } return skipped } // getOpIDs extracts all the paths.<path>.operationIds from the given // spec and returns them as the keys in a map with 'true' values. func getOpIDs(s spec.Swagger) map[string]bool { rv := make(map[string]bool) if s.Paths == nil { return rv } for _, v := range s.Paths.Paths { piops := pathItemOps(v) for _, op := range piops { rv[op.ID] = true } } return rv } func pathItemOps(p spec.PathItem) []spec.Operation { var rv []spec.Operation rv = appendOp(rv, p.Get) rv = appendOp(rv, p.Put) rv = appendOp(rv, p.Post) rv = appendOp(rv, p.Delete) rv = appendOp(rv, p.Head) rv = appendOp(rv, p.Patch) return rv } func appendOp(ops []spec.Operation, op spec.Operation) []spec.Operation { if op == nil { return ops } return append(ops, op) } func mergeSecurityDefinitions(primary spec.Swagger, m spec.Swagger) (skipped []string) { for k, v := range m.SecurityDefinitions { if _, exists := primary.SecurityDefinitions[k]; exists { warn := fmt.Sprintf( "SecurityDefinitions entry '%v' already exists in primary or higher priority mixin, skipping\n", k) skipped = append(skipped, warn) continue } primary.SecurityDefinitions[k] = v } return } func mergeSecurityRequirements(primary spec.Swagger, m spec.Swagger) (skipped []string) { for _, v := range m.Security { found := false for _, vv := range primary.Security { if reflect.DeepEqual(v, vv) { found = true break } } if found { warn := fmt.Sprintf( "Security requirement: '%v' already exists in primary or higher priority mixin, skipping\n", v) skipped = append(skipped, warn) continue } primary.Security = append(primary.Security, v) } return } func mergeDefinitions(primary spec.Swagger, m spec.Swagger) (skipped []string) { for k, v := range m.Definitions { // assume name collisions represent IDENTICAL type. careful. if _, exists := primary.Definitions[k]; exists { warn := fmt.Sprintf( "definitions entry '%v' already exists in primary or higher priority mixin, skipping\n", k) skipped = append(skipped, warn) continue } primary.Definitions[k] = v } return } func mergePaths(primary spec.Swagger, m spec.Swagger, opIDs map[string]bool, mixIndex int) (skipped []string) { if m.Paths != nil { for k, v := range m.Paths.Paths { if _, exists := primary.Paths.Paths[k]; exists { warn := fmt.Sprintf( "paths entry '%v' already exists in primary or higher priority mixin, skipping\n", k) skipped = append(skipped, warn) continue } // Swagger requires that operationIds be // unique within a spec. If we find a // collision we append "Mixin0" to the // operatoinId we are adding, where 0 is mixin // index. We assume that operationIds with // all the proivded specs are already unique. piops := pathItemOps(v) for _, piop := range piops { if opIDs[piop.ID] { piop.ID = fmt.Sprintf("%v%v%v", piop.ID, "Mixin", mixIndex) } opIDs[piop.ID] = true } primary.Paths.Paths[k] = v } } return } func mergeParameters(primary spec.Swagger, m spec.Swagger) (skipped []string) { for k, v := range m.Parameters { // could try to rename on conflict but would // have to fix $refs in the mixin. Complain // for now if _, exists := primary.Parameters[k]; exists { warn := fmt.Sprintf( "top level parameters entry '%v' already exists in primary or higher priority mixin, skipping\n", k) skipped = append(skipped, warn) continue } primary.Parameters[k] = v } return } func mergeResponses(primary spec.Swagger, m spec.Swagger) (skipped []string) { for k, v := range m.Responses { // could try to rename on conflict but would // have to fix $refs in the mixin. Complain // for now if _, exists := primary.Responses[k]; exists { warn := fmt.Sprintf( "top level responses entry '%v' already exists in primary or higher priority mixin, skipping\n", k) skipped = append(skipped, warn) continue } primary.Responses[k] = v } return skipped } func mergeConsumes(primary spec.Swagger, m spec.Swagger) []string { for _, v := range m.Consumes { found := false for _, vv := range primary.Consumes { if v == vv { found = true break } } if found { // no warning here: we just skip it continue } primary.Consumes = append(primary.Consumes, v) } return []string{} } func mergeProduces(primary spec.Swagger, m spec.Swagger) []string { for _, v := range m.Produces { found := false for _, vv := range primary.Produces { if v == vv { found = true break } } if found { // no warning here: we just skip it continue } primary.Produces = append(primary.Produces, v) } return []string{} } func mergeTags(primary spec.Swagger, m spec.Swagger) (skipped []string) { for _, v := range m.Tags { found := false for _, vv := range primary.Tags { if v.Name == vv.Name { found = true break } } if found { warn := fmt.Sprintf( "top level tags entry with name '%v' already exists in primary or higher priority mixin, skipping\n", v.Name, ) skipped = append(skipped, warn) continue } primary.Tags = append(primary.Tags, v) } return } func mergeSchemes(primary spec.Swagger, m spec.Swagger) []string { for _, v := range m.Schemes { found := false for _, vv := range primary.Schemes { if v == vv { found = true break } } if found { // no warning here: we just skip it continue } primary.Schemes = append(primary.Schemes, v) } return []string{} } func mergeSwaggerProps(primary spec.Swagger, m spec.Swagger) []string { var skipped, skippedInfo, skippedDocs []string primary.Extensions, skipped = mergeExtensions(primary.Extensions, m.Extensions) // merging details in swagger top properties if primary.Host == "" { primary.Host = m.Host } if primary.BasePath == "" { primary.BasePath = m.BasePath } if primary.Info == nil { primary.Info = m.Info } else if m.Info != nil { skippedInfo = mergeInfo(primary.Info, m.Info) skipped = append(skipped, skippedInfo...) } if primary.ExternalDocs == nil { primary.ExternalDocs = m.ExternalDocs } else if m != nil { skippedDocs = mergeExternalDocs(primary.ExternalDocs, m.ExternalDocs) skipped = append(skipped, skippedDocs...) } return skipped } //nolint:unparam func mergeExternalDocs(primary spec.ExternalDocumentation, m spec.ExternalDocumentation) []string { if primary.Description == "" { primary.Description = m.Description } if primary.URL == "" { primary.URL = m.URL } return nil } func mergeInfo(primary spec.Info, m spec.Info) []string { var sk, skipped []string primary.Extensions, sk = mergeExtensions(primary.Extensions, m.Extensions) skipped = append(skipped, sk...) if primary.Description == "" { primary.Description = m.Description } if primary.Title == "" { primary.Description = m.Description } if primary.TermsOfService == "" { primary.TermsOfService = m.TermsOfService } if primary.Version == "" { primary.Version = m.Version } if primary.Contact == nil { primary.Contact = m.Contact } else if m.Contact != nil { var csk []string primary.Contact.Extensions, csk = mergeExtensions(primary.Contact.Extensions, m.Contact.Extensions) skipped = append(skipped, csk...) if primary.Contact.Name == "" { primary.Contact.Name = m.Contact.Name } if primary.Contact.URL == "" { primary.Contact.URL = m.Contact.URL } if primary.Contact.Email == "" { primary.Contact.Email = m.Contact.Email } } if primary.License == nil { primary.License = m.License } else if m.License != nil { var lsk []string primary.License.Extensions, lsk = mergeExtensions(primary.License.Extensions, m.License.Extensions) skipped = append(skipped, lsk...) if primary.License.Name == "" { primary.License.Name = m.License.Name } if primary.License.URL == "" { primary.License.URL = m.License.URL } } return skipped } func mergeExtensions(primary spec.Extensions, m spec.Extensions) (result spec.Extensions, skipped []string) { if primary == nil { result = m return } if m == nil { result = primary return } result = primary for k, v := range m { if _, found := primary[k]; found { skipped = append(skipped, k) continue } primary[k] = v } return } func initPrimary(primary spec.Swagger) { if primary.SecurityDefinitions == nil { primary.SecurityDefinitions = make(map[string]spec.SecurityScheme) } if primary.Security == nil { primary.Security = make([]map[string][]string, 0, 10) } if primary.Produces == nil { primary.Produces = make([]string, 0, 10) } if primary.Consumes == nil { primary.Consumes = make([]string, 0, 10) } if primary.Tags == nil { primary.Tags = make([]spec.Tag, 0, 10) } if primary.Schemes == nil { primary.Schemes = make([]string, 0, 10) } if primary.Paths == nil { primary.Paths = &spec.Paths{Paths: make(map[string]spec.PathItem)} } if primary.Paths.Paths == nil { primary.Paths.Paths = make(map[string]spec.PathItem) } if primary.Definitions == nil { primary.Definitions = make(spec.Definitions) } if primary.Parameters == nil { primary.Parameters = make(map[string]spec.Parameter) } if primary.Responses == nil { primary.Responses = make(map[string]spec.Response) } }	12.03 KB	2025-05-25 12:27
📄 mixin_test.go // Copyright 2015 go-swagger maintainers // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package analysis import ( "testing" "github.com/go-openapi/analysis/internal/antest" "github.com/stretchr/testify/require" ) const ( widgetFile = "fixtures/widget-crud.yml" fooFile = "fixtures/foo-crud.yml" barFile = "fixtures/bar-crud.yml" noPathsFile = "fixtures/no-paths.yml" emptyPathsFile = "fixtures/empty-paths.json" securityFile = "fixtures/securitydef.yml" otherMixin = "fixtures/other-mixin.yml" emptyProps = "fixtures/empty-props.yml" swaggerProps = "fixtures/swagger-props.yml" ) func TestMixin_All(t testing.T) { t.Parallel() primary := antest.LoadOrFail(t, widgetFile) mixin1 := antest.LoadOrFail(t, fooFile) mixin2 := antest.LoadOrFail(t, barFile) mixin3 := antest.LoadOrFail(t, noPathsFile) mixin4 := antest.LoadOrFail(t, securityFile) mixin5 := antest.LoadOrFail(t, otherMixin) collisions := Mixin(primary, mixin1, mixin2, mixin3, mixin4, mixin5) require.Lenf(t, collisions, 19, "TestMixin: Expected 19 collisions, got %v\n%v", len(collisions), collisions) require.Lenf(t, primary.Paths.Paths, 7, "TestMixin: Expected 7 paths in merged, got %v\n", len(primary.Paths.Paths)) require.Lenf(t, primary.Definitions, 8, "TestMixin: Expected 8 definitions in merged, got %v\n", len(primary.Definitions)) require.Lenf(t, primary.Parameters, 4, "TestMixin: Expected 4 top level parameters in merged, got %v\n", len(primary.Parameters)) require.Lenf(t, primary.Responses, 2, "TestMixin: Expected 2 top level responses in merged, got %v\n", len(primary.Responses)) require.Lenf(t, primary.SecurityDefinitions, 5, "TestMixin: Expected 5 top level SecurityDefinitions in merged, got %v\n", len(primary.SecurityDefinitions)) require.Lenf(t, primary.Security, 3, "TestMixin: Expected 3 top level Security requirements in merged, got %v\n", len(primary.Security)) require.Lenf(t, primary.Tags, 3, "TestMixin: Expected 3 top level tags merged, got %v\n", len(primary.Security)) require.Lenf(t, primary.Schemes, 2, "TestMixin: Expected 2 top level schemes merged, got %v\n", len(primary.Security)) require.Lenf(t, primary.Consumes, 2, "TestMixin: Expected 2 top level Consumers merged, got %v\n", len(primary.Security)) require.Lenf(t, primary.Produces, 2, "TestMixin: Expected 2 top level Producers merged, got %v\n", len(primary.Security)) } func TestMixin_EmptyPath(t testing.T) { t.Parallel() // test that adding paths to a primary with no paths works (was NPE) primary := antest.LoadOrFail(t, widgetFile) emptyPaths := antest.LoadOrFail(t, emptyPathsFile) collisions := Mixin(emptyPaths, primary) require.Emptyf(t, collisions, "TestMixin: Expected 0 collisions, got %v\n%v", len(collisions), collisions) } func TestMixin_FromNilPath(t testing.T) { t.Parallel() primary := antest.LoadOrFail(t, otherMixin) mixin1 := antest.LoadOrFail(t, widgetFile) collisions := Mixin(primary, mixin1) require.Lenf(t, collisions, 1, "TestMixin: Expected 1 collisions, got %v\n%v", len(collisions), collisions) require.Lenf(t, primary.Paths.Paths, 3, "TestMixin: Expected 3 paths in merged, got %v\n", len(primary.Paths.Paths)) } func TestMixin_SwaggerProps(t testing.T) { t.Parallel() primary := antest.LoadOrFail(t, emptyProps) mixin := antest.LoadOrFail(t, swaggerProps) collisions := Mixin(primary, mixin) require.Lenf(t, collisions, 1, "TestMixin: Expected 1 collisions, got %v\n%v", len(collisions), collisions) }	3.92 KB	2025-05-25 12:27
📄 schema.go package analysis import ( "errors" "github.com/go-openapi/spec" "github.com/go-openapi/strfmt" ) // SchemaOpts configures the schema analyzer type SchemaOpts struct { Schema spec.Schema Root interface{} BasePath string _ struct{} } // Schema analysis, will classify the schema according to known // patterns. func Schema(opts SchemaOpts) (AnalyzedSchema, error) { if opts.Schema == nil { return nil, errors.New("no schema to analyze") } a := &AnalyzedSchema{ schema: opts.Schema, root: opts.Root, basePath: opts.BasePath, } a.initializeFlags() a.inferKnownType() a.inferEnum() a.inferBaseType() if err := a.inferMap(); err != nil { return nil, err } if err := a.inferArray(); err != nil { return nil, err } a.inferTuple() if err := a.inferFromRef(); err != nil { return nil, err } a.inferSimpleSchema() return a, nil } // AnalyzedSchema indicates what the schema represents type AnalyzedSchema struct { schema spec.Schema root interface{} basePath string hasProps bool hasAllOf bool hasItems bool hasAdditionalProps bool hasAdditionalItems bool hasRef bool IsKnownType bool IsSimpleSchema bool IsArray bool IsSimpleArray bool IsMap bool IsSimpleMap bool IsExtendedObject bool IsTuple bool IsTupleWithExtra bool IsBaseType bool IsEnum bool } // Inherits copies value fields from other onto this schema func (a AnalyzedSchema) inherits(other AnalyzedSchema) { if other == nil { return } a.hasProps = other.hasProps a.hasAllOf = other.hasAllOf a.hasItems = other.hasItems a.hasAdditionalItems = other.hasAdditionalItems a.hasAdditionalProps = other.hasAdditionalProps a.hasRef = other.hasRef a.IsKnownType = other.IsKnownType a.IsSimpleSchema = other.IsSimpleSchema a.IsArray = other.IsArray a.IsSimpleArray = other.IsSimpleArray a.IsMap = other.IsMap a.IsSimpleMap = other.IsSimpleMap a.IsExtendedObject = other.IsExtendedObject a.IsTuple = other.IsTuple a.IsTupleWithExtra = other.IsTupleWithExtra a.IsBaseType = other.IsBaseType a.IsEnum = other.IsEnum } func (a AnalyzedSchema) inferFromRef() error { if a.hasRef { sch := new(spec.Schema) sch.Ref = a.schema.Ref err := spec.ExpandSchema(sch, a.root, nil) if err != nil { return err } rsch, err := Schema(SchemaOpts{ Schema: sch, Root: a.root, BasePath: a.basePath, }) if err != nil { // NOTE(fredbi): currently the only cause for errors is // unresolved ref. Since spec.ExpandSchema() expands the // schema recursively, there is no chance to get there, // until we add more causes for error in this schema analysis. return err } a.inherits(rsch) } return nil } func (a AnalyzedSchema) inferSimpleSchema() { a.IsSimpleSchema = a.IsKnownType \|\| a.IsSimpleArray \|\| a.IsSimpleMap } func (a AnalyzedSchema) inferKnownType() { tpe := a.schema.Type format := a.schema.Format a.IsKnownType = tpe.Contains("boolean") \|\| tpe.Contains("integer") \|\| tpe.Contains("number") \|\| tpe.Contains("string") \|\| (format != "" && strfmt.Default.ContainsName(format)) \|\| (a.isObjectType() && !a.hasProps && !a.hasAllOf && !a.hasAdditionalProps && !a.hasAdditionalItems) } func (a AnalyzedSchema) inferMap() error { if !a.isObjectType() { return nil } hasExtra := a.hasProps \|\| a.hasAllOf a.IsMap = a.hasAdditionalProps && !hasExtra a.IsExtendedObject = a.hasAdditionalProps && hasExtra if !a.IsMap { return nil } // maps if a.schema.AdditionalProperties.Schema != nil { msch, err := Schema(SchemaOpts{ Schema: a.schema.AdditionalProperties.Schema, Root: a.root, BasePath: a.basePath, }) if err != nil { return err } a.IsSimpleMap = msch.IsSimpleSchema } else if a.schema.AdditionalProperties.Allows { a.IsSimpleMap = true } return nil } func (a AnalyzedSchema) inferArray() error { // an array has Items defined as an object schema, otherwise we qualify this JSON array as a tuple // (yes, even if the Items array contains only one element). // arrays in JSON schema may be unrestricted (i.e no Items specified). // Note that arrays in Swagger MUST have Items. Nonetheless, we analyze unrestricted arrays. // // NOTE: the spec package misses the distinction between: // items: [] and items: {}, so we consider both arrays here. a.IsArray = a.isArrayType() && (a.schema.Items == nil \|\| a.schema.Items.Schemas == nil) if a.IsArray && a.hasItems { if a.schema.Items.Schema != nil { itsch, err := Schema(SchemaOpts{ Schema: a.schema.Items.Schema, Root: a.root, BasePath: a.basePath, }) if err != nil { return err } a.IsSimpleArray = itsch.IsSimpleSchema } } if a.IsArray && !a.hasItems { a.IsSimpleArray = true } return nil } func (a AnalyzedSchema) inferTuple() { tuple := a.hasItems && a.schema.Items.Schemas != nil a.IsTuple = tuple && !a.hasAdditionalItems a.IsTupleWithExtra = tuple && a.hasAdditionalItems } func (a AnalyzedSchema) inferBaseType() { if a.isObjectType() { a.IsBaseType = a.schema.Discriminator != "" } } func (a AnalyzedSchema) inferEnum() { a.IsEnum = len(a.schema.Enum) > 0 } func (a AnalyzedSchema) initializeFlags() { a.hasProps = len(a.schema.Properties) > 0 a.hasAllOf = len(a.schema.AllOf) > 0 a.hasRef = a.schema.Ref.String() != "" a.hasItems = a.schema.Items != nil && (a.schema.Items.Schema != nil \|\| len(a.schema.Items.Schemas) > 0) a.hasAdditionalProps = a.schema.AdditionalProperties != nil && (a.schema.AdditionalProperties.Schema != nil \|\| a.schema.AdditionalProperties.Allows) a.hasAdditionalItems = a.schema.AdditionalItems != nil && (a.schema.AdditionalItems.Schema != nil \|\| a.schema.AdditionalItems.Allows) } func (a AnalyzedSchema) isObjectType() bool { return !a.hasRef && (a.schema.Type == nil \|\| a.schema.Type.Contains("") \|\| a.schema.Type.Contains("object")) } func (a AnalyzedSchema) isArrayType() bool { return !a.hasRef && (a.schema.Type != nil && a.schema.Type.Contains("array")) } // isAnalyzedAsComplex determines if an analyzed schema is eligible to flattening (i.e. it is "complex"). // // Complex means the schema is any of: // - a simple type (primitive) // - an array of something (items are possibly complex ; if this is the case, items will generate a definition) // - a map of something (additionalProperties are possibly complex ; if this is the case, additionalProperties will // generate a definition) func (a *AnalyzedSchema) isAnalyzedAsComplex() bool { return !a.IsSimpleSchema && !a.IsArray && !a.IsMap }	6.51 KB	2025-05-25 12:27
📄 schema_test.go package analysis import ( "encoding/json" "fmt" "net/http" "net/http/httptest" "path" "path/filepath" "testing" "github.com/go-openapi/analysis/internal/antest" "github.com/go-openapi/spec" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var knownSchemas = []spec.Schema{ spec.BoolProperty(), // 0 spec.StringProperty(), // 1 spec.Int8Property(), // 2 spec.Int16Property(), // 3 spec.Int32Property(), // 4 spec.Int64Property(), // 5 spec.Float32Property(), // 6 spec.Float64Property(), // 7 spec.DateProperty(), // 8 spec.DateTimeProperty(), // 9 (&spec.Schema{}), // 10 (&spec.Schema{}).Typed("object", ""), // 11 (&spec.Schema{}).Typed("", ""), // 12 (&spec.Schema{}).Typed("", "uuid"), // 13 } func TestSchemaAnalysis_KnownTypes(t testing.T) { for i, v := range knownSchemas { sch, err := Schema(SchemaOpts{Schema: v}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsKnownType, "item at %d should be a known type", i) } for i, v := range complexSchemas { sch, err := Schema(SchemaOpts{Schema: v}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Falsef(t, sch.IsKnownType, "item at %d should not be a known type", i) } serv := refServer() defer serv.Close() for i, ref := range knownRefs(serv.URL) { sch, err := Schema(SchemaOpts{Schema: refSchema(ref)}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsKnownType, "item at %d should be a known type", i) } for i, ref := range complexRefs(serv.URL) { sch, err := Schema(SchemaOpts{Schema: refSchema(ref)}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Falsef(t, sch.IsKnownType, "item at %d should not be a known type", i) } } func TestSchemaAnalysis_Array(t testing.T) { for i, v := range append(knownSchemas, (&spec.Schema{}).Typed("array", "")) { sch, err := Schema(SchemaOpts{Schema: spec.ArrayProperty(v)}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsArray, "item at %d should be an array type", i) assert.Truef(t, sch.IsSimpleArray, "item at %d should be a simple array type", i) } for i, v := range complexSchemas { sch, err := Schema(SchemaOpts{Schema: spec.ArrayProperty(v)}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsArray, "item at %d should be an array type", i) assert.Falsef(t, sch.IsSimpleArray, "item at %d should not be a simple array type", i) } serv := refServer() defer serv.Close() for i, ref := range knownRefs(serv.URL) { sch, err := Schema(SchemaOpts{Schema: spec.ArrayProperty(refSchema(ref))}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsArray, "item at %d should be an array type", i) assert.Truef(t, sch.IsSimpleArray, "item at %d should be a simple array type", i) } for i, ref := range complexRefs(serv.URL) { sch, err := Schema(SchemaOpts{Schema: spec.ArrayProperty(refSchema(ref))}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Falsef(t, sch.IsKnownType, "item at %d should not be a known type", i) assert.Truef(t, sch.IsArray, "item at %d should be an array type", i) assert.Falsef(t, sch.IsSimpleArray, "item at %d should not be a simple array type", i) } // edge case: unrestricted array (beyond Swagger) at := spec.ArrayProperty(nil) at.Items = nil sch, err := Schema(SchemaOpts{Schema: at}) require.NoError(t, err) assert.True(t, sch.IsArray) assert.False(t, sch.IsTuple) assert.False(t, sch.IsKnownType) assert.True(t, sch.IsSimpleSchema) // unrestricted array with explicit empty schema at = spec.ArrayProperty(nil) at.Items = &spec.SchemaOrArray{} sch, err = Schema(SchemaOpts{Schema: at}) require.NoError(t, err) assert.True(t, sch.IsArray) assert.False(t, sch.IsTuple) assert.False(t, sch.IsKnownType) assert.True(t, sch.IsSimpleSchema) } func TestSchemaAnalysis_Map(t testing.T) { for i, v := range append(knownSchemas, spec.MapProperty(nil)) { sch, err := Schema(SchemaOpts{Schema: spec.MapProperty(v)}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsMap, "item at %d should be a map type", i) assert.Truef(t, sch.IsSimpleMap, "item at %d should be a simple map type", i) } for i, v := range complexSchemas { sch, err := Schema(SchemaOpts{Schema: spec.MapProperty(v)}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsMap, "item at %d should be a map type", i) assert.Falsef(t, sch.IsSimpleMap, "item at %d should not be a simple map type", i) } } func TestSchemaAnalysis_ExtendedObject(t testing.T) { for i, v := range knownSchemas { wex := spec.MapProperty(v).SetProperty("name", spec.StringProperty()) sch, err := Schema(SchemaOpts{Schema: wex}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsExtendedObject, "item at %d should be an extended map object type", i) assert.Falsef(t, sch.IsMap, "item at %d should not be a map type", i) assert.Falsef(t, sch.IsSimpleMap, "item at %d should not be a simple map type", i) } } func TestSchemaAnalysis_Tuple(t testing.T) { at := spec.ArrayProperty(nil) at.Items = &spec.SchemaOrArray{} at.Items.Schemas = append(at.Items.Schemas, spec.StringProperty(), spec.Int64Property()) sch, err := Schema(SchemaOpts{Schema: at}) require.NoError(t, err) assert.True(t, sch.IsTuple) assert.False(t, sch.IsTupleWithExtra) assert.False(t, sch.IsKnownType) assert.False(t, sch.IsSimpleSchema) // edge case: tuple with a single element at.Items = &spec.SchemaOrArray{} at.Items.Schemas = append(at.Items.Schemas, spec.StringProperty()) sch, err = Schema(SchemaOpts{Schema: at}) require.NoError(t, err) assert.True(t, sch.IsTuple) assert.False(t, sch.IsTupleWithExtra) assert.False(t, sch.IsKnownType) assert.False(t, sch.IsSimpleSchema) } func TestSchemaAnalysis_TupleWithExtra(t testing.T) { at := spec.ArrayProperty(nil) at.Items = &spec.SchemaOrArray{} at.Items.Schemas = append(at.Items.Schemas, spec.StringProperty(), spec.Int64Property()) at.AdditionalItems = &spec.SchemaOrBool{Allows: true} at.AdditionalItems.Schema = spec.Int32Property() sch, err := Schema(SchemaOpts{Schema: at}) require.NoError(t, err) assert.False(t, sch.IsTuple) assert.True(t, sch.IsTupleWithExtra) assert.False(t, sch.IsKnownType) assert.False(t, sch.IsSimpleSchema) } func TestSchemaAnalysis_BaseType(t testing.T) { cl := (&spec.Schema{}).Typed("object", "").SetProperty("type", spec.StringProperty()).WithDiscriminator("type") sch, err := Schema(SchemaOpts{Schema: cl}) require.NoError(t, err) assert.True(t, sch.IsBaseType) assert.False(t, sch.IsKnownType) assert.False(t, sch.IsSimpleSchema) } func TestSchemaAnalysis_SimpleSchema(t testing.T) { for i, v := range append(knownSchemas, spec.ArrayProperty(nil), spec.MapProperty(nil)) { sch, err := Schema(SchemaOpts{Schema: v}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Truef(t, sch.IsSimpleSchema, "item at %d should be a simple schema", i) asch, err := Schema(SchemaOpts{Schema: spec.ArrayProperty(v)}) require.NoErrorf(t, err, "failed to analyze array schema at %d: %v", i, err) assert.Truef(t, asch.IsSimpleSchema, "array item at %d should be a simple schema", i) msch, err := Schema(SchemaOpts{Schema: spec.MapProperty(v)}) require.NoErrorf(t, err, "failed to analyze map schema at %d: %v", i, err) assert.Truef(t, msch.IsSimpleSchema, "map item at %d should be a simple schema", i) } for i, v := range complexSchemas { sch, err := Schema(SchemaOpts{Schema: v}) require.NoErrorf(t, err, "failed to analyze schema at %d: %v", i, err) assert.Falsef(t, sch.IsSimpleSchema, "item at %d should not be a simple schema", i) } } func TestSchemaAnalys_InvalidSchema(t testing.T) { // explore error cases in schema analysis: // the only cause for failure is a wrong $ref at some place bp := filepath.Join("fixtures", "bugs", "1602", "other-invalid-pointers.yaml") sp := antest.LoadOrFail(t, bp) // invalid ref not detected (no digging further) def := sp.Definitions["invalidRefInObject"] _, err := Schema(SchemaOpts{Schema: &def, Root: sp, BasePath: bp}) require.NoError(t, err, "did not expect an error here, in spite of the underlying invalid $ref") def = sp.Definitions["invalidRefInTuple"] _, err = Schema(SchemaOpts{Schema: &def, Root: sp, BasePath: bp}) require.NoError(t, err, "did not expect an error here, in spite of the underlying invalid $ref") // invalid ref detected (digging) schema := refSchema(spec.MustCreateRef("#/definitions/noWhere")) _, err = Schema(SchemaOpts{Schema: schema, Root: sp, BasePath: bp}) require.Error(t, err, "expected an error here") def = sp.Definitions["invalidRefInMap"] _, err = Schema(SchemaOpts{Schema: &def, Root: sp, BasePath: bp}) require.Error(t, err, "expected an error here") def = sp.Definitions["invalidRefInArray"] _, err = Schema(SchemaOpts{Schema: &def, Root: sp, BasePath: bp}) require.Error(t, err, "expected an error here") def = sp.Definitions["indirectToInvalidRef"] _, err = Schema(SchemaOpts{Schema: &def, Root: sp, BasePath: bp}) require.Error(t, err, "expected an error here") } func TestSchemaAnalysis_EdgeCases(t testing.T) { t.Parallel() _, err := Schema(SchemaOpts{Schema: nil}) require.Error(t, err) } /* helpers for the Schema test suite / func newCObj() spec.Schema { return (&spec.Schema{}).Typed("object", "").SetProperty("id", spec.Int64Property()) } var complexObject = newCObj() var complexSchemas = []spec.Schema{ complexObject, spec.ArrayProperty(complexObject), spec.MapProperty(complexObject), } func knownRefs(base string) []spec.Ref { urls := []string{"bool", "string", "integer", "float", "date", "object", "format"} result := make([]spec.Ref, 0, len(urls)) for _, u := range urls { result = append(result, spec.MustCreateRef(fmt.Sprintf("%s/%s", base, path.Join("known", u)))) } return result } func complexRefs(base string) []spec.Ref { urls := []string{"object", "array", "map"} result := make([]spec.Ref, 0, len(urls)) for _, u := range urls { result = append(result, spec.MustCreateRef(fmt.Sprintf("%s/%s", base, path.Join("complex", u)))) } return result } func refServer() httptest.Server { mux := http.NewServeMux() mux.Handle("/known/bool", schemaHandler(knownSchemas[0])) mux.Handle("/known/string", schemaHandler(knownSchemas[1])) mux.Handle("/known/integer", schemaHandler(knownSchemas[5])) mux.Handle("/known/float", schemaHandler(knownSchemas[6])) mux.Handle("/known/date", schemaHandler(knownSchemas[8])) mux.Handle("/known/object", schemaHandler(knownSchemas[11])) mux.Handle("/known/format", schemaHandler(knownSchemas[13])) mux.Handle("/complex/object", schemaHandler(complexSchemas[0])) mux.Handle("/complex/array", schemaHandler(complexSchemas[1])) mux.Handle("/complex/map", schemaHandler(complexSchemas[2])) return httptest.NewServer(mux) } func refSchema(ref spec.Ref) spec.Schema { return &spec.Schema{SchemaProps: spec.SchemaProps{Ref: ref}} } func schemaHandler(schema spec.Schema) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, _ http.Request) { writeJSON(w, schema) }) } func writeJSON(w http.ResponseWriter, data interface{}) { w.Header().Add("Content-Type", "application/json") w.WriteHeader(http.StatusOK) enc := json.NewEncoder(w) if err := enc.Encode(data); err != nil { panic(err) } }	11.58 KB	2025-05-25 12:27

Edit File:

Terminal