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
📄 .editorconfig # top-most EditorConfig file root = true # Unix-style newlines with a newline ending every file [] end_of_line = lf insert_final_newline = true indent_style = space indent_size = 2 trim_trailing_whitespace = true # Set default charset [.{js,py,go,scala,rb,java,html,css,less,sass,md}] charset = utf-8 # Tab indentation (no size specified) [.go] indent_style = tab [.md] trim_trailing_whitespace = false # Matches the exact files either package.json or .travis.yml [{package.json,.travis.yml}] indent_style = space indent_size = 2	539 B	2025-05-25 12:27
📁 .github	-	2025-05-25 12:27
📄 .gitignore *.out	6 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 v2 object model [![Build Status](https://github.com/go-openapi/spec/actions/workflows/go-test.yml/badge.svg)](https://github.com/go-openapi/spec/actions?query=workflow%3A"go+test") [![codecov](https://codecov.io/gh/go-openapi/spec/branch/master/graph/badge.svg)](https://codecov.io/gh/go-openapi/spec) [![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/spec/master/LICENSE) [![Go Reference](https://pkg.go.dev/badge/github.com/go-openapi/spec.svg)](https://pkg.go.dev/github.com/go-openapi/spec) [![Go Report Card](https://goreportcard.com/badge/github.com/go-openapi/spec)](https://goreportcard.com/report/github.com/go-openapi/spec) The object model for OpenAPI specification documents. ### FAQ * What does this do? > 1. This package knows how to marshal and unmarshal Swagger API specifications into a golang object model > 2. It knows how to resolve $ref and expand them to make a single root document * How does it play with the rest of the go-openapi packages ? > 1. This package is at the core of the go-openapi suite of packages and [code generator](https://github.com/go-swagger/go-swagger) > 2. There is a [spec loading package](https://github.com/go-openapi/loads) to fetch specs as JSON or YAML from local or remote locations > 3. There is a [spec validation package](https://github.com/go-openapi/validate) built on top of it > 4. There is a [spec analysis package](https://github.com/go-openapi/analysis) built on top of it, to analyze, flatten, fix and merge spec documents * 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. > > An early attempt to support Swagger 3 may be found at: https://github.com/go-openapi/spec3 * Does the unmarshaling support YAML? > Not directly. The exposed types know only how to unmarshal from JSON. > > In order to load a YAML document as a Swagger spec, you need to use the loaders provided by > github.com/go-openapi/loads > > Take a look at the example there: https://pkg.go.dev/github.com/go-openapi/loads#example-Spec > > See also https://github.com/go-openapi/spec/issues/164 * How can I validate a spec? > Validation is provided by [the validate package](http://github.com/go-openapi/validate) * Why do we have an `ID` field for `Schema` which is not part of the swagger spec? > We found jsonschema compatibility more important: since `id` in jsonschema influences > how `$ref` are resolved. > This `id` does not conflict with any property named `id`. > > See also https://github.com/go-openapi/spec/issues/23	2.8 KB	2025-05-25 12:27
📄 auth_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 spec import ( "testing" ) func TestSerialization_AuthSerialization(t testing.T) { assertSerializeJSON(t, BasicAuth(), `{"type":"basic"}`) assertSerializeJSON(t, APIKeyAuth("api-key", "header"), `{"type":"apiKey","name":"api-key","in":"header"}`) assertSerializeJSON( t, OAuth2Implicit("http://foo.com/authorization"), `{"type":"oauth2","flow":"implicit","authorizationUrl":"http://foo.com/authorization"}`) assertSerializeJSON( t, OAuth2Password("http://foo.com/token"), `{"type":"oauth2","flow":"password","tokenUrl":"http://foo.com/token"}`) assertSerializeJSON(t, OAuth2Application("http://foo.com/token"), `{"type":"oauth2","flow":"application","tokenUrl":"http://foo.com/token"}`) assertSerializeJSON( t, OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token"), `{"type":"oauth2","flow":"accessCode","authorizationUrl":"http://foo.com/authorization",`+ `"tokenUrl":"http://foo.com/token"}`) auth1 := OAuth2Implicit("http://foo.com/authorization") auth1.AddScope("email", "read your email") assertSerializeJSON( t, auth1, `{"type":"oauth2","flow":"implicit","authorizationUrl":"http://foo.com/authorization",`+ `"scopes":{"email":"read your email"}}`) auth2 := OAuth2Password("http://foo.com/authorization") auth2.AddScope("email", "read your email") assertSerializeJSON( t, auth2, `{"type":"oauth2","flow":"password","tokenUrl":"http://foo.com/authorization",`+ `"scopes":{"email":"read your email"}}`) auth3 := OAuth2Application("http://foo.com/token") auth3.AddScope("email", "read your email") assertSerializeJSON( t, auth3, `{"type":"oauth2","flow":"application","tokenUrl":"http://foo.com/token","scopes":{"email":"read your email"}}`) auth4 := OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token") auth4.AddScope("email", "read your email") assertSerializeJSON( t, auth4, `{"type":"oauth2","flow":"accessCode","authorizationUrl":"http://foo.com/authorization",`+ `"tokenUrl":"http://foo.com/token","scopes":{"email":"read your email"}}`) } func TestSerialization_AuthDeserialization(t testing.T) { assertParsesJSON(t, `{"type":"basic"}`, BasicAuth()) assertParsesJSON( t, `{"in":"header","name":"api-key","type":"apiKey"}`, APIKeyAuth("api-key", "header")) assertParsesJSON( t, `{"authorizationUrl":"http://foo.com/authorization","flow":"implicit","type":"oauth2"}`, OAuth2Implicit("http://foo.com/authorization")) assertParsesJSON( t, `{"flow":"password","tokenUrl":"http://foo.com/token","type":"oauth2"}`, OAuth2Password("http://foo.com/token")) assertParsesJSON( t, `{"flow":"application","tokenUrl":"http://foo.com/token","type":"oauth2"}`, OAuth2Application("http://foo.com/token")) assertParsesJSON( t, `{"authorizationUrl":"http://foo.com/authorization","flow":"accessCode","tokenUrl":"http://foo.com/token",`+ `"type":"oauth2"}`, OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token")) auth1 := OAuth2Implicit("http://foo.com/authorization") auth1.AddScope("email", "read your email") assertParsesJSON(t, `{"authorizationUrl":"http://foo.com/authorization","flow":"implicit","scopes":{"email":"read your email"},`+ `"type":"oauth2"}`, auth1) auth2 := OAuth2Password("http://foo.com/token") auth2.AddScope("email", "read your email") assertParsesJSON(t, `{"flow":"password","scopes":{"email":"read your email"},"tokenUrl":"http://foo.com/token","type":"oauth2"}`, auth2) auth3 := OAuth2Application("http://foo.com/token") auth3.AddScope("email", "read your email") assertParsesJSON(t, `{"flow":"application","scopes":{"email":"read your email"},"tokenUrl":"http://foo.com/token","type":"oauth2"}`, auth3) auth4 := OAuth2AccessToken("http://foo.com/authorization", "http://foo.com/token") auth4.AddScope("email", "read your email") assertParsesJSON( t, `{"authorizationUrl":"http://foo.com/authorization","flow":"accessCode","scopes":{"email":"read your email"},`+ `"tokenUrl":"http://foo.com/token","type":"oauth2"}`, auth4) }	4.58 KB	2025-05-25 12:27
📄 cache.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 spec import ( "sync" ) // ResolutionCache a cache for resolving urls type ResolutionCache interface { Get(string) (interface{}, bool) Set(string, interface{}) } type simpleCache struct { lock sync.RWMutex store map[string]interface{} } func (s simpleCache) ShallowClone() ResolutionCache { store := make(map[string]interface{}, len(s.store)) s.lock.RLock() for k, v := range s.store { store[k] = v } s.lock.RUnlock() return &simpleCache{ store: store, } } // Get retrieves a cached URI func (s simpleCache) Get(uri string) (interface{}, bool) { s.lock.RLock() v, ok := s.store[uri] s.lock.RUnlock() return v, ok } // Set caches a URI func (s simpleCache) Set(uri string, data interface{}) { s.lock.Lock() s.store[uri] = data s.lock.Unlock() } var ( // resCache is a package level cache for $ref resolution and expansion. // It is initialized lazily by methods that have the need for it: no // memory is allocated unless some expander methods are called. // // It is initialized with JSON schema and swagger schema, // which do not mutate during normal operations. // // All subsequent utilizations of this cache are produced from a shallow // clone of this initial version. resCache simpleCache onceCache sync.Once _ ResolutionCache = &simpleCache{} ) // initResolutionCache initializes the URI resolution cache. To be wrapped in a sync.Once.Do call. func initResolutionCache() { resCache = defaultResolutionCache() } func defaultResolutionCache() *simpleCache { return &simpleCache{store: map[string]interface{}{ "http://swagger.io/v2/schema.json": MustLoadSwagger20Schema(), "http://json-schema.org/draft-04/schema": MustLoadJSONSchemaDraft04(), }} } func cacheOrDefault(cache ResolutionCache) ResolutionCache { onceCache.Do(initResolutionCache) if cache != nil { return cache } // get a shallow clone of the base cache with swagger and json schema return resCache.ShallowClone() }	2.51 KB	2025-05-25 12:27
📄 cache_test.go package spec import ( "testing" "github.com/stretchr/testify/assert" ) func TestDefaultResolutionCache(t *testing.T) { jsonSchema := MustLoadJSONSchemaDraft04() swaggerSchema := MustLoadSwagger20Schema() cache := defaultResolutionCache() sch, ok := cache.Get("not there") assert.False(t, ok) assert.Nil(t, sch) sch, ok = cache.Get("http://swagger.io/v2/schema.json") assert.True(t, ok) assert.Equal(t, swaggerSchema, sch) sch, ok = cache.Get("http://json-schema.org/draft-04/schema") assert.True(t, ok) assert.Equal(t, jsonSchema, sch) cache.Set("something", "here") sch, ok = cache.Get("something") assert.True(t, ok) assert.Equal(t, "here", sch) }	676 B	2025-05-25 12:27
📄 circular_test.go package spec import ( "encoding/json" "net/http" "net/http/httptest" "os" "path/filepath" "testing" "time" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestExpandCircular_Issue3(t testing.T) { jazon, root := expandThisOrDieTrying(t, "fixtures/expansion/overflow.json") require.NotEmpty(t, jazon) // circular $ref point to the expanded root document assertRefInJSON(t, jazon, "#/definitions") // verify that all $ref can resolved against the new root schema assertRefResolve(t, jazon, "", root) // verify that all $ref can be expanded in the new root schema assertRefExpand(t, jazon, "", root) } func TestExpandCircular_RefExpansion(t testing.T) { basePath := filepath.Join("fixtures", "expansion", "circularRefs.json") carsDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(carsDoc, spec)) resolver := defaultSchemaLoader(spec, &ExpandOptions{RelativeBase: basePath}, nil, nil) schema := spec.Definitions["car"] _, err = expandSchema(schema, []string{"#/definitions/car"}, resolver, normalizeBase(basePath)) require.NoError(t, err) jazon := asJSON(t, schema) // circular $ref point to the expanded root document // there are only 2 types with circular definitions assertRefInJSONRegexp(t, jazon, "#/definitions/(car\|category)") // verify that all $ref can resolved against the new root schema assertRefResolve(t, jazon, "", spec) // verify that all $ref can be expanded in the new root schema assertRefExpand(t, jazon, "", spec) } func TestExpandCircular_Spec2Expansion(t testing.T) { // TODO: assert repeatable results (see commented section below) fixturePath := filepath.Join("fixtures", "expansion", "circular-minimal.json") jazon, root := expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) // circular $ref are not always the same, but they sure are one of the nodes assertRefInJSONRegexp(t, jazon, `#/definitions/node\d+`) // circular $ref always resolve against the root assertRefResolve(t, jazon, "", root) // assert stripped $ref in result assert.NotContainsf(t, jazon, "circular-minimal.json#/", "expected %s to be expanded with stripped circular $ref", fixturePath) fixturePath = filepath.Join("fixtures", "expansion", "circularSpec2.json") jazon, root = expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) // circular $ref resolved against the expanded root document assertRefInJSON(t, jazon, `#/definitions/`) // circular $ref always resolve against the root assertRefResolve(t, jazon, "", root) // circular $ref can always be further expanded against the root assertRefExpand(t, jazon, "", root) assert.NotContainsf(t, jazon, "circularSpec.json#/", "expected %s to be expanded with stripped circular $ref", fixturePath) / At the moment, the result of expanding circular references is not stable, when several cycles have intersections: the spec structure is randomly walked through and mutating as expansion is carried out. detected cycles in $ref are not necessarily the shortest matches. This may result in different, functionally correct expanded specs (e.g. with same validations) for i := 0; i < 1; i++ { bbb := expandThisOrDieTrying(t, fixturePath) t.Log(bbb) if !assert.JSONEqf(t, jazon, bbb, "on iteration %d, we should have stable expanded spec", i) { t.FailNow() return } } / } func TestExpandCircular_MoreCircular(t testing.T) { // Additional testcase for circular $ref (from go-openapi/validate): // - $ref with file = current file // - circular is located in remote file // // There are 4 variants to run: // - with/without $ref with local file (so its not really remote) // - with circular in a schema in #/responses // - with circular in a schema in #/parameters fixturePath := filepath.Join("fixtures", "more_circulars", "spec.json") jazon, root := expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "item.json#/item") assertRefResolve(t, jazon, "", root, &ExpandOptions{RelativeBase: fixturePath}) fixturePath = filepath.Join("fixtures", "more_circulars", "spec2.json") jazon, root = expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "item2.json#/item") assertRefResolve(t, jazon, "", root, &ExpandOptions{RelativeBase: fixturePath}) fixturePath = filepath.Join("fixtures", "more_circulars", "spec3.json") jazon, root = expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "item.json#/item") assertRefResolve(t, jazon, "", root, &ExpandOptions{RelativeBase: fixturePath}) fixturePath = filepath.Join("fixtures", "more_circulars", "spec4.json") jazon, root = expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "item4.json#/item") assertRefResolve(t, jazon, "", root, &ExpandOptions{RelativeBase: fixturePath}) } func TestExpandCircular_Issue957(t testing.T) { fixturePath := filepath.Join("fixtures", "bugs", "957", "fixture-957.json") jazon, root := expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) require.NotContainsf(t, jazon, "fixture-957.json#/", "expected %s to be expanded with stripped circular $ref", fixturePath) assertRefInJSON(t, jazon, "#/definitions/") assertRefResolve(t, jazon, "", root) assertRefExpand(t, jazon, "", root) } func TestExpandCircular_Bitbucket(t testing.T) { // Additional testcase for circular $ref (from bitbucket api) fixturePath := filepath.Join("fixtures", "more_circulars", "bitbucket.json") jazon, root := expandThisOrDieTrying(t, fixturePath) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "#/definitions/") assertRefResolve(t, jazon, "", root) assertRefExpand(t, jazon, "", root) } func TestExpandCircular_ResponseWithRoot(t testing.T) { rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join("fixtures", "more_circulars", "resp.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) path := rootDoc.Paths.Paths["/api/v1/getx"] resp := path.Post.Responses.StatusCodeResponses[200] thisCache := cacheOrDefault(nil) // during the first response expand, refs are getting expanded, // so the following expands cannot properly resolve them w/o the document. // this happens in validator.Validate() when different validators try to expand the same mutable response. require.NoError(t, ExpandResponseWithRoot(&resp, rootDoc, thisCache)) jazon := asJSON(t, resp) assertRefInJSON(t, jazon, "#/definitions/MyObj") // do it again require.NoError(t, ExpandResponseWithRoot(&resp, rootDoc, thisCache)) jazon = asJSON(t, resp) assertRefInJSON(t, jazon, "#/definitions/MyObj") } func TestExpandCircular_Issue415(t testing.T) { jazon, root := expandThisOrDieTrying(t, filepath.Join("fixtures", "expansion", "clickmeter.json")) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "#/definitions/") assertRefResolve(t, jazon, "", root) assertRefExpand(t, jazon, "", root) } func TestExpandCircular_SpecExpansion(t testing.T) { jazon, root := expandThisOrDieTrying(t, filepath.Join("fixtures", "expansion", "circularSpec.json")) require.NotEmpty(t, jazon) assertRefInJSON(t, jazon, "#/definitions/Book") assertRefResolve(t, jazon, "", root) assertRefExpand(t, jazon, "", root) } func TestExpandCircular_RemoteCircularID(t testing.T) { go func() { err := http.ListenAndServe("localhost:1234", http.FileServer(http.Dir("fixtures/more_circulars/remote"))) //#nosec if err != nil { panic(err.Error()) } }() time.Sleep(100 * time.Millisecond) // from json-schema test suite testcase for remote with circular ID fixturePath := "http://localhost:1234/tree" jazon, root := expandThisSchemaOrDieTrying(t, fixturePath) assertRefResolve(t, jazon, "", root, &ExpandOptions{RelativeBase: fixturePath}) assertRefExpand(t, jazon, "", root, &ExpandOptions{RelativeBase: fixturePath}) require.NoError(t, ExpandSchemaWithBasePath(root, nil, &ExpandOptions{})) jazon = asJSON(t, root) assertRefInJSONRegexp(t, jazon, "^http://localhost:1234/tree$") // $ref now point to the root doc // a spec using the previous circular schema fixtureSpecPath := filepath.Join("fixtures", "more_circulars", "with-id.json") jazon, doc := expandThisOrDieTrying(t, fixtureSpecPath) assertRefInJSON(t, jazon, fixturePath) // all remaining $ref's point to the circular ID (http://...) // ResolveRef fails, because there are some remote $ref, but ResolveRefWithBasePath is successful assertRefResolve(t, jazon, "", doc, &ExpandOptions{}) assertRefExpand(t, jazon, "", doc) } func TestCircular_RemoteExpandAzure(t testing.T) { // local copy of : https://raw.githubusercontent.com/Azure/azure-rest-api-specs/master/specification/network/resource-manager/Microsoft.Network/stable/2020-04-01/publicIpAddress.json server := httptest.NewServer(http.FileServer(http.Dir("fixtures/azure"))) defer server.Close() basePath := server.URL + "/publicIpAddress.json" jazon, sch := expandThisOrDieTrying(t, basePath) // check a pointer with escaped path pth1, err := ResolvePathItem(sch, MustCreateRef("#/paths/~1subscriptions~1%7BsubscriptionId%7D~1providers~1Microsoft.Network~1publicIPAddresses"), nil) require.NoError(t, err) require.NotNil(t, pth1) // check expected remaining $ref assertRefInJSONRegexp(t, jazon, `^(#/definitions/)\|(networkInterface.json#/definitions/)\|(networkSecurityGroup.json#/definitions/)\|(network.json#/definitions)\|(virtualNetworkTap.json#/definitions/)\|(virtualNetwork.json#/definitions/)\|(privateEndpoint.json#/definitions/)\|(\./examples/)`) // check all $ref resolve in the expanded root // (filter out the remaining $ref in x-ms-example extensions, which are not expanded) t.Run("resolve $ref azure", func(t testing.T) { assertRefResolve(t, jazon, `\./example`, sch, &ExpandOptions{RelativeBase: basePath}) }) }	9.75 KB	2025-05-25 12:27
📄 contact_info.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 spec import ( "encoding/json" "github.com/go-openapi/swag" ) // ContactInfo contact information for the exposed API. // // For more information: http://goo.gl/8us55a#contactObject type ContactInfo struct { ContactInfoProps VendorExtensible } // ContactInfoProps hold the properties of a ContactInfo object type ContactInfoProps struct { Name string `json:"name,omitempty"` URL string `json:"url,omitempty"` Email string `json:"email,omitempty"` } // UnmarshalJSON hydrates ContactInfo from json func (c *ContactInfo) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &c.ContactInfoProps); err != nil { return err } return json.Unmarshal(data, &c.VendorExtensible) } // MarshalJSON produces ContactInfo as json func (c ContactInfo) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(c.ContactInfoProps) if err != nil { return nil, err } b2, err := json.Marshal(c.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2), nil }	1.57 KB	2025-05-25 12:27
📄 contact_info_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const contactInfoJSON = `{ "name": "wordnik api team", "url": "http://developer.wordnik.com", "email": "some@mailayada.dkdkd", "x-teams": "test team" }` var contactInfo = ContactInfo{ContactInfoProps: ContactInfoProps{ Name: "wordnik api team", URL: "http://developer.wordnik.com", Email: "some@mailayada.dkdkd", }, VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-teams": "test team"}}} func TestIntegrationContactInfo(t *testing.T) { b, err := json.MarshalIndent(contactInfo, "", "\t") require.NoError(t, err) assert.Equal(t, contactInfoJSON, string(b)) actual := ContactInfo{} err = json.Unmarshal([]byte(contactInfoJSON), &actual) require.NoError(t, err) assert.EqualValues(t, contactInfo, actual) }	1.44 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 spec import ( "fmt" "log" "os" "path" "runtime" ) // Debug is true when the SWAGGER_DEBUG env var is not empty. // // It enables a more verbose logging of this package. var Debug = os.Getenv("SWAGGER_DEBUG") != "" var ( // specLogger is a debug logger for this package specLogger *log.Logger ) func init() { debugOptions() } func debugOptions() { specLogger = log.New(os.Stdout, "spec:", log.LstdFlags) } func debugLog(msg string, args ...interface{}) { // A private, trivial trace logger, based on go-openapi/spec/expander.go:debugLog() if Debug { _, file1, pos1, _ := runtime.Caller(1) specLogger.Printf("%s:%d: %s", path.Base(file1), pos1, fmt.Sprintf(msg, args...)) } }	1.27 KB	2025-05-25 12:27
📄 debug_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 spec import ( "os" "sync" "testing" "github.com/stretchr/testify/assert" ) var ( logMutex = &sync.Mutex{} ) func TestDebug(t *testing.T) { tmpFile, _ := os.CreateTemp("", "debug-test") tmpName := tmpFile.Name() defer func() { Debug = false // mutex for -race logMutex.Unlock() _ = os.Remove(tmpName) }() // mutex for -race logMutex.Lock() Debug = true debugOptions() defer func() { specLogger.SetOutput(os.Stdout) }() specLogger.SetOutput(tmpFile) debugLog("A debug") Debug = false _ = tmpFile.Close() flushed, _ := os.Open(tmpName) buf := make([]byte, 500) _, _ = flushed.Read(buf) specLogger.SetOutput(os.Stdout) assert.Contains(t, string(buf), "A debug") }	1.28 KB	2025-05-25 12:27
📄 embed.go package spec import ( "embed" "path" ) //go:embed schemas/.json schemas//*.json var assets embed.FS func jsonschemaDraft04JSONBytes() ([]byte, error) { return assets.ReadFile(path.Join("schemas", "jsonschema-draft-04.json")) } func v2SchemaJSONBytes() ([]byte, error) { return assets.ReadFile(path.Join("schemas", "v2", "schema.json")) }	348 B	2025-05-25 12:27
📄 errors.go package spec import "errors" // Error codes var ( // ErrUnknownTypeForReference indicates that a resolved reference was found in an unsupported container type ErrUnknownTypeForReference = errors.New("unknown type for the resolved reference") // ErrResolveRefNeedsAPointer indicates that a $ref target must be a valid JSON pointer ErrResolveRefNeedsAPointer = errors.New("resolve ref: target needs to be a pointer") // ErrDerefUnsupportedType indicates that a resolved reference was found in an unsupported container type. // At the moment, $ref are supported only inside: schemas, parameters, responses, path items ErrDerefUnsupportedType = errors.New("deref: unsupported type") // ErrExpandUnsupportedType indicates that $ref expansion is attempted on some invalid type ErrExpandUnsupportedType = errors.New("expand: unsupported type. Input should be of type Parameter or Response") )	902 B	2025-05-25 12:27
📄 expander.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 spec import ( "encoding/json" "fmt" ) // ExpandOptions provides options for the spec expander. // // RelativeBase is the path to the root document. This can be a remote URL or a path to a local file. // // If left empty, the root document is assumed to be located in the current working directory: // all relative $ref's will be resolved from there. // // PathLoader injects a document loading method. By default, this resolves to the function provided by the SpecLoader package variable. type ExpandOptions struct { RelativeBase string // the path to the root document to expand. This is a file, not a directory SkipSchemas bool // do not expand schemas, just paths, parameters and responses ContinueOnError bool // continue expanding even after and error is found PathLoader func(string) (json.RawMessage, error) `json:"-"` // the document loading method that takes a path as input and yields a json document AbsoluteCircularRef bool // circular $ref remaining after expansion remain absolute URLs } func optionsOrDefault(opts ExpandOptions) ExpandOptions { if opts != nil { clone := opts // shallow clone to avoid internal changes to be propagated to the caller if clone.RelativeBase != "" { clone.RelativeBase = normalizeBase(clone.RelativeBase) } // if the relative base is empty, let the schema loader choose a pseudo root document return &clone } return &ExpandOptions{} } // ExpandSpec expands the references in a swagger spec func ExpandSpec(spec Swagger, options ExpandOptions) error { options = optionsOrDefault(options) resolver := defaultSchemaLoader(spec, options, nil, nil) specBasePath := options.RelativeBase if !options.SkipSchemas { for key, definition := range spec.Definitions { parentRefs := make([]string, 0, 10) parentRefs = append(parentRefs, "#/definitions/"+key) def, err := expandSchema(definition, parentRefs, resolver, specBasePath) if resolver.shouldStopOnError(err) { return err } if def != nil { spec.Definitions[key] = def } } } for key := range spec.Parameters { parameter := spec.Parameters[key] if err := expandParameterOrResponse(&parameter, resolver, specBasePath); resolver.shouldStopOnError(err) { return err } spec.Parameters[key] = parameter } for key := range spec.Responses { response := spec.Responses[key] if err := expandParameterOrResponse(&response, resolver, specBasePath); resolver.shouldStopOnError(err) { return err } spec.Responses[key] = response } if spec.Paths != nil { for key := range spec.Paths.Paths { pth := spec.Paths.Paths[key] if err := expandPathItem(&pth, resolver, specBasePath); resolver.shouldStopOnError(err) { return err } spec.Paths.Paths[key] = pth } } return nil } const rootBase = ".root" // baseForRoot loads in the cache the root document and produces a fake ".root" base path entry // for further $ref resolution func baseForRoot(root interface{}, cache ResolutionCache) string { // cache the root document to resolve $ref's normalizedBase := normalizeBase(rootBase) if root == nil { // ensure that we never leave a nil root: always cache the root base pseudo-document cachedRoot, found := cache.Get(normalizedBase) if found && cachedRoot != nil { // the cache is already preloaded with a root return normalizedBase } root = map[string]interface{}{} } cache.Set(normalizedBase, root) return normalizedBase } // ExpandSchema expands the refs in the schema object with reference to the root object. // // go-openapi/validate uses this function. // // Notice that it is impossible to reference a json schema in a different document other than root // (use ExpandSchemaWithBasePath to resolve external references). // // Setting the cache is optional and this parameter may safely be left to nil. func ExpandSchema(schema Schema, root interface{}, cache ResolutionCache) error { cache = cacheOrDefault(cache) if root == nil { root = schema } opts := &ExpandOptions{ // when a root is specified, cache the root as an in-memory document for $ref retrieval RelativeBase: baseForRoot(root, cache), SkipSchemas: false, ContinueOnError: false, } return ExpandSchemaWithBasePath(schema, cache, opts) } // ExpandSchemaWithBasePath expands the refs in the schema object, base path configured through expand options. // // Setting the cache is optional and this parameter may safely be left to nil. func ExpandSchemaWithBasePath(schema Schema, cache ResolutionCache, opts ExpandOptions) error { if schema == nil { return nil } cache = cacheOrDefault(cache) opts = optionsOrDefault(opts) resolver := defaultSchemaLoader(nil, opts, cache, nil) parentRefs := make([]string, 0, 10) s, err := expandSchema(schema, parentRefs, resolver, opts.RelativeBase) if err != nil { return err } if s != nil { // guard for when continuing on error schema = s } return nil } func expandItems(target Schema, parentRefs []string, resolver schemaLoader, basePath string) (Schema, error) { if target.Items == nil { return &target, nil } // array if target.Items.Schema != nil { t, err := expandSchema(target.Items.Schema, parentRefs, resolver, basePath) if err != nil { return nil, err } target.Items.Schema = t } // tuple for i := range target.Items.Schemas { t, err := expandSchema(target.Items.Schemas[i], parentRefs, resolver, basePath) if err != nil { return nil, err } target.Items.Schemas[i] = t } return &target, nil } func expandSchema(target Schema, parentRefs []string, resolver schemaLoader, basePath string) (Schema, error) { if target.Ref.String() == "" && target.Ref.IsRoot() { newRef := normalizeRef(&target.Ref, basePath) target.Ref = newRef return &target, nil } // change the base path of resolution when an ID is encountered // otherwise the basePath should inherit the parent's if target.ID != "" { basePath, _ = resolver.setSchemaID(target, target.ID, basePath) } if target.Ref.String() != "" { if !resolver.options.SkipSchemas { return expandSchemaRef(target, parentRefs, resolver, basePath) } // when "expand" with SkipSchema, we just rebase the existing $ref without replacing // the full schema. rebasedRef, err := NewRef(normalizeURI(target.Ref.String(), basePath)) if err != nil { return nil, err } target.Ref = denormalizeRef(&rebasedRef, resolver.context.basePath, resolver.context.rootID) return &target, nil } for k := range target.Definitions { tt, err := expandSchema(target.Definitions[k], parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if tt != nil { target.Definitions[k] = tt } } t, err := expandItems(target, parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target = t } for i := range target.AllOf { t, err := expandSchema(target.AllOf[i], parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.AllOf[i] = t } } for i := range target.AnyOf { t, err := expandSchema(target.AnyOf[i], parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.AnyOf[i] = t } } for i := range target.OneOf { t, err := expandSchema(target.OneOf[i], parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.OneOf[i] = t } } if target.Not != nil { t, err := expandSchema(target.Not, parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.Not = t } } for k := range target.Properties { t, err := expandSchema(target.Properties[k], parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.Properties[k] = t } } if target.AdditionalProperties != nil && target.AdditionalProperties.Schema != nil { t, err := expandSchema(target.AdditionalProperties.Schema, parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.AdditionalProperties.Schema = t } } for k := range target.PatternProperties { t, err := expandSchema(target.PatternProperties[k], parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.PatternProperties[k] = t } } for k := range target.Dependencies { if target.Dependencies[k].Schema != nil { t, err := expandSchema(target.Dependencies[k].Schema, parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.Dependencies[k].Schema = t } } } if target.AdditionalItems != nil && target.AdditionalItems.Schema != nil { t, err := expandSchema(target.AdditionalItems.Schema, parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return &target, err } if t != nil { target.AdditionalItems.Schema = t } } return &target, nil } func expandSchemaRef(target Schema, parentRefs []string, resolver schemaLoader, basePath string) (Schema, error) { // if a Ref is found, all sibling fields are skipped // Ref also changes the resolution scope of children expandSchema // here the resolution scope is changed because a $ref was encountered normalizedRef := normalizeRef(&target.Ref, basePath) normalizedBasePath := normalizedRef.RemoteURI() if resolver.isCircular(normalizedRef, basePath, parentRefs...) { // this means there is a cycle in the recursion tree: return the Ref // - circular refs cannot be expanded. We leave them as ref. // - denormalization means that a new local file ref is set relative to the original basePath debugLog("short circuit circular ref: basePath: %s, normalizedPath: %s, normalized ref: %s", basePath, normalizedBasePath, normalizedRef.String()) if !resolver.options.AbsoluteCircularRef { target.Ref = denormalizeRef(normalizedRef, resolver.context.basePath, resolver.context.rootID) } else { target.Ref = normalizedRef } return &target, nil } var t Schema err := resolver.Resolve(&target.Ref, &t, basePath) if resolver.shouldStopOnError(err) { return nil, err } if t == nil { // guard for when continuing on error return &target, nil } parentRefs = append(parentRefs, normalizedRef.String()) transitiveResolver := resolver.transitiveResolver(basePath, target.Ref) basePath = resolver.updateBasePath(transitiveResolver, normalizedBasePath) return expandSchema(t, parentRefs, transitiveResolver, basePath) } func expandPathItem(pathItem PathItem, resolver schemaLoader, basePath string) error { if pathItem == nil { return nil } parentRefs := make([]string, 0, 10) if err := resolver.deref(pathItem, parentRefs, basePath); resolver.shouldStopOnError(err) { return err } if pathItem.Ref.String() != "" { transitiveResolver := resolver.transitiveResolver(basePath, pathItem.Ref) basePath = transitiveResolver.updateBasePath(resolver, basePath) resolver = transitiveResolver } pathItem.Ref = Ref{} for i := range pathItem.Parameters { if err := expandParameterOrResponse(&(pathItem.Parameters[i]), resolver, basePath); resolver.shouldStopOnError(err) { return err } } ops := []Operation{ pathItem.Get, pathItem.Head, pathItem.Options, pathItem.Put, pathItem.Post, pathItem.Patch, pathItem.Delete, } for _, op := range ops { if err := expandOperation(op, resolver, basePath); resolver.shouldStopOnError(err) { return err } } return nil } func expandOperation(op Operation, resolver schemaLoader, basePath string) error { if op == nil { return nil } for i := range op.Parameters { param := op.Parameters[i] if err := expandParameterOrResponse(&param, resolver, basePath); resolver.shouldStopOnError(err) { return err } op.Parameters[i] = param } if op.Responses == nil { return nil } responses := op.Responses if err := expandParameterOrResponse(responses.Default, resolver, basePath); resolver.shouldStopOnError(err) { return err } for code := range responses.StatusCodeResponses { response := responses.StatusCodeResponses[code] if err := expandParameterOrResponse(&response, resolver, basePath); resolver.shouldStopOnError(err) { return err } responses.StatusCodeResponses[code] = response } return nil } // ExpandResponseWithRoot expands a response based on a root document, not a fetchable document // // Notice that it is impossible to reference a json schema in a different document other than root // (use ExpandResponse to resolve external references). // // Setting the cache is optional and this parameter may safely be left to nil. func ExpandResponseWithRoot(response Response, root interface{}, cache ResolutionCache) error { cache = cacheOrDefault(cache) opts := &ExpandOptions{ RelativeBase: baseForRoot(root, cache), } resolver := defaultSchemaLoader(root, opts, cache, nil) return expandParameterOrResponse(response, resolver, opts.RelativeBase) } // ExpandResponse expands a response based on a basepath // // All refs inside response will be resolved relative to basePath func ExpandResponse(response Response, basePath string) error { opts := optionsOrDefault(&ExpandOptions{ RelativeBase: basePath, }) resolver := defaultSchemaLoader(nil, opts, nil, nil) return expandParameterOrResponse(response, resolver, opts.RelativeBase) } // ExpandParameterWithRoot expands a parameter based on a root document, not a fetchable document. // // Notice that it is impossible to reference a json schema in a different document other than root // (use ExpandParameter to resolve external references). func ExpandParameterWithRoot(parameter Parameter, root interface{}, cache ResolutionCache) error { cache = cacheOrDefault(cache) opts := &ExpandOptions{ RelativeBase: baseForRoot(root, cache), } resolver := defaultSchemaLoader(root, opts, cache, nil) return expandParameterOrResponse(parameter, resolver, opts.RelativeBase) } // ExpandParameter expands a parameter based on a basepath. // This is the exported version of expandParameter // all refs inside parameter will be resolved relative to basePath func ExpandParameter(parameter Parameter, basePath string) error { opts := optionsOrDefault(&ExpandOptions{ RelativeBase: basePath, }) resolver := defaultSchemaLoader(nil, opts, nil, nil) return expandParameterOrResponse(parameter, resolver, opts.RelativeBase) } func getRefAndSchema(input interface{}) (Ref, Schema, error) { var ( ref Ref sch Schema ) switch refable := input.(type) { case Parameter: if refable == nil { return nil, nil, nil } ref = &refable.Ref sch = refable.Schema case Response: if refable == nil { return nil, nil, nil } ref = &refable.Ref sch = refable.Schema default: return nil, nil, fmt.Errorf("unsupported type: %T: %w", input, ErrExpandUnsupportedType) } return ref, sch, nil } func expandParameterOrResponse(input interface{}, resolver schemaLoader, basePath string) error { ref, sch, err := getRefAndSchema(input) if err != nil { return err } if ref == nil && sch == nil { // nothing to do return nil } parentRefs := make([]string, 0, 10) if ref != nil { // dereference this $ref if err = resolver.deref(input, parentRefs, basePath); resolver.shouldStopOnError(err) { return err } ref, sch, _ = getRefAndSchema(input) } if ref.String() != "" { transitiveResolver := resolver.transitiveResolver(basePath, ref) basePath = resolver.updateBasePath(transitiveResolver, basePath) resolver = transitiveResolver } if sch == nil { // nothing to be expanded if ref != nil { ref = Ref{} } return nil } if sch.Ref.String() != "" { rebasedRef, ern := NewRef(normalizeURI(sch.Ref.String(), basePath)) if ern != nil { return ern } if resolver.isCircular(&rebasedRef, basePath, parentRefs...) { // this is a circular $ref: stop expansion if !resolver.options.AbsoluteCircularRef { sch.Ref = denormalizeRef(&rebasedRef, resolver.context.basePath, resolver.context.rootID) } else { sch.Ref = rebasedRef } } } // $ref expansion or rebasing is performed by expandSchema below if ref != nil { ref = Ref{} } // expand schema // yes, we do it even if options.SkipSchema is true: we have to go down that rabbit hole and rebase nested $ref) s, err := expandSchema(sch, parentRefs, resolver, basePath) if resolver.shouldStopOnError(err) { return err } if s != nil { // guard for when continuing on error sch = *s } return nil }	17.14 KB	2025-05-25 12:27
📄 expander_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 spec import ( "encoding/json" "io" "log" "net/http" "net/http/httptest" "os" "path/filepath" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const ( crossFileRefFixture = "fixtures/expansion/crossFileRef.json" withoutSchemaID = "removed" withSchemaID = "schema" pathItemsFixture = "fixtures/expansion/pathItems.json" extraRefFixture = "fixtures/expansion/extraRef.json" ) var ( // PetStoreJSONMessage json raw message for Petstore20 PetStoreJSONMessage = json.RawMessage([]byte(PetStore20)) specs = filepath.Join("fixtures", "specs") ) func TestExpand_Issue148(t testing.T) { fp := filepath.Join("fixtures", "bugs", "schema-148.json") b, err := jsonDoc(fp) require.NoError(t, err) assertAdditionalProps := func(sp Swagger) func(testing.T) { return func(t testing.T) { require.Len(t, sp.Definitions, 2) require.Contains(t, sp.Definitions, "empty") empty := sp.Definitions["empty"] require.NotNil(t, empty.AdditionalProperties) require.NotNil(t, empty.AdditionalProperties.Schema) require.True(t, empty.AdditionalProperties.Allows) require.Contains(t, sp.Definitions, "false") additionalIsFalse := sp.Definitions["false"] require.NotNil(t, additionalIsFalse.AdditionalProperties) require.Nil(t, additionalIsFalse.AdditionalProperties.Schema) require.False(t, additionalIsFalse.AdditionalProperties.Allows) } } var sp Swagger require.NoError(t, json.Unmarshal(b, &sp)) t.Run("check additional properties", assertAdditionalProps(sp)) require.NoError(t, ExpandSpec(&sp, nil)) t.Run("check additional properties after expansion", assertAdditionalProps(sp)) } func TestExpand_KnownRef(t testing.T) { // json schema draft 4 meta schema is embedded by default: it resolves without setup schema := RefProperty("http://json-schema.org/draft-04/schema#") require.NoError(t, ExpandSchema(schema, nil, nil)) assert.Equal(t, "Core schema meta-schema", schema.Description) // from the expanded schema, verify that all remaining $ref actually resolve jazon := asJSON(t, schema) assertRefResolve(t, jazon, "", schema) } func TestExpand_ResponseSchema(t testing.T) { fp := filepath.Join("fixtures", "local_expansion", "spec.json") b, err := jsonDoc(fp) require.NoError(t, err) var spec Swagger require.NoError(t, json.Unmarshal(b, &spec)) require.NoError(t, ExpandSpec(&spec, &ExpandOptions{RelativeBase: fp})) // verify that the document is full expanded jazon := asJSON(t, spec) assertNoRef(t, jazon) sch := spec.Paths.Paths["/item"].Get.Responses.StatusCodeResponses[200].Schema require.NotNil(t, sch) assert.Empty(t, sch.Ref.String()) assert.Contains(t, sch.Type, "object") assert.Len(t, sch.Properties, 2) } func TestExpand_EmptySpec(t testing.T) { spec := new(Swagger) // expansion of an empty spec require.NoError(t, ExpandSpec(spec, nil)) // expansion of a nil schema var schema Schema require.NoError(t, ExpandSchemaWithBasePath(schema, nil, nil)) // expansion of a nil paths var paths PathItem resolver := defaultSchemaLoader(spec, nil, nil, nil) require.NoError(t, expandPathItem(paths, resolver, "")) // expansion of a nil Parameter var param Parameter require.NoError(t, expandParameterOrResponse(param, resolver, "")) } func TestExpand_Spec(t testing.T) { // expansion of a rich spec specPath := filepath.Join("fixtures", "expansion", "all-the-things.json") specDoc, err := jsonDoc(specPath) require.NoError(t, err) opts := &ExpandOptions{ RelativeBase: specPath, } spec := new(Swagger) require.NoError(t, json.Unmarshal(specDoc, spec)) // verify the resulting unmarshaled structure pet := spec.Definitions["pet"] errorModel := spec.Definitions["errorModel"] petResponse := spec.Responses["petResponse"] petResponse.Schema = &pet stringResponse := spec.Responses["stringResponse"] tagParam := spec.Parameters["tag"] idParam := spec.Parameters["idParam"] require.NoError(t, ExpandSpec(spec, opts)) // verify that the spec is fully expanded assertNoRef(t, asJSON(t, spec)) assert.Equal(t, tagParam, spec.Parameters["query"]) assert.Equal(t, petResponse, spec.Responses["petResponse"]) assert.Equal(t, petResponse, spec.Responses["anotherPet"]) assert.Equal(t, pet, spec.Responses["petResponse"].Schema) assert.Equal(t, stringResponse, spec.Paths.Paths["/"].Get.Responses.Default) assert.Equal(t, petResponse, spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200]) assert.Equal(t, pet, spec.Paths.Paths["/pets"].Get.Responses.StatusCodeResponses[200].Schema.Items.Schema) assert.Equal(t, errorModel, spec.Paths.Paths["/pets"].Get.Responses.Default.Schema) assert.Equal(t, pet, spec.Definitions["petInput"].AllOf[0]) assert.Equal(t, spec.Definitions["petInput"], spec.Paths.Paths["/pets"].Post.Parameters[0].Schema) assert.Equal(t, petResponse, spec.Paths.Paths["/pets"].Post.Responses.StatusCodeResponses[200]) assert.Equal(t, errorModel, spec.Paths.Paths["/pets"].Post.Responses.Default.Schema) pi := spec.Paths.Paths["/pets/{id}"] assert.Equal(t, idParam, pi.Get.Parameters[0]) assert.Equal(t, petResponse, pi.Get.Responses.StatusCodeResponses[200]) assert.Equal(t, errorModel, pi.Get.Responses.Default.Schema) assert.Equal(t, idParam, pi.Delete.Parameters[0]) assert.Equal(t, errorModel, pi.Delete.Responses.Default.Schema) } func TestExpand_InternalResponse(t testing.T) { basePath := normalizeBase(filepath.Join("fixtures", "expansion", "all-the-things.json")) specDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(specDoc, spec)) resolver := defaultSchemaLoader(spec, nil, nil, nil) expectedPet := spec.Responses["petResponse"] require.NoError(t, expandParameterOrResponse(&expectedPet, resolver, basePath)) jazon := asJSON(t, expectedPet) assert.JSONEq(t, `{ "description": "pet response", "schema": { "required": [ "id", "name" ], "properties": { "id": { "type": "integer", "format": "int64" }, "name": { "type": "string" }, "tag": { "type": "string" } } } }`, jazon) // response pointing to the same target: result is unchanged another := spec.Responses["anotherPet"] require.NoError(t, expandParameterOrResponse(&another, resolver, basePath)) assert.Equal(t, expectedPet, another) defaultResponse := spec.Paths.Paths["/"].Get.Responses.Default require.NoError(t, expandParameterOrResponse(defaultResponse, resolver, basePath)) expectedString := spec.Responses["stringResponse"] assert.Equal(t, expectedString, defaultResponse) // cascading ref successResponse := spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200] jazon = asJSON(t, successResponse) assert.JSONEq(t, `{ "$ref": "#/responses/anotherPet" }`, jazon) require.NoError(t, expandParameterOrResponse(&successResponse, resolver, basePath)) assert.Equal(t, expectedPet, successResponse) } func TestExpand_Response(t testing.T) { basePath := filepath.Join("fixtures", "expansion", "all-the-things.json") specDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(specDoc, spec)) resp := spec.Responses["anotherPet"] expected := spec.Responses["petResponse"] require.NoError(t, ExpandResponse(&expected, basePath)) require.NoError(t, ExpandResponse(&resp, basePath)) assert.Equal(t, expected, resp) resp2 := spec.Paths.Paths["/"].Get.Responses.Default expected = spec.Responses["stringResponse"] require.NoError(t, ExpandResponse(resp2, basePath)) assert.Equal(t, expected, resp2) resp = spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200] expected = spec.Responses["petResponse"] require.NoError(t, ExpandResponse(&resp, basePath)) assert.Equal(t, expected, resp) } func TestExpand_ResponseAndParamWithRoot(t testing.T) { specDoc, err := jsonDoc("fixtures/bugs/1614/gitea.json") require.NoError(t, err) var spec Swagger err = json.Unmarshal(specDoc, &spec) require.NoError(t, err) // check responses with $ref resp := spec.Paths.Paths["/admin/users"].Post.Responses.StatusCodeResponses[201] require.NoError(t, ExpandResponseWithRoot(&resp, spec, nil)) jazon := asJSON(t, resp) assertNoRef(t, jazon) resp = spec.Paths.Paths["/admin/users"].Post.Responses.StatusCodeResponses[403] require.NoError(t, ExpandResponseWithRoot(&resp, spec, nil)) jazon = asJSON(t, resp) assertNoRef(t, jazon) // check param with $ref param := spec.Paths.Paths["/admin/users"].Post.Parameters[0] require.NoError(t, ExpandParameterWithRoot(&param, spec, nil)) jazon = asJSON(t, param) assertNoRef(t, jazon) } func TestExpand_InternalParameter(t testing.T) { basePath := normalizeBase(filepath.Join("fixtures", "expansion", "params.json")) paramDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(paramDoc, spec)) resolver := defaultSchemaLoader(spec, nil, nil, nil) param := spec.Parameters["query"] expected := spec.Parameters["tag"] require.NoError(t, expandParameterOrResponse(&param, resolver, basePath)) assert.Equal(t, expected, param) param = spec.Paths.Paths["/cars/{id}"].Parameters[0] expected = spec.Parameters["id"] require.NoError(t, expandParameterOrResponse(&param, resolver, basePath)) assert.Equal(t, expected, param) } func TestExpand_Parameter(t testing.T) { basePath := filepath.Join("fixtures", "expansion", "params.json") paramDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(paramDoc, spec)) param := spec.Parameters["query"] expected := spec.Parameters["tag"] require.NoError(t, ExpandParameter(&param, basePath)) assert.Equal(t, expected, param) param = spec.Paths.Paths["/cars/{id}"].Parameters[0] expected = spec.Parameters["id"] require.NoError(t, ExpandParameter(&param, basePath)) assert.Equal(t, expected, param) } func TestExpand_JSONSchemaDraft4(t testing.T) { fixturePath := filepath.Join("schemas", "jsonschema-draft-04.json") jazon, sch := expandThisSchemaOrDieTrying(t, fixturePath) // expansion leaves some circular $ref behind: let's assert those // assert all $ref match // "$ref": "http://json-schema.org/draft-04/something" // // Case: Circular $refs against schema ID assertRefInJSONRegexp(t, jazon, `^(http://json-schema.org/draft-04/)\|(#/definitions/schemaArray)`) // verify that all remaining $ref may be expanded in the new root schema assertRefExpand(t, jazon, "", sch) } func TestExpand_SwaggerSchema(t testing.T) { fixturePath := filepath.Join("schemas", "v2", "schema.json") jazon, sch := expandThisSchemaOrDieTrying(t, fixturePath) // expansion leaves some circular $ref behind: let's assert those // assert all $ref match // "$ref": "#/definitions/something" assertRefInJSON(t, jazon, "#/definitions/") // verify that all $ref resolve in the new root schema assertRefExpand(t, jazon, "", sch) } func TestExpand_ContinueOnError(t testing.T) { specPath := filepath.Join("fixtures", "expansion", "missingRef.json") defer log.SetOutput(os.Stdout) log.SetOutput(io.Discard) // missing $ref in spec missingRefDoc, err := jsonDoc(specPath) require.NoError(t, err) testCase := struct { Input Swagger `json:"input"` Expected Swagger `json:"expected"` }{} require.NoError(t, json.Unmarshal(missingRefDoc, &testCase)) opts := &ExpandOptions{ ContinueOnError: true, RelativeBase: specPath, } require.NoError(t, ExpandSpec(testCase.Input, opts)) assert.Equal(t, testCase.Expected, testCase.Input, "Should continue expanding spec when a definition can't be found.") // missing $ref in items doc, err := jsonDoc("fixtures/expansion/missingItemRef.json") require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(doc, spec)) assert.NotPanics(t, func() { require.NoError(t, ExpandSpec(spec, opts)) }, "Array of missing refs should not cause a panic, and continue to expand spec.") } func TestExpand_InternalSchemas2(t testing.T) { basePath := normalizeBase(filepath.Join("fixtures", "expansion", "schemas2.json")) carsDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(carsDoc, spec)) resolver := defaultSchemaLoader(spec, nil, nil, nil) // verify unmarshaled structure schema := spec.Definitions["car"] oldBrand := schema.Properties["brand"] require.NotEmpty(t, oldBrand.Items.Schema.Ref.String()) // this is a $ref require.NotEqual(t, spec.Definitions["brand"], oldBrand) _, err = expandSchema(schema, []string{"#/definitions/car"}, resolver, basePath) require.NoError(t, err) // verify expanded schema for Car, in the document passed newBrand := schema.Properties["brand"] assert.Empty(t, newBrand.Items.Schema.Ref.String()) assert.Equal(t, spec.Definitions["brand"], newBrand.Items.Schema) // verify expanded schema for Truck, in the returned schema schema = spec.Definitions["truck"] require.NotEmpty(t, schema.Items.Schema.Ref.String()) s, err := expandSchema(schema, []string{"#/definitions/truck"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Items.Schema.Ref.String()) // no more a $ref assert.False(t, schema.Items.Schema.Ref.IsRoot()) // no more a $ref assert.Equal(t, spec.Definitions["car"], schema.Items.Schema) sch := new(Schema) _, err = expandSchema(sch, []string{""}, resolver, basePath) require.NoError(t, err) // verify expanded schema for Batch, in the returned schema schema = spec.Definitions["batch"] s, err = expandSchema(schema, []string{"#/definitions/batch"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Items.Schema.Items.Schema.Ref.String()) assert.Equal(t, schema.Items.Schema.Items.Schema, spec.Definitions["brand"]) // verify expanded schema for Batch2, in the returned schema schema = spec.Definitions["batch2"] s, err = expandSchema(schema, []string{"#/definitions/batch2"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Items.Schemas[0].Items.Schema.Ref.String()) assert.Empty(t, schema.Items.Schemas[1].Items.Schema.Ref.String()) assert.Equal(t, schema.Items.Schemas[0].Items.Schema, spec.Definitions["brand"]) assert.Equal(t, schema.Items.Schemas[1].Items.Schema, spec.Definitions["tag"]) // verify expanded schema for AllOfBoth, in the returned schema [expand allOf] schema = spec.Definitions["allofBoth"] s, err = expandSchema(schema, []string{"#/definitions/allofBoth"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AllOf[0].Items.Schema.Ref.String()) assert.Empty(t, schema.AllOf[1].Items.Schema.Ref.String()) assert.Equal(t, schema.AllOf[0].Items.Schema, spec.Definitions["brand"]) assert.Equal(t, schema.AllOf[1].Items.Schema, spec.Definitions["tag"]) // verify expanded schema for AnyOfBoth, in the returned schema [expand anyOf] schema = spec.Definitions["anyofBoth"] s, err = expandSchema(schema, []string{"#/definitions/anyofBoth"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AnyOf[0].Items.Schema.Ref.String()) assert.Empty(t, schema.AnyOf[1].Items.Schema.Ref.String()) assert.Equal(t, schema.AnyOf[0].Items.Schema, spec.Definitions["brand"]) assert.Equal(t, schema.AnyOf[1].Items.Schema, spec.Definitions["tag"]) // verify expanded schema for OneOfBoth, in the returned schema [expand oneOf] schema = spec.Definitions["oneofBoth"] s, err = expandSchema(schema, []string{"#/definitions/oneofBoth"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.OneOf[0].Items.Schema.Ref.String()) assert.Empty(t, schema.OneOf[1].Items.Schema.Ref.String()) assert.Equal(t, schema.OneOf[0].Items.Schema, spec.Definitions["brand"]) assert.Equal(t, schema.OneOf[1].Items.Schema, spec.Definitions["tag"]) // verify expanded schema for NotSomething, in the returned schema [expand not] schema = spec.Definitions["notSomething"] s, err = expandSchema(schema, []string{"#/definitions/notSomething"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Not.Items.Schema.Ref.String()) assert.Equal(t, schema.Not.Items.Schema, spec.Definitions["tag"]) // verify expanded schema for WithAdditional, in the returned schema [expand additionalProperties] schema = spec.Definitions["withAdditional"] s, err = expandSchema(schema, []string{"#/definitions/withAdditional"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AdditionalProperties.Schema.Items.Schema.Ref.String()) assert.Equal(t, schema.AdditionalProperties.Schema.Items.Schema, spec.Definitions["tag"]) // verify expanded schema for WithAdditionalItems, in the returned schema [expand additionalItems] schema = spec.Definitions["withAdditionalItems"] s, err = expandSchema(schema, []string{"#/definitions/withAdditionalItems"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AdditionalItems.Schema.Items.Schema.Ref.String()) assert.Equal(t, schema.AdditionalItems.Schema.Items.Schema, spec.Definitions["tag"]) // verify expanded schema for WithPattern, in the returned schema [expand PatternProperties] schema = spec.Definitions["withPattern"] s, err = expandSchema(schema, []string{"#/definitions/withPattern"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s prop := schema.PatternProperties["^x-ab"] assert.Empty(t, prop.Items.Schema.Ref.String()) assert.Equal(t, prop.Items.Schema, spec.Definitions["tag"]) // verify expanded schema for Deps, in the returned schema [expand dependencies] schema = spec.Definitions["deps"] s, err = expandSchema(schema, []string{"#/definitions/deps"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s prop2 := schema.Dependencies["something"] assert.Empty(t, prop2.Schema.Items.Schema.Ref.String()) assert.Equal(t, prop2.Schema.Items.Schema, spec.Definitions["tag"]) // verify expanded schema for Defined, in the returned schema [expand nested definitions] schema = spec.Definitions["defined"] s, err = expandSchema(schema, []string{"#/definitions/defined"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s prop = schema.Definitions["something"] assert.Empty(t, prop.Items.Schema.Ref.String()) assert.Equal(t, prop.Items.Schema, spec.Definitions["tag"]) } func TestExpand_InternalSchemas1(t testing.T) { basePath := normalizeBase(filepath.Join("fixtures", "expansion", "schemas1.json")) carsDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(carsDoc, spec)) resolver := defaultSchemaLoader(spec, nil, nil, nil) schema := spec.Definitions["car"] oldBrand := schema.Properties["brand"] assert.NotEmpty(t, oldBrand.Ref.String()) assert.NotEqual(t, spec.Definitions["brand"], oldBrand) s, err := expandSchema(schema, []string{"#/definitions/car"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s newBrand := schema.Properties["brand"] assert.Empty(t, newBrand.Ref.String()) assert.Equal(t, spec.Definitions["brand"], newBrand) schema = spec.Definitions["truck"] assert.NotEmpty(t, schema.Ref.String()) s, err = expandSchema(schema, []string{"#/definitions/truck"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Ref.String()) assert.Equal(t, spec.Definitions["car"], schema) sch := new(Schema) _, err = expandSchema(sch, []string{""}, resolver, basePath) require.NoError(t, err) schema = spec.Definitions["batch"] s, err = expandSchema(schema, []string{"#/definitions/batch"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Items.Schema.Ref.String()) assert.Equal(t, schema.Items.Schema, spec.Definitions["brand"]) schema = spec.Definitions["batch2"] s, err = expandSchema(schema, []string{"#/definitions/batch2"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Items.Schemas[0].Ref.String()) assert.Empty(t, schema.Items.Schemas[1].Ref.String()) assert.Equal(t, schema.Items.Schemas[0], spec.Definitions["brand"]) assert.Equal(t, schema.Items.Schemas[1], spec.Definitions["tag"]) schema = spec.Definitions["allofBoth"] s, err = expandSchema(schema, []string{"#/definitions/allofBoth"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AllOf[0].Ref.String()) assert.Empty(t, schema.AllOf[1].Ref.String()) assert.Equal(t, schema.AllOf[0], spec.Definitions["brand"]) assert.Equal(t, schema.AllOf[1], spec.Definitions["tag"]) schema = spec.Definitions["anyofBoth"] s, err = expandSchema(schema, []string{"#/definitions/anyofBoth"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AnyOf[0].Ref.String()) assert.Empty(t, schema.AnyOf[1].Ref.String()) assert.Equal(t, schema.AnyOf[0], spec.Definitions["brand"]) assert.Equal(t, schema.AnyOf[1], spec.Definitions["tag"]) schema = spec.Definitions["oneofBoth"] s, err = expandSchema(schema, []string{"#/definitions/oneofBoth"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.OneOf[0].Ref.String()) assert.Empty(t, schema.OneOf[1].Ref.String()) assert.Equal(t, schema.OneOf[0], spec.Definitions["brand"]) assert.Equal(t, schema.OneOf[1], spec.Definitions["tag"]) schema = spec.Definitions["notSomething"] s, err = expandSchema(schema, []string{"#/definitions/notSomething"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.Not.Ref.String()) assert.Equal(t, schema.Not, spec.Definitions["tag"]) schema = spec.Definitions["withAdditional"] s, err = expandSchema(schema, []string{"#/definitions/withAdditional"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AdditionalProperties.Schema.Ref.String()) assert.Equal(t, schema.AdditionalProperties.Schema, spec.Definitions["tag"]) schema = spec.Definitions["withAdditionalItems"] s, err = expandSchema(schema, []string{"#/definitions/withAdditionalItems"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s assert.Empty(t, schema.AdditionalItems.Schema.Ref.String()) assert.Equal(t, schema.AdditionalItems.Schema, spec.Definitions["tag"]) schema = spec.Definitions["withPattern"] s, err = expandSchema(schema, []string{"#/definitions/withPattern"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s prop := schema.PatternProperties["^x-ab"] assert.Empty(t, prop.Ref.String()) assert.Equal(t, prop, spec.Definitions["tag"]) schema = spec.Definitions["deps"] s, err = expandSchema(schema, []string{"#/definitions/deps"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s prop2 := schema.Dependencies["something"] assert.Empty(t, prop2.Schema.Ref.String()) assert.Equal(t, prop2.Schema, spec.Definitions["tag"]) schema = spec.Definitions["defined"] s, err = expandSchema(schema, []string{"#/definitions/defined"}, resolver, basePath) require.NoError(t, err) require.NotNil(t, s) schema = s prop = schema.Definitions["something"] assert.Empty(t, prop.Ref.String()) assert.Equal(t, prop, spec.Definitions["tag"]) } func TestExpand_RelativeBaseURI(t testing.T) { server := httptest.NewServer(http.FileServer(http.Dir("fixtures/remote"))) defer server.Close() spec := new(Swagger) require.NoError(t, ExpandSpec(spec, nil)) // this a spec on local fs... specDoc, err := jsonDoc("fixtures/remote/all-the-things.json") require.NoError(t, err) spec = new(Swagger) require.NoError(t, json.Unmarshal(specDoc, spec)) pet := spec.Definitions["pet"] errorModel := spec.Definitions["errorModel"] petResponse := spec.Responses["petResponse"] petResponse.Schema = &pet stringResponse := spec.Responses["stringResponse"] tagParam := spec.Parameters["tag"] idParam := spec.Parameters["idParam"] anotherPet := spec.Responses["anotherPet"] // ... with some $ref with http scheme anotherPet.Ref = MustCreateRef(server.URL + "/" + anotherPet.Ref.String()) opts := &ExpandOptions{ RelativeBase: server.URL + "/all-the-things.json", } require.NoError(t, ExpandResponse(&anotherPet, opts.RelativeBase)) spec.Responses["anotherPet"] = anotherPet circularA := spec.Responses["circularA"] circularA.Ref = MustCreateRef(server.URL + "/" + circularA.Ref.String()) require.NoError(t, ExpandResponse(&circularA, opts.RelativeBase)) // circularA is self-referencing: results in an empty response: this is okay and expected // for the expand use case. The flatten use case should however be expected to fail on this. assert.Empty(t, circularA.Description) assert.Empty(t, circularA.Ref) spec.Responses["circularA"] = circularA // expand again, no issue should arise require.NoError(t, ExpandSpec(spec, opts)) // backRef navigates back to the root document (relative $ref) backRef := spec.Responses["backRef"] require.NoError(t, ExpandResponse(&backRef, opts.RelativeBase)) assert.Equal(t, "pet response", backRef.Description) assert.NotEmpty(t, backRef.Schema) assert.Empty(t, backRef.Ref) assert.Equal(t, tagParam, spec.Parameters["query"]) assert.Equal(t, petResponse, spec.Responses["petResponse"]) assert.Equal(t, petResponse, spec.Responses["anotherPet"]) assert.Equal(t, petResponse, spec.Paths.Paths["/pets"].Post.Responses.StatusCodeResponses[200]) assert.Equal(t, petResponse, spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200]) assert.Equal(t, pet, spec.Paths.Paths["/pets"].Get.Responses.StatusCodeResponses[200].Schema.Items.Schema) assert.Equal(t, pet, spec.Responses["petResponse"].Schema) assert.Equal(t, pet, spec.Definitions["petInput"].AllOf[0]) assert.Equal(t, spec.Definitions["petInput"], spec.Paths.Paths["/pets"].Post.Parameters[0].Schema) assert.Equal(t, stringResponse, spec.Paths.Paths["/"].Get.Responses.Default) assert.Equal(t, errorModel, spec.Paths.Paths["/pets"].Get.Responses.Default.Schema) assert.Equal(t, errorModel, spec.Paths.Paths["/pets"].Post.Responses.Default.Schema) pi := spec.Paths.Paths["/pets/{id}"] assert.Equal(t, idParam, pi.Get.Parameters[0]) assert.Equal(t, petResponse, pi.Get.Responses.StatusCodeResponses[200]) assert.Equal(t, idParam, pi.Delete.Parameters[0]) assert.Equal(t, errorModel, pi.Get.Responses.Default.Schema) assert.Equal(t, errorModel, pi.Delete.Responses.Default.Schema) } func resolutionContextServer() httptest.Server { var servedAt string server := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req http.Request) { if req.URL.Path == "/resolution.json" { b, _ := os.ReadFile(filepath.Join(specs, "resolution.json")) var ctnt map[string]interface{} _ = json.Unmarshal(b, &ctnt) ctnt["id"] = servedAt rw.Header().Set("Content-Type", "application/json") rw.WriteHeader(http.StatusOK) bb, _ := json.Marshal(ctnt) _, _ = rw.Write(bb) return } if req.URL.Path == "/resolution2.json" { b, _ := os.ReadFile(filepath.Join(specs, "resolution2.json")) var ctnt map[string]interface{} _ = json.Unmarshal(b, &ctnt) ctnt["id"] = servedAt rw.Header().Set("Content-Type", "application/json") bb, _ := json.Marshal(ctnt) _, _ = rw.Write(bb) return } if req.URL.Path == "/boolProp.json" { rw.Header().Set("Content-Type", "application/json") b, _ := json.Marshal(map[string]interface{}{ "type": "boolean", }) _, _ = rw.Write(b) return } if req.URL.Path == "/deeper/stringProp.json" { rw.Header().Set("Content-Type", "application/json") b, _ := json.Marshal(map[string]interface{}{ "type": "string", }) _, _ = rw.Write(b) return } if req.URL.Path == "/deeper/arrayProp.json" { rw.Header().Set("Content-Type", "application/json") b, _ := json.Marshal(map[string]interface{}{ "type": "array", "items": map[string]interface{}{ "type": "file", }, }) _, _ = rw.Write(b) return } rw.WriteHeader(http.StatusNotFound) })) servedAt = server.URL return server } func TestExpand_RemoteRefWithResolutionContext(t testing.T) { server := resolutionContextServer() defer server.Close() tgt := RefSchema(server.URL + "/resolution.json#/definitions/bool") require.NoError(t, ExpandSchema(tgt, nil, nil)) assert.Equal(t, StringOrArray([]string{"boolean"}), tgt.Type) assert.Empty(t, tgt.Ref) } func TestExpandRemoteRef_WithNestedResolutionContext(t testing.T) { server := resolutionContextServer() defer server.Close() tgt := RefSchema(server.URL + "/resolution.json#/items") require.NoError(t, ExpandSchema(tgt, nil, nil)) require.Empty(t, tgt.Ref) require.NotNil(t, tgt.Items) require.NotNil(t, tgt.Schema) assert.Equal(t, "deeper/", tgt.ID) // schema id is preserved assert.Equal(t, StringOrArray([]string{"string"}), tgt.Items.Schema.Type) assert.Empty(t, tgt.Items.Schema.Ref) } /* This next test will have to wait until we do full $ID analysis for every subschema on every file that is referenced // For now, TestExpandRemoteRef_WithNestedResolutionContext replaces this next test func TestExpandRemoteRef_WithNestedResolutionContext_WithParentID(t testing.T) { server := resolutionContextServer() defer server.Close() tgt := RefSchema(server.URL + "/resolution.json#/items/items") require.NoError(t, ExpandSchema(tgt, nil, nil)) t.Logf("%s", asJSON(t, tgt)) assert.Equal(t, StringOrArray([]string{"string"}), tgt.Type) } / func TestExpand_RemoteRefWithNestedResolutionContextWithFragment(t testing.T) { server := resolutionContextServer() defer server.Close() tgt := RefSchema(server.URL + "/resolution2.json#/items") require.NoError(t, ExpandSchema(tgt, nil, nil)) require.Empty(t, tgt.Ref) require.NotNil(t, tgt.Items) require.NotNil(t, tgt.Schema) assert.Equal(t, "deeper/", tgt.ID) // schema id is preserved assert.Equal(t, StringOrArray([]string{"file"}), tgt.Items.Schema.Type) assert.Empty(t, tgt.Items.Schema.Ref) } func TestExpand_TransitiveRefs(t testing.T) { basePath := filepath.Join(specs, "todos.json") rawSpec, err := os.ReadFile(basePath) require.NoError(t, err) var spec Swagger require.NoError(t, json.Unmarshal(rawSpec, &spec)) opts := &ExpandOptions{ RelativeBase: basePath, } require.NoError(t, ExpandSpec(spec, opts)) assert.Equal(t, "todos.stoplight.io", spec.Host) // i.e. not empty jazon := asJSON(t, spec) // verify that the spec has been fully expanded assertNoRef(t, jazon) } func TestExpand_SchemaWithRoot(t testing.T) { root := new(Swagger) require.NoError(t, json.Unmarshal(PetStoreJSONMessage, root)) // 1. remove ID from root definition origPet := root.Definitions["Pet"] newPet := origPet newPet.ID = "" root.Definitions["Pet"] = newPet expandRootWithID(t, root, withoutSchemaID) // 2. put back ID in Pet definition // nested $ref should fail root.Definitions["Pet"] = origPet expandRootWithID(t, root, withSchemaID) } func expandRootWithID(t testing.TB, root Swagger, testcase string) { t.Logf("case: expanding $ref to schema without ID, with nested $ref with %s ID", testcase) sch := RefSchema("#/definitions/newPet") err := ExpandSchema(sch, root, nil) if testcase == withSchemaID { require.Errorf(t, err, "expected %s NOT to expand properly because of the ID in the parent schema", sch.Ref.String()) } else { require.NoErrorf(t, err, "expected %s to expand properly", sch.Ref.String()) // verify that the spec has been fully expanded jazon := asJSON(t, sch) assertNoRef(t, jazon) } t.Log("case: expanding $ref to schema without nested $ref") sch = RefSchema("#/definitions/Category") require.NoErrorf(t, ExpandSchema(sch, root, nil), "expected %s to expand properly", sch.Ref.String()) t.Logf("case: expanding $ref to schema with %s ID and nested $ref", testcase) sch = RefSchema("#/definitions/Pet") err = ExpandSchema(sch, root, nil) if testcase == withSchemaID { require.Errorf(t, err, "expected %s NOT to expand properly because of the ID in the parent schema", sch.Ref.String()) } else { require.NoErrorf(t, err, "expected %s to expand properly", sch.Ref.String()) // verify that the spec has been fully expanded jazon := asJSON(t, sch) assertNoRef(t, jazon) } } func TestExpand_PathItem(t testing.T) { jazon, _ := expandThisOrDieTrying(t, pathItemsFixture) assert.JSONEq(t, `{ "swagger": "2.0", "info": { "title": "PathItems refs", "version": "1.0" }, "paths": { "/todos": { "get": { "responses": { "200": { "description": "List Todos", "schema": { "type": "array", "items": { "type": "string" } } }, "404": { "description": "error" } } } } } }`, jazon) } func TestExpand_ExtraItems(t testing.T) { jazon, _ := expandThisOrDieTrying(t, extraRefFixture) assert.JSONEq(t, `{ "schemes": [ "http" ], "swagger": "2.0", "info": { "title": "Supported, but non Swagger 20 compliant $ref constructs", "version": "2.1.0" }, "host": "item.com", "basePath": "/extraRefs", "paths": { "/employees": { "get": { "summary": "List Employee Types", "operationId": "LIST-Employees", "parameters": [ { "description": "unsupported $ref in simple param", "type": "array", "items": { "$ref": "#/definitions/arrayType" }, "name": "myQueryParam", "in": "query" } ], "responses": { "200": { "description": "unsupported $ref in header", "schema": { "type": "string" }, "headers": { "X-header": { "type": "array", "items": { "$ref": "#/definitions/headerType" } } } } } } } }, "definitions": { "arrayType": { "type": "integer", "format": "int32" }, "headerType": { "type": "string", "format": "uuid" } } }`, jazon) } func TestExpand_Issue145(t testing.T) { cwd, err := os.Getwd() require.NoError(t, err) pseudoRoot := normalizeBase(filepath.Join(cwd, rootBase)) // assert the internal behavior of baseForRoot() t.Run("with nil root, empty cache", func(t testing.T) { cache := defaultResolutionCache() require.Equal(t, pseudoRoot, baseForRoot(nil, cache)) t.Run("empty root is cached", func(t testing.T) { value, ok := cache.Get(pseudoRoot) require.True(t, ok) // found in cache asMap, ok := value.(map[string]interface{}) require.True(t, ok) require.Empty(t, asMap) }) }) t.Run("with non-nil root, empty cache", func(t testing.T) { cache := defaultResolutionCache() require.Equal(t, pseudoRoot, baseForRoot(map[string]interface{}{"key": "arbitrary"}, cache)) t.Run("non-empty root is cached", func(t testing.T) { value, ok := cache.Get(pseudoRoot) require.True(t, ok) // found in cache asMap, ok := value.(map[string]interface{}) require.True(t, ok) require.Contains(t, asMap, "key") require.Equal(t, "arbitrary", asMap["key"]) }) t.Run("with nil root, non-empty cache", func(t testing.T) { require.Equal(t, pseudoRoot, baseForRoot(nil, cache)) t.Run("non-empty root is kept", func(t testing.T) { value, ok := cache.Get(pseudoRoot) require.True(t, ok) // found in cache asMap, ok := value.(map[string]interface{}) require.True(t, ok) require.Contains(t, asMap, "key") require.Equal(t, "arbitrary", asMap["key"]) }) }) }) } // PetStore20 json doc for swagger 2.0 pet store const PetStore20 = `{ "swagger": "2.0", "info": { "version": "1.0.0", "title": "Swagger Petstore", "contact": { "name": "Wordnik API Team", "url": "http://developer.wordnik.com" }, "license": { "name": "Creative Commons 4.0 International", "url": "http://creativecommons.org/licenses/by/4.0/" } }, "host": "petstore.swagger.wordnik.com", "basePath": "/api", "schemes": [ "http" ], "paths": { "/pets": { "get": { "security": [ { "basic": [] } ], "tags": [ "Pet Operations" ], "operationId": "getAllPets", "parameters": [ { "name": "status", "in": "query", "description": "The status to filter by", "type": "string" }, { "name": "limit", "in": "query", "description": "The maximum number of results to return", "type": "integer", "format": "int64" } ], "summary": "Finds all pets in the system", "responses": { "200": { "description": "Pet response", "schema": { "type": "array", "items": { "$ref": "#/definitions/Pet" } } }, "default": { "description": "Unexpected error", "schema": { "$ref": "#/definitions/Error" } } } }, "post": { "security": [ { "basic": [] } ], "tags": [ "Pet Operations" ], "operationId": "createPet", "summary": "Creates a new pet", "consumes": ["application/x-yaml"], "produces": ["application/x-yaml"], "parameters": [ { "name": "pet", "in": "body", "description": "The Pet to create", "required": true, "schema": { "$ref": "#/definitions/newPet" } } ], "responses": { "200": { "description": "Created Pet response", "schema": { "$ref": "#/definitions/Pet" } }, "default": { "description": "Unexpected error", "schema": { "$ref": "#/definitions/Error" } } } } }, "/pets/{id}": { "delete": { "security": [ { "apiKey": [] } ], "description": "Deletes the Pet by id", "operationId": "deletePet", "parameters": [ { "name": "id", "in": "path", "description": "ID of pet to delete", "required": true, "type": "integer", "format": "int64" } ], "responses": { "204": { "description": "pet deleted" }, "default": { "description": "unexpected error", "schema": { "$ref": "#/definitions/Error" } } } }, "get": { "tags": [ "Pet Operations" ], "operationId": "getPetById", "summary": "Finds the pet by id", "responses": { "200": { "description": "Pet response", "schema": { "$ref": "#/definitions/Pet" } }, "default": { "description": "Unexpected error", "schema": { "$ref": "#/definitions/Error" } } } }, "parameters": [ { "name": "id", "in": "path", "description": "ID of pet", "required": true, "type": "integer", "format": "int64" } ] } }, "definitions": { "Category": { "id": "Category", "properties": { "id": { "format": "int64", "type": "integer" }, "name": { "type": "string" } } }, "Pet": { "id": "Pet", "properties": { "category": { "$ref": "#/definitions/Category" }, "id": { "description": "unique identifier for the pet", "format": "int64", "maximum": 100.0, "minimum": 0.0, "type": "integer" }, "name": { "type": "string" }, "photoUrls": { "items": { "type": "string" }, "type": "array" }, "status": { "description": "pet status in the store", "enum": [ "available", "pending", "sold" ], "type": "string" }, "tags": { "items": { "$ref": "#/definitions/Tag" }, "type": "array" } }, "required": [ "id", "name" ] }, "newPet": { "anyOf": [ { "$ref": "#/definitions/Pet" }, { "required": [ "name" ] } ] }, "Tag": { "id": "Tag", "properties": { "id": { "format": "int64", "type": "integer" }, "name": { "type": "string" } } }, "Error": { "required": [ "code", "message" ], "properties": { "code": { "type": "integer", "format": "int32" }, "message": { "type": "string" } } } }, "consumes": [ "application/json", "application/xml" ], "produces": [ "application/json", "application/xml", "text/plain", "text/html" ], "securityDefinitions": { "basic": { "type": "basic" }, "apiKey": { "type": "apiKey", "in": "header", "name": "X-API-KEY" } } } `	42.55 KB	2025-05-25 12:27
📄 external_docs.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 spec // ExternalDocumentation allows referencing an external resource for // extended documentation. // // For more information: http://goo.gl/8us55a#externalDocumentationObject type ExternalDocumentation struct { Description string `json:"description,omitempty"` URL string `json:"url,omitempty"` }	918 B	2025-05-25 12:27
📄 external_docs_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 spec import ( "testing" ) func TestIntegrationExternalDocs(t *testing.T) { var extDocs = ExternalDocumentation{Description: "the name", URL: "the url"} const extDocsYAML = "description: the name\nurl: the url\n" const extDocsJSON = `{"description":"the name","url":"the url"}` assertSerializeJSON(t, extDocs, extDocsJSON) assertSerializeYAML(t, extDocs, extDocsYAML) assertParsesJSON(t, extDocsJSON, extDocs) assertParsesYAML(t, extDocsYAML, extDocs) }	1.04 KB	2025-05-25 12:27
📁 fixtures	-	2025-05-25 12:27
📄 go.mod module github.com/go-openapi/spec require ( github.com/go-openapi/jsonpointer v0.21.0 github.com/go-openapi/jsonreference v0.21.0 github.com/go-openapi/swag v0.23.0 github.com/stretchr/testify v1.9.0 gopkg.in/yaml.v3 v3.0.1 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/josharian/intern v1.0.0 // indirect github.com/mailru/easyjson v0.7.7 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect ) go 1.20	446 B	2025-05-25 12:27
📄 go.sum 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/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/swag v0.23.0 h1:vsEVJDUo2hPJ2tu0/Xc+4noaxyEffXNIs3cOULZ+GrE= github.com/go-openapi/swag v0.23.0/go.mod h1:esZ8ITTYEsH1V2trKHjAN8Ai7xHb8RV+YSZ577vPjgQ= 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/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= 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=	1.97 KB	2025-05-25 12:27
📄 header.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 spec import ( "encoding/json" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) const ( jsonArray = "array" ) // HeaderProps describes a response header type HeaderProps struct { Description string `json:"description,omitempty"` } // Header describes a header for a response of the API // // For more information: http://goo.gl/8us55a#headerObject type Header struct { CommonValidations SimpleSchema VendorExtensible HeaderProps } // ResponseHeader creates a new header instance for use in a response func ResponseHeader() Header { return new(Header) } // WithDescription sets the description on this response, allows for chaining func (h Header) WithDescription(description string) Header { h.Description = description return h } // Typed a fluent builder method for the type of parameter func (h Header) Typed(tpe, format string) Header { h.Type = tpe h.Format = format return h } // CollectionOf a fluent builder method for an array item func (h Header) CollectionOf(items Items, format string) Header { h.Type = jsonArray h.Items = items h.CollectionFormat = format return h } // WithDefault sets the default value on this item func (h Header) WithDefault(defaultValue interface{}) Header { h.Default = defaultValue return h } // WithMaxLength sets a max length value func (h Header) WithMaxLength(max int64) Header { h.MaxLength = &max return h } // WithMinLength sets a min length value func (h Header) WithMinLength(min int64) Header { h.MinLength = &min return h } // WithPattern sets a pattern value func (h Header) WithPattern(pattern string) Header { h.Pattern = pattern return h } // WithMultipleOf sets a multiple of value func (h Header) WithMultipleOf(number float64) Header { h.MultipleOf = &number return h } // WithMaximum sets a maximum number value func (h Header) WithMaximum(max float64, exclusive bool) Header { h.Maximum = &max h.ExclusiveMaximum = exclusive return h } // WithMinimum sets a minimum number value func (h Header) WithMinimum(min float64, exclusive bool) Header { h.Minimum = &min h.ExclusiveMinimum = exclusive return h } // WithEnum sets a the enum values (replace) func (h Header) WithEnum(values ...interface{}) Header { h.Enum = append([]interface{}{}, values...) return h } // WithMaxItems sets the max items func (h Header) WithMaxItems(size int64) Header { h.MaxItems = &size return h } // WithMinItems sets the min items func (h Header) WithMinItems(size int64) Header { h.MinItems = &size return h } // UniqueValues dictates that this array can only have unique items func (h Header) UniqueValues() Header { h.UniqueItems = true return h } // AllowDuplicates this array can have duplicates func (h Header) AllowDuplicates() Header { h.UniqueItems = false return h } // WithValidations is a fluent method to set header validations func (h Header) WithValidations(val CommonValidations) Header { h.SetValidations(SchemaValidations{CommonValidations: val}) return h } // MarshalJSON marshal this to JSON func (h Header) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(h.CommonValidations) if err != nil { return nil, err } b2, err := json.Marshal(h.SimpleSchema) if err != nil { return nil, err } b3, err := json.Marshal(h.HeaderProps) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2, b3), nil } // UnmarshalJSON unmarshals this header from JSON func (h *Header) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &h.CommonValidations); err != nil { return err } if err := json.Unmarshal(data, &h.SimpleSchema); err != nil { return err } if err := json.Unmarshal(data, &h.VendorExtensible); err != nil { return err } return json.Unmarshal(data, &h.HeaderProps) } // JSONLookup look up a value by the json property name func (h Header) JSONLookup(token string) (interface{}, error) { if ex, ok := h.Extensions[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(h.CommonValidations, token) if err != nil && !strings.HasPrefix(err.Error(), "object has no field") { return nil, err } if r != nil { return r, nil } r, _, err = jsonpointer.GetForToken(h.SimpleSchema, token) if err != nil && !strings.HasPrefix(err.Error(), "object has no field") { return nil, err } if r != nil { return r, nil } r, _, err = jsonpointer.GetForToken(h.HeaderProps, token) return r, err }	4.94 KB	2025-05-25 12:27
📄 header_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 spec import ( "encoding/json" "testing" "github.com/go-openapi/swag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const epsilon = 1e-9 func float64Ptr(f float64) float64 { return &f } func int64Ptr(f int64) int64 { return &f } var header = Header{ VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{ "x-framework": "swagger-go", }}, HeaderProps: HeaderProps{Description: "the description of this header"}, SimpleSchema: SimpleSchema{ Items: &Items{ Refable: Refable{Ref: MustCreateRef("Cat")}, }, Type: "string", Format: "date", Default: "8", }, CommonValidations: CommonValidations{ Maximum: float64Ptr(100), ExclusiveMaximum: true, ExclusiveMinimum: true, Minimum: float64Ptr(5), MaxLength: int64Ptr(100), MinLength: int64Ptr(5), Pattern: "\\w{1,5}\\w+", MaxItems: int64Ptr(100), MinItems: int64Ptr(5), UniqueItems: true, MultipleOf: float64Ptr(5), Enum: []interface{}{"hello", "world"}, }, } const headerJSON = `{ "items": { "$ref": "Cat" }, "x-framework": "swagger-go", "description": "the description of this header", "maximum": 100, "minimum": 5, "exclusiveMaximum": true, "exclusiveMinimum": true, "maxLength": 100, "minLength": 5, "pattern": "\\w{1,5}\\w+", "maxItems": 100, "minItems": 5, "uniqueItems": true, "multipleOf": 5, "enum": ["hello", "world"], "type": "string", "format": "date", "default": "8" }` func TestIntegrationHeader(t testing.T) { var actual Header require.NoError(t, json.Unmarshal([]byte(headerJSON), &actual)) assert.EqualValues(t, actual, header) assertParsesJSON(t, headerJSON, header) } func TestJSONLookupHeader(t testing.T) { var def string res, err := header.JSONLookup("default") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, def, res) var ok bool def, ok = res.(string) require.True(t, ok) assert.Equal(t, "8", def) var x interface{} res, err = header.JSONLookup("x-framework") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, x, res) x, ok = res.(interface{}) require.True(t, ok) assert.EqualValues(t, "swagger-go", x) res, err = header.JSONLookup("unknown") require.Error(t, err) require.Nil(t, res) var max float64 res, err = header.JSONLookup("maximum") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, max, res) max, ok = res.(float64) require.True(t, ok) assert.InDelta(t, float64(100), max, epsilon) } func TestResponseHeaueder(t testing.T) { var expectedHeader Header h := ResponseHeader() assert.IsType(t, expectedHeader, h) } func TestWithHeader(t testing.T) { h := new(Header).WithDescription("header description").Typed("integer", "int32") assert.Equal(t, "header description", h.Description) assert.Equal(t, "integer", h.Type) assert.Equal(t, "int32", h.Format) i := new(Items).Typed("string", "date") h = new(Header).CollectionOf(i, "pipe") assert.EqualValues(t, i, h.Items) assert.Equal(t, "pipe", h.CollectionFormat) h = new(Header).WithDefault([]string{"a", "b", "c"}).WithMaxLength(10).WithMinLength(3) assert.Equal(t, int64(10), h.MaxLength) assert.Equal(t, int64(3), h.MinLength) assert.EqualValues(t, []string{"a", "b", "c"}, h.Default) h = new(Header).WithPattern("^abc$") assert.Equal(t, Header{ CommonValidations: CommonValidations{ Pattern: "^abc$", }, }, h) h = new(Header).WithEnum("a", "b", "c") assert.Equal(t, Header{ CommonValidations: CommonValidations{ Enum: []interface{}{ "a", "b", "c", }, }, }, h) } func TestHeaderWithValidation(t testing.T) { h := new(Header).WithValidations(CommonValidations{MaxLength: swag.Int64(15)}) assert.EqualValues(t, swag.Int64(15), h.MaxLength) }	4.36 KB	2025-05-25 12:27
📄 helpers_spec_test.go package spec_test import ( "encoding/json" "fmt" "regexp" "strings" "testing" "github.com/go-openapi/spec" "github.com/go-openapi/swag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var ( rex = regexp.MustCompile(`"\$ref":\s"(.?)"`) testLoader func(string) (json.RawMessage, error) ) func init() { // mimics what the go-openapi/load does testLoader = func(path string) (json.RawMessage, error) { if swag.YAMLMatcher(path) { return swag.YAMLDoc(path) } data, err := swag.LoadFromFileOrHTTP(path) if err != nil { return nil, err } return json.RawMessage(data), nil } } func loadOrFail(t testing.T, path string) spec.Swagger { raw, err := testLoader(path) require.NoErrorf(t, err, "can't load fixture %s: %v", path, err) swspec := new(spec.Swagger) err = json.Unmarshal(raw, swspec) require.NoError(t, err) return swspec } func assertRefInJSON(t testing.TB, jazon, prefix string) { // assert a match in a references m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) for _, matched := range m { subMatch := matched[1] assert.True(t, strings.HasPrefix(subMatch, prefix), "expected $ref to match %q, got: %s", prefix, matched[0]) } } func assertRefInJSONRegexp(t testing.TB, jazon, match string) { // assert a match in a references m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) refMatch, err := regexp.Compile(match) require.NoError(t, err) for _, matched := range m { subMatch := matched[1] assert.True(t, refMatch.MatchString(subMatch), "expected $ref to match %q, got: %s", match, matched[0]) } } // assertRefExpand ensures that all $ref in some json doc expand properly against a root document. // // "exclude" is a regexp pattern to ignore certain $ref (e.g. some specs may embed $ref that are not processed, such as extensions). func assertRefExpand(t testing.T, jazon, _ string, root interface{}, opts ...spec.ExpandOptions) { if len(opts) > 0 { assertRefWithFunc(t, "expand-with-base", jazon, "", func(t testing.T, match string) { ref := spec.RefSchema(match) options := opts[0] require.NoError(t, spec.ExpandSchemaWithBasePath(ref, nil, &options)) }) return } assertRefWithFunc(t, "expand", jazon, "", func(t testing.T, match string) { ref := spec.RefSchema(match) require.NoError(t, spec.ExpandSchema(ref, root, nil)) }) } func assertRefResolve(t testing.T, jazon, exclude string, root interface{}, opts ...spec.ExpandOptions) { assertRefWithFunc(t, "resolve", jazon, exclude, func(t testing.T, match string) { ref := spec.MustCreateRef(match) var ( sch spec.Schema err error ) if len(opts) > 0 { options := opts[0] sch, err = spec.ResolveRefWithBase(root, &ref, &options) } else { sch, err = spec.ResolveRef(root, &ref) } require.NoErrorf(t, err, `%v: for "$ref": %q`, err, match) require.NotNil(t, sch) }) } // assertRefWithFunc ensures that all $ref in a j // // "exclude" is a regexp pattern to ignore certain $ref (e.g. some specs may embed $ref that are not processed, such as extensions). func assertRefWithFunc(t testing.T, name, jazon, exclude string, asserter func(testing.T, string)) { filterRex := regexp.MustCompile(exclude) m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) allRefs := make(map[string]struct{}, len(m)) for _, toPin := range m { matched := toPin subMatch := matched[1] if exclude != "" && filterRex.MatchString(subMatch) { continue } _, ok := allRefs[subMatch] if ok { continue } allRefs[subMatch] = struct{}{} t.Run(fmt.Sprintf("%s-%s-%s", t.Name(), name, subMatch), func(t *testing.T) { // t.Parallel() asserter(t, subMatch) }) } } func asJSON(t testing.TB, sp interface{}) string { bbb, err := json.MarshalIndent(sp, "", " ") require.NoError(t, err) return string(bbb) } // assertNoRef ensures that no $ref is remaining in json doc func assertNoRef(t testing.TB, jazon string) { m := rex.FindAllStringSubmatch(jazon, -1) require.Nil(t, m) }	3.96 KB	2025-05-25 12:27
📄 helpers_test.go package spec import ( "encoding/json" "fmt" "regexp" "strings" "testing" "github.com/go-openapi/swag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var rex = regexp.MustCompile(`"\$ref":\s"(.?)"`) func jsonDoc(path string) (json.RawMessage, error) { data, err := swag.LoadFromFileOrHTTP(path) if err != nil { return nil, err } return json.RawMessage(data), nil } func docAndOpts(t testing.TB, fixturePath string) ([]byte, ExpandOptions) { doc, err := jsonDoc(fixturePath) require.NoError(t, err) return doc, &ExpandOptions{ RelativeBase: fixturePath, } } func expandThisSchemaOrDieTrying(t testing.TB, fixturePath string) (string, Schema) { doc, opts := docAndOpts(t, fixturePath) sch := new(Schema) require.NoError(t, json.Unmarshal(doc, sch)) require.NotPanics(t, func() { require.NoError(t, ExpandSchemaWithBasePath(sch, nil, opts)) }, "calling expand schema circular refs, should not panic!") bbb, err := json.MarshalIndent(sch, "", " ") require.NoError(t, err) return string(bbb), sch } func expandThisOrDieTrying(t testing.TB, fixturePath string) (string, Swagger) { doc, opts := docAndOpts(t, fixturePath) spec := new(Swagger) require.NoError(t, json.Unmarshal(doc, spec)) require.NotPanics(t, func() { require.NoError(t, ExpandSpec(spec, opts)) }, "calling expand spec with circular refs, should not panic!") bbb, err := json.MarshalIndent(spec, "", " ") require.NoError(t, err) return string(bbb), spec } // assertRefInJSONRegexp ensures all $ref in a jazon document have a given prefix. // // NOTE: matched $ref might be empty. func assertRefInJSON(t testing.TB, jazon, prefix string) { // assert a match in a references m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) for _, matched := range m { subMatch := matched[1] assert.True(t, strings.HasPrefix(subMatch, prefix), "expected $ref to match %q, got: %s", prefix, matched[0]) } } // assertRefInJSONRegexp ensures all $ref in a jazon document match a given regexp // // NOTE: matched $ref might be empty. func assertRefInJSONRegexp(t testing.TB, jazon, match string) { // assert a match in a references m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) refMatch, err := regexp.Compile(match) require.NoError(t, err) for _, matched := range m { subMatch := matched[1] assert.True(t, refMatch.MatchString(subMatch), "expected $ref to match %q, got: %s", match, matched[0]) } } // assertNoRef ensures that no $ref is remaining in json doc func assertNoRef(t testing.TB, jazon string) { m := rex.FindAllStringSubmatch(jazon, -1) require.Nil(t, m) } // assertRefExpand ensures that all $ref in some json doc expand properly against a root document. // // "exclude" is a regexp pattern to ignore certain $ref (e.g. some specs may embed $ref that are not processed, such as extensions). func assertRefExpand(t testing.T, jazon, _ string, root interface{}, opts ...ExpandOptions) { assertRefWithFunc(t, jazon, "", func(t testing.T, match string) { ref := RefSchema(match) if len(opts) > 0 { options := opts[0] require.NoError(t, ExpandSchemaWithBasePath(ref, nil, &options)) } else { require.NoError(t, ExpandSchema(ref, root, nil)) } }) } // assertRefResolve ensures that all $ref in some json doc resolve properly against a root document. // // "exclude" is a regexp pattern to ignore certain $ref (e.g. some specs may embed $ref that are not processed, such as extensions). func assertRefResolve(t testing.T, jazon, exclude string, root interface{}, opts ...ExpandOptions) { assertRefWithFunc(t, jazon, exclude, func(t testing.T, match string) { ref := MustCreateRef(match) var ( sch Schema err error ) if len(opts) > 0 { options := opts[0] sch, err = ResolveRefWithBase(root, &ref, &options) } else { sch, err = ResolveRef(root, &ref) } require.NoErrorf(t, err, `%v: for "$ref": %q`, err, match) require.NotNil(t, sch) }) } // assertRefResolve ensures that all $ref in some json doc verify some asserting func. // // "exclude" is a regexp pattern to ignore certain $ref (e.g. some specs may embed $ref that are not processed, such as extensions). func assertRefWithFunc(t testing.T, jazon, exclude string, asserter func(t testing.T, match string)) { filterRex := regexp.MustCompile(exclude) m := rex.FindAllStringSubmatch(jazon, -1) require.NotNil(t, m) allRefs := make(map[string]struct{}, len(m)) for _, matched := range m { subMatch := matched[1] if exclude != "" && filterRex.MatchString(subMatch) { continue } _, ok := allRefs[subMatch] if ok { continue } allRefs[subMatch] = struct{}{} t.Run(fmt.Sprintf("%s-%s", t.Name(), subMatch), func(t *testing.T) { t.Parallel() asserter(t, subMatch) }) } } func asJSON(t testing.TB, sp interface{}) string { bbb, err := json.MarshalIndent(sp, "", " ") require.NoError(t, err) return string(bbb) }	4.85 KB	2025-05-25 12:27
📄 info.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 spec import ( "encoding/json" "strconv" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // Extensions vendor specific extensions type Extensions map[string]interface{} // Add adds a value to these extensions func (e Extensions) Add(key string, value interface{}) { realKey := strings.ToLower(key) e[realKey] = value } // GetString gets a string value from the extensions func (e Extensions) GetString(key string) (string, bool) { if v, ok := e[strings.ToLower(key)]; ok { str, ok := v.(string) return str, ok } return "", false } // GetInt gets a int value from the extensions func (e Extensions) GetInt(key string) (int, bool) { realKey := strings.ToLower(key) if v, ok := e.GetString(realKey); ok { if r, err := strconv.Atoi(v); err == nil { return r, true } } if v, ok := e[realKey]; ok { if r, rOk := v.(float64); rOk { return int(r), true } } return -1, false } // GetBool gets a string value from the extensions func (e Extensions) GetBool(key string) (bool, bool) { if v, ok := e[strings.ToLower(key)]; ok { str, ok := v.(bool) return str, ok } return false, false } // GetStringSlice gets a string value from the extensions func (e Extensions) GetStringSlice(key string) ([]string, bool) { if v, ok := e[strings.ToLower(key)]; ok { arr, isSlice := v.([]interface{}) if !isSlice { return nil, false } var strs []string for _, iface := range arr { str, isString := iface.(string) if !isString { return nil, false } strs = append(strs, str) } return strs, ok } return nil, false } // VendorExtensible composition block. type VendorExtensible struct { Extensions Extensions } // AddExtension adds an extension to this extensible object func (v VendorExtensible) AddExtension(key string, value interface{}) { if value == nil { return } if v.Extensions == nil { v.Extensions = make(map[string]interface{}) } v.Extensions.Add(key, value) } // MarshalJSON marshals the extensions to json func (v VendorExtensible) MarshalJSON() ([]byte, error) { toser := make(map[string]interface{}) for k, v := range v.Extensions { lk := strings.ToLower(k) if strings.HasPrefix(lk, "x-") { toser[k] = v } } return json.Marshal(toser) } // UnmarshalJSON for this extensible object func (v VendorExtensible) UnmarshalJSON(data []byte) error { var d map[string]interface{} if err := json.Unmarshal(data, &d); err != nil { return err } for k, vv := range d { lk := strings.ToLower(k) if strings.HasPrefix(lk, "x-") { if v.Extensions == nil { v.Extensions = map[string]interface{}{} } v.Extensions[k] = vv } } return nil } // InfoProps the properties for an info definition type InfoProps struct { Description string `json:"description,omitempty"` Title string `json:"title,omitempty"` TermsOfService string `json:"termsOfService,omitempty"` Contact ContactInfo `json:"contact,omitempty"` License License `json:"license,omitempty"` Version string `json:"version,omitempty"` } // Info object provides metadata about the API. // The metadata can be used by the clients if needed, and can be presented in the Swagger-UI for convenience. // // For more information: http://goo.gl/8us55a#infoObject type Info struct { VendorExtensible InfoProps } // JSONLookup look up a value by the json property name func (i Info) JSONLookup(token string) (interface{}, error) { if ex, ok := i.Extensions[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(i.InfoProps, token) return r, err } // MarshalJSON marshal this to JSON func (i Info) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(i.InfoProps) if err != nil { return nil, err } b2, err := json.Marshal(i.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2), nil } // UnmarshalJSON marshal this from JSON func (i *Info) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &i.InfoProps); err != nil { return err } return json.Unmarshal(data, &i.VendorExtensible) }	4.62 KB	2025-05-25 12:27
📄 info_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const infoJSON = `{ "description": "A sample API that uses a petstore as an example to demonstrate features in ` + `the swagger-2.0 specification", "title": "Swagger Sample API", "termsOfService": "http://helloreverb.com/terms/", "contact": { "name": "wordnik api team", "url": "http://developer.wordnik.com" }, "license": { "name": "Creative Commons 4.0 International", "url": "http://creativecommons.org/licenses/by/4.0/" }, "version": "1.0.9-abcd", "x-framework": "go-swagger" }` var info = Info{ InfoProps: InfoProps{ Version: "1.0.9-abcd", Title: "Swagger Sample API", Description: "A sample API that uses a petstore as an example to demonstrate features in " + "the swagger-2.0 specification", TermsOfService: "http://helloreverb.com/terms/", Contact: &ContactInfo{ContactInfoProps: ContactInfoProps{Name: "wordnik api team", URL: "http://developer.wordnik.com"}}, License: &License{LicenseProps: LicenseProps{ Name: "Creative Commons 4.0 International", URL: "http://creativecommons.org/licenses/by/4.0/", }, }, }, VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-framework": "go-swagger"}}, } func TestIntegrationInfo_Serialize(t testing.T) { b, err := json.MarshalIndent(info, "", "\t") require.NoError(t, err) assert.Equal(t, infoJSON, string(b)) } func TestIntegrationInfo_Deserialize(t testing.T) { actual := Info{} require.NoError(t, json.Unmarshal([]byte(infoJSON), &actual)) assert.EqualValues(t, info, actual) } func TestInfoGobEncoding(t *testing.T) { var src, dst Info require.NoError(t, json.Unmarshal([]byte(infoJSON), &src)) assert.EqualValues(t, src, info) doTestAnyGobEncoding(t, &src, &dst) }	2.39 KB	2025-05-25 12:27
📄 items.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 spec import ( "encoding/json" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) const ( jsonRef = "$ref" ) // SimpleSchema describe swagger simple schemas for parameters and headers type SimpleSchema struct { Type string `json:"type,omitempty"` Nullable bool `json:"nullable,omitempty"` Format string `json:"format,omitempty"` Items Items `json:"items,omitempty"` CollectionFormat string `json:"collectionFormat,omitempty"` Default interface{} `json:"default,omitempty"` Example interface{} `json:"example,omitempty"` } // TypeName return the type (or format) of a simple schema func (s SimpleSchema) TypeName() string { if s.Format != "" { return s.Format } return s.Type } // ItemsTypeName yields the type of items in a simple schema array func (s SimpleSchema) ItemsTypeName() string { if s.Items == nil { return "" } return s.Items.TypeName() } // Items a limited subset of JSON-Schema's items object. // It is used by parameter definitions that are not located in "body". // // For more information: http://goo.gl/8us55a#items-object type Items struct { Refable CommonValidations SimpleSchema VendorExtensible } // NewItems creates a new instance of items func NewItems() Items { return &Items{} } // Typed a fluent builder method for the type of item func (i Items) Typed(tpe, format string) Items { i.Type = tpe i.Format = format return i } // AsNullable flags this schema as nullable. func (i Items) AsNullable() Items { i.Nullable = true return i } // CollectionOf a fluent builder method for an array item func (i Items) CollectionOf(items Items, format string) Items { i.Type = jsonArray i.Items = items i.CollectionFormat = format return i } // WithDefault sets the default value on this item func (i Items) WithDefault(defaultValue interface{}) Items { i.Default = defaultValue return i } // WithMaxLength sets a max length value func (i Items) WithMaxLength(max int64) Items { i.MaxLength = &max return i } // WithMinLength sets a min length value func (i Items) WithMinLength(min int64) Items { i.MinLength = &min return i } // WithPattern sets a pattern value func (i Items) WithPattern(pattern string) Items { i.Pattern = pattern return i } // WithMultipleOf sets a multiple of value func (i Items) WithMultipleOf(number float64) Items { i.MultipleOf = &number return i } // WithMaximum sets a maximum number value func (i Items) WithMaximum(max float64, exclusive bool) Items { i.Maximum = &max i.ExclusiveMaximum = exclusive return i } // WithMinimum sets a minimum number value func (i Items) WithMinimum(min float64, exclusive bool) Items { i.Minimum = &min i.ExclusiveMinimum = exclusive return i } // WithEnum sets a the enum values (replace) func (i Items) WithEnum(values ...interface{}) Items { i.Enum = append([]interface{}{}, values...) return i } // WithMaxItems sets the max items func (i Items) WithMaxItems(size int64) Items { i.MaxItems = &size return i } // WithMinItems sets the min items func (i Items) WithMinItems(size int64) Items { i.MinItems = &size return i } // UniqueValues dictates that this array can only have unique items func (i Items) UniqueValues() Items { i.UniqueItems = true return i } // AllowDuplicates this array can have duplicates func (i Items) AllowDuplicates() Items { i.UniqueItems = false return i } // WithValidations is a fluent method to set Items validations func (i Items) WithValidations(val CommonValidations) Items { i.SetValidations(SchemaValidations{CommonValidations: val}) return i } // UnmarshalJSON hydrates this items instance with the data from JSON func (i Items) UnmarshalJSON(data []byte) error { var validations CommonValidations if err := json.Unmarshal(data, &validations); err != nil { return err } var ref Refable if err := json.Unmarshal(data, &ref); err != nil { return err } var simpleSchema SimpleSchema if err := json.Unmarshal(data, &simpleSchema); err != nil { return err } var vendorExtensible VendorExtensible if err := json.Unmarshal(data, &vendorExtensible); err != nil { return err } i.Refable = ref i.CommonValidations = validations i.SimpleSchema = simpleSchema i.VendorExtensible = vendorExtensible return nil } // MarshalJSON converts this items object to JSON func (i Items) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(i.CommonValidations) if err != nil { return nil, err } b2, err := json.Marshal(i.SimpleSchema) if err != nil { return nil, err } b3, err := json.Marshal(i.Refable) if err != nil { return nil, err } b4, err := json.Marshal(i.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b4, b3, b1, b2), nil } // JSONLookup look up a value by the json property name func (i Items) JSONLookup(token string) (interface{}, error) { if token == jsonRef { return &i.Ref, nil } r, _, err := jsonpointer.GetForToken(i.CommonValidations, token) if err != nil && !strings.HasPrefix(err.Error(), "object has no field") { return nil, err } if r != nil { return r, nil } r, _, err = jsonpointer.GetForToken(i.SimpleSchema, token) return r, err }	5.75 KB	2025-05-25 12:27
📄 items_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 spec import ( "encoding/json" "testing" "github.com/go-openapi/swag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var items = Items{ Refable: Refable{Ref: MustCreateRef("Dog")}, CommonValidations: CommonValidations{ Maximum: float64Ptr(100), ExclusiveMaximum: true, ExclusiveMinimum: true, Minimum: float64Ptr(5), MaxLength: int64Ptr(100), MinLength: int64Ptr(5), Pattern: "\\w{1,5}\\w+", MaxItems: int64Ptr(100), MinItems: int64Ptr(5), UniqueItems: true, MultipleOf: float64Ptr(5), Enum: []interface{}{"hello", "world"}, }, SimpleSchema: SimpleSchema{ Type: "string", Format: "date", Items: &Items{ Refable: Refable{Ref: MustCreateRef("Cat")}, }, CollectionFormat: "csv", Default: "8", }, } const itemsJSON = `{ "items": { "$ref": "Cat" }, "$ref": "Dog", "maximum": 100, "minimum": 5, "exclusiveMaximum": true, "exclusiveMinimum": true, "maxLength": 100, "minLength": 5, "pattern": "\\w{1,5}\\w+", "maxItems": 100, "minItems": 5, "uniqueItems": true, "multipleOf": 5, "enum": ["hello", "world"], "type": "string", "format": "date", "collectionFormat": "csv", "default": "8" }` func TestIntegrationItems(t testing.T) { var actual Items require.NoError(t, json.Unmarshal([]byte(itemsJSON), &actual)) assert.EqualValues(t, actual, items) assertParsesJSON(t, itemsJSON, items) } func TestTypeNameItems(t testing.T) { var nilItems Items assert.Equal(t, "", nilItems.TypeName()) assert.Equal(t, "date", items.TypeName()) assert.Equal(t, "", items.ItemsTypeName()) nested := Items{ SimpleSchema: SimpleSchema{ Type: "array", Items: &Items{ SimpleSchema: SimpleSchema{ Type: "integer", Format: "int32", }, }, CollectionFormat: "csv", }, } assert.Equal(t, "array", nested.TypeName()) assert.Equal(t, "int32", nested.ItemsTypeName()) simple := SimpleSchema{ Type: "string", Items: nil, } assert.Equal(t, "string", simple.TypeName()) assert.Equal(t, "", simple.ItemsTypeName()) simple.Items = NewItems() simple.Type = "array" simple.Items.Type = "string" assert.Equal(t, "array", simple.TypeName()) assert.Equal(t, "string", simple.ItemsTypeName()) } func TestItemsBuilder(t testing.T) { simple := SimpleSchema{ Type: "array", Items: NewItems(). Typed("string", "uuid"). WithDefault([]string{"default-value"}). WithEnum([]string{"abc", "efg"}, []string{"hij"}). WithMaxItems(4). WithMinItems(1). UniqueValues(), } assert.Equal(t, SimpleSchema{ Type: "array", Items: &Items{ SimpleSchema: SimpleSchema{ Type: "string", Format: "uuid", Default: []string{"default-value"}, }, CommonValidations: CommonValidations{ Enum: []interface{}{[]string{"abc", "efg"}, []string{"hij"}}, MinItems: swag.Int64(1), MaxItems: swag.Int64(4), UniqueItems: true, }, }, }, simple) } func TestJSONLookupItems(t testing.T) { res, err := items.JSONLookup("$ref") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, &Ref{}, res) var ok bool ref, ok := res.(Ref) require.True(t, ok) assert.EqualValues(t, MustCreateRef("Dog"), ref) var max float64 res, err = items.JSONLookup("maximum") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, max, res) max, ok = res.(float64) require.True(t, ok) assert.InDelta(t, float64(100), max, epsilon) var f string res, err = items.JSONLookup("collectionFormat") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, f, res) f, ok = res.(string) require.True(t, ok) assert.Equal(t, "csv", f) res, err = items.JSONLookup("unknown") require.Error(t, err) require.Nil(t, res) } func TestItemsWithValidation(t testing.T) { i := new(Items).WithValidations(CommonValidations{MaxLength: swag.Int64(15)}) assert.EqualValues(t, swag.Int64(15), i.MaxLength) }	4.51 KB	2025-05-25 12:27
📄 license.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 spec import ( "encoding/json" "github.com/go-openapi/swag" ) // License information for the exposed API. // // For more information: http://goo.gl/8us55a#licenseObject type License struct { LicenseProps VendorExtensible } // LicenseProps holds the properties of a License object type LicenseProps struct { Name string `json:"name,omitempty"` URL string `json:"url,omitempty"` } // UnmarshalJSON hydrates License from json func (l *License) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &l.LicenseProps); err != nil { return err } return json.Unmarshal(data, &l.VendorExtensible) } // MarshalJSON produces License as json func (l License) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(l.LicenseProps) if err != nil { return nil, err } b2, err := json.Marshal(l.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2), nil }	1.48 KB	2025-05-25 12:27
📄 license_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var license = License{ LicenseProps: LicenseProps{Name: "the name", URL: "the url"}, VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-license": "custom term"}}} const licenseJSON = `{ "name": "the name", "url": "the url", "x-license": "custom term" }` func TestIntegrationLicense(t *testing.T) { // const licenseYAML = "name: the name\nurl: the url\n" b, err := json.MarshalIndent(license, "", "\t") require.NoError(t, err) assert.Equal(t, licenseJSON, string(b)) actual := License{} err = json.Unmarshal([]byte(licenseJSON), &actual) require.NoError(t, err) assert.EqualValues(t, license, actual) }	1.34 KB	2025-05-25 12:27
📄 normalizer.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 spec import ( "net/url" "path" "strings" ) const fileScheme = "file" // normalizeURI ensures that all $ref paths used internally by the expander are canonicalized. // // NOTE(windows): there is a tolerance over the strict URI format on windows. // // The normalizer accepts relative file URLs like 'Path\File.JSON' as well as absolute file URLs like // 'C:\Path\file.Yaml'. // // Both are canonicalized with a "file://" scheme, slashes and a lower-cased path: // 'file:///c:/path/file.yaml' // // URLs can be specified with a file scheme, like in 'file:///folder/file.json' or // 'file:///c:\folder\File.json'. // // URLs like file://C:\folder are considered invalid (i.e. there is no host 'c:\folder') and a "repair" // is attempted. // // The base path argument is assumed to be canonicalized (e.g. using normalizeBase()). func normalizeURI(refPath, base string) string { refURL, err := parseURL(refPath) if err != nil { specLogger.Printf("warning: invalid URI in $ref %q: %v", refPath, err) refURL, refPath = repairURI(refPath) } fixWindowsURI(refURL, refPath) // noop on non-windows OS refURL.Path = path.Clean(refURL.Path) if refURL.Path == "." { refURL.Path = "" } r := MustCreateRef(refURL.String()) if r.IsCanonical() { return refURL.String() } baseURL, _ := parseURL(base) if path.IsAbs(refURL.Path) { baseURL.Path = refURL.Path } else if refURL.Path != "" { baseURL.Path = path.Join(path.Dir(baseURL.Path), refURL.Path) } // copying fragment from ref to base baseURL.Fragment = refURL.Fragment return baseURL.String() } // denormalizeRef returns the simplest notation for a normalized $ref, given the path of the original root document. // // When calling this, we assume that: // * $ref is a canonical URI // * originalRelativeBase is a canonical URI // // denormalizeRef is currently used when we rewrite a $ref after a circular $ref has been detected. // In this case, expansion stops and normally renders the internal canonical $ref. // // This internal $ref is eventually rebased to the original RelativeBase used for the expansion. // // There is a special case for schemas that are anchored with an "id": // in that case, the rebasing is performed // against the id only if this is an anchor for the initial root document. // All other intermediate "id"'s found along the way are ignored for the purpose of rebasing. func denormalizeRef(ref Ref, originalRelativeBase, id string) Ref { debugLog("denormalizeRef called:\n$ref: %q\noriginal: %s\nroot ID:%s", ref.String(), originalRelativeBase, id) if ref.String() == "" \|\| ref.IsRoot() \|\| ref.HasFragmentOnly { // short circuit: $ref to current doc return ref } if id != "" { idBaseURL, err := parseURL(id) if err == nil { // if the schema id is not usable as a URI, ignore it if ref, ok := rebase(ref, idBaseURL, true); ok { // rebase, but keep references to root unchaged (do not want $ref: "") // $ref relative to the ID of the schema in the root document return ref } } } originalRelativeBaseURL, _ := parseURL(originalRelativeBase) r, _ := rebase(ref, originalRelativeBaseURL, false) return r } func rebase(ref Ref, v url.URL, notEqual bool) (Ref, bool) { var newBase url.URL u := ref.GetURL() if u.Scheme != v.Scheme \|\| u.Host != v.Host { return ref, false } docPath := v.Path v.Path = path.Dir(v.Path) if v.Path == "." { v.Path = "" } else if !strings.HasSuffix(v.Path, "/") { v.Path += "/" } newBase.Fragment = u.Fragment if strings.HasPrefix(u.Path, docPath) { newBase.Path = strings.TrimPrefix(u.Path, docPath) } else { newBase.Path = strings.TrimPrefix(u.Path, v.Path) } if notEqual && newBase.Path == "" && newBase.Fragment == "" { // do not want rebasing to end up in an empty $ref return ref, false } if path.IsAbs(newBase.Path) { // whenever we end up with an absolute path, specify the scheme and host newBase.Scheme = v.Scheme newBase.Host = v.Host } return MustCreateRef(newBase.String()), true } // normalizeRef canonicalize a Ref, using a canonical relativeBase as its absolute anchor func normalizeRef(ref Ref, relativeBase string) Ref { r := MustCreateRef(normalizeURI(ref.String(), relativeBase)) return &r } // normalizeBase performs a normalization of the input base path. // // This always yields a canonical URI (absolute), usable for the document cache. // // It ensures that all further internal work on basePath may safely assume // a non-empty, cross-platform, canonical URI (i.e. absolute). // // This normalization tolerates windows paths (e.g. C:\x\y\File.dat) and transform this // in a file:// URL with lower cased drive letter and path. // // See also: https://en.wikipedia.org/wiki/File_URI_scheme func normalizeBase(in string) string { u, err := parseURL(in) if err != nil { specLogger.Printf("warning: invalid URI in RelativeBase %q: %v", in, err) u, in = repairURI(in) } u.Fragment = "" // any fragment in the base is irrelevant fixWindowsURI(u, in) // noop on non-windows OS u.Path = path.Clean(u.Path) if u.Path == "." { // empty after Clean() u.Path = "" } if u.Scheme != "" { if path.IsAbs(u.Path) \|\| u.Scheme != fileScheme { // this is absolute or explicitly not a local file: we're good return u.String() } } // no scheme or file scheme with relative path: assume file and make it absolute // enforce scheme file://... with absolute path. // // If the input path is relative, we anchor the path to the current working directory. // NOTE: we may end up with a host component. Leave it unchanged: e.g. file://host/folder/file.json u.Scheme = fileScheme u.Path = absPath(u.Path) // platform-dependent u.RawQuery = "" // any query component is irrelevant for a base return u.String() }	6.24 KB	2025-05-25 12:27
📄 normalizer_nonwindows.go //go:build !windows // +build !windows // 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 spec import ( "net/url" "path/filepath" ) // absPath makes a file path absolute and compatible with a URI path component. // // The parameter must be a path, not an URI. func absPath(in string) string { anchored, err := filepath.Abs(in) if err != nil { specLogger.Printf("warning: could not resolve current working directory: %v", err) return in } return anchored } func repairURI(in string) (url.URL, string) { u, _ := parseURL("") debugLog("repaired URI: original: %q, repaired: %q", in, "") return u, "" } func fixWindowsURI(_ url.URL, _ string) { }	1.19 KB	2025-05-25 12:27
📄 normalizer_test.go package spec import ( "os" "path" "path/filepath" "runtime" "strings" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const windowsOS = "windows" // only used for windows var currentDriveLetter = getCurrentDrive() // get the current drive letter in lowercase on windows that the test is running func getCurrentDrive() string { if runtime.GOOS != windowsOS { return "" } p, err := filepath.Abs("/") if err != nil { panic(err) } if len(p) == 0 { panic("current windows drive letter is empty") } return strings.ToLower(string(p[0])) } func TestNormalizer_NormalizeURI(t testing.T) { type testNormalizePathsTestCases []struct { refPath string base string expOutput string windows bool nonWindows bool } testCases := func() testNormalizePathsTestCases { return testNormalizePathsTestCases{ { // http basePath, absolute refPath refPath: "", base: "http://www.example.com/base/path/swagger.json", expOutput: "http://www.example.com/base/path/swagger.json", }, { // http basePath, absolute refPath refPath: "#", base: "http://www.example.com/base/path/swagger.json", expOutput: "http://www.example.com/base/path/swagger.json", }, { // http basePath, absolute refPath refPath: "#/definitions/Pet", base: "http://www.example.com/base/path/swagger.json", expOutput: "http://www.example.com/base/path/swagger.json#/definitions/Pet", }, { // http basePath, absolute refPath refPath: "http://www.anotherexample.com/another/base/path/swagger.json#/definitions/Pet", base: "http://www.example.com/base/path/swagger.json", expOutput: "http://www.anotherexample.com/another/base/path/swagger.json#/definitions/Pet", }, { // http basePath, relative refPath refPath: "another/base/path/swagger.json#/definitions/Pet", base: "http://www.example.com/base/path/swagger.json", expOutput: "http://www.example.com/base/path/another/base/path/swagger.json#/definitions/Pet", }, { // file basePath, absolute refPath, no fragment refPath: "/another/base/path.json", base: "/base/path.json", expOutput: "/another/base/path.json", }, { // path clean refPath: "/another///base//path.json/", base: "/base/path.json", expOutput: "/another/base/path.json", }, { // path clean edge case refPath: "", base: "/base/path.json", expOutput: "/base/path.json", }, { // file basePath, absolute refPath refPath: "/another/base/path.json#/definitions/Pet", base: "/base/path.json", expOutput: "/another/base/path.json#/definitions/Pet", }, { // file basePath, relative refPath refPath: "another/base/path.json#/definitions/Pet", base: "/base/path.json", expOutput: "/base/another/base/path.json#/definitions/Pet", }, { // file basePath, relative refPath refPath: "./another/base/path.json#/definitions/Pet", base: "/base/path.json", expOutput: "/base/another/base/path.json#/definitions/Pet", }, { refPath: "another/base/path.json#/definitions/Pet", base: "file:///base/path.json", expOutput: "file:///base/another/base/path.json#/definitions/Pet", }, { refPath: "/another/base/path.json#/definitions/Pet", base: "https://www.example.com:8443//base/path.json", expOutput: "https://www.example.com:8443/another/base/path.json#/definitions/Pet", }, { // params in base refPath: "/another/base/path.json#/definitions/Pet", base: "https://www.example.com:8443//base/path.json?raw=true", expOutput: "https://www.example.com:8443/another/base/path.json?raw=true#/definitions/Pet", }, { // params in ref refPath: "https://origin.com/another/file.json?raw=true", base: "https://www.example.com:8443//base/path.json?raw=true", expOutput: "https://origin.com/another/file.json?raw=true", }, { refPath: "another/base/def.yaml#/definitions/Pet", base: "file:///base/path.json", expOutput: "file:///base/another/base/def.yaml#/definitions/Pet", }, { refPath: "", base: "file:///base/path.json", expOutput: "file:///base/path.json", }, { refPath: "#", base: "file:///base/path.json", expOutput: "file:///base/path.json", }, { refPath: "../other/another.json#/definitions/X", base: "file:///base/path.json", expOutput: "file:///other/another.json#/definitions/X", }, { // invalid URI refPath: "\x7f\x9a", base: "file:///base/path.json", expOutput: "file:///base/path.json", }, { // file basePath, absolute refPath, no fragment refPath: `C:\another\base\path.json`, base: `file:///c:/base/path.json`, expOutput: `file:///c:/another/base/path.json`, windows: true, }, { // file basePath, absolute refPath refPath: `C:\another\Base\path.json#/definitions/Pet`, base: `file:///c:/base/path.json`, expOutput: `file:///c:/another/base/path.json#/definitions/Pet`, windows: true, }, { // file basePath, relative refPath refPath: `another\base\path.json#/definitions/Pet`, base: `file:///c:/base/path.json`, expOutput: `file:///c:/base/another/base/path.json#/definitions/Pet`, windows: true, }, { // file basePath, relative refPath refPath: `.\another\base\path.json#/definitions/Pet`, base: `file:///c:/base/path.json`, expOutput: `file:///c:/base/another/base/path.json#/definitions/Pet`, windows: true, }, { refPath: `\\host\share\another\base\path.json#/definitions/Pet`, base: `file:///c:/base/path.json`, expOutput: `file://host/share/another/base/path.json#/definitions/Pet`, windows: true, }, { // repair URI refPath: `file://E:\Base\sub\File.json`, base: `file:///c:/base/path.json`, expOutput: `file:///e:/base/sub/file.json`, windows: true, }, { // case sensitivity on local paths only (1/4) // see note: refPath: `Resources.yaml#/definitions/Pets`, base: `file:///c:/base/Spec.json`, expOutput: `file:///c:/base/Resources.yaml#/definitions/Pets`, windows: true, }, { // case sensitivity on local paths only (2/4) refPath: `Resources.yaml#/definitions/Pets`, base: `file:///c:/base/Spec.json`, expOutput: `file:///c:/base/Resources.yaml#/definitions/Pets`, nonWindows: true, }, { // case sensitivity on local paths only (3/4) refPath: `Resources.yaml#/definitions/Pets`, base: `https://example.com//base/Spec.json`, expOutput: `https://example.com/base/Resources.yaml#/definitions/Pets`, }, { // escaped characters in base (1) refPath: `Resources.yaml#/definitions/Pets`, base: `https://example.com/base (x86)/Spec.json`, expOutput: `https://example.com/base%20%28x86%29/Resources.yaml#/definitions/Pets`, }, { // escaped characters in base (2) refPath: `Resources.yaml#/definitions/Pets`, base: `https://example.com/base [x86]/Spec.json`, expOutput: `https://example.com/base%20%5Bx86%5D/Resources.yaml#/definitions/Pets`, }, { // escaped characters in joined fragment refPath: `Resources.yaml#/definitions (x86)/Pets`, base: `https://example.com/base/Spec.json`, expOutput: `https://example.com/base/Resources.yaml#/definitions%20(x86)/Pets`, }, { // escaped characters in joined path refPath: `Resources [x86].yaml#/definitions/Pets`, base: `https://example.com/base/Spec.json`, expOutput: `https://example.com/base/Resources%20%5Bx86%5D.yaml#/definitions/Pets`, }, } }() for _, toPin := range testCases { testCase := toPin if testCase.windows && runtime.GOOS != windowsOS { continue } if testCase.nonWindows && runtime.GOOS == windowsOS { continue } t.Run(testCase.refPath, func(t testing.T) { t.Parallel() out := normalizeURI(testCase.refPath, testCase.base) assert.Equalf(t, testCase.expOutput, out, "unexpected normalized URL with $ref %q and base %q", testCase.refPath, testCase.base) }) } } func TestNormalizer_NormalizeBase(t testing.T) { cwd, err := os.Getwd() require.NoError(t, err) if runtime.GOOS == windowsOS { cwd = "/" + strings.ToLower(filepath.ToSlash(cwd)) } const fileScheme = "file:///" for _, toPin := range []struct { Base, Expected string Windows bool NonWindows bool }{ { Base: "", Expected: "file://$cwd", // edge case: this won't work because a document is a file }, { Base: "#", Expected: "file://$cwd", // edge case: this won't work because a document is a file }, { Base: "\x7f\x9a", Expected: "file://$cwd", // edge case: invalid URI }, { Base: ".", Expected: "file://$cwd", // edge case: this won't work because a document is a file }, { Base: "https://user:password@www.example.com:123/base/sub/file.json", Expected: "https://user:password@www.example.com:123/base/sub/file.json", }, { // irrelevant fragment: cleaned Base: "http://www.anotherexample.com/another/base/path/swagger.json#/definitions/Pet", Expected: "http://www.anotherexample.com/another/base/path/swagger.json", }, { Base: "base/sub/file.json", Expected: "file://$cwd/base/sub/file.json", }, { Base: "./base/sub/file.json", Expected: "file://$cwd/base/sub/file.json", }, { Base: "file:/base/sub/file.json", Expected: "file:///base/sub/file.json", }, { // funny scheme, no path Base: "smb://host", Expected: "smb://host", }, { // explicit scheme, with host and path Base: "gs://bucket/folder/file.json", Expected: "gs://bucket/folder/file.json", }, { // explicit file scheme, with host and path Base: "file://folder/file.json", Expected: "file://folder/file.json", }, { // path clean Base: "file:///folder//subfolder///file.json/", Expected: "file:///folder/subfolder/file.json", }, { // path clean Base: "///folder//subfolder///file.json/", Expected: "file:///folder/subfolder/file.json", NonWindows: true, }, { // path clean Base: "///folder//subfolder///file.json/", Expected: fileScheme + currentDriveLetter + ":/folder/subfolder/file.json", Windows: true, }, { // relevant query param: kept Base: "https:///host/base/sub/file.json?query=param", Expected: "https:///host/base/sub/file.json?query=param", }, { // no host component, absolute path Base: `file:/base/sub/file.json`, Expected: "file:///base/sub/file.json", }, { // handling dots (1/6): dodgy specification - resolved to / Base: `file:///.`, Expected: "file:///", }, { // handling dots (2/6): valid, cleaned to / Base: "/..", Expected: "file:///", NonWindows: true, }, { // handling dots (3/6): valid, cleaned to /c:/ on windows Base: "/..", Expected: fileScheme + currentDriveLetter + ":", Windows: true, }, { // handling dots (4/6): dodgy specification - resolved to / Base: `file:/.`, Expected: fileScheme, }, { // handling dots (5/6): dodgy specification - resolved to / Base: `file:/..`, Expected: fileScheme, }, { // handling dots (6/6) Base: `..`, Expected: "file://$dir", }, // non-windows case { Base: "/base/sub/file.json", Expected: "file:///base/sub/file.json", NonWindows: true, }, { // irrelevant query param (local file resolver): cleaned Base: "/base/sub/file.json?query=param", Expected: "file:///base/sub/file.json", NonWindows: true, }, // windows-only cases { Base: "/base/sub/file.json", Expected: fileScheme + currentDriveLetter + ":/base/sub/file.json", // on windows, filepath.Abs("/a/b") prepends the "c:" drive Windows: true, }, { // case sensitivity Base: `C:\Base\sub\File.json`, Expected: "file:///c:/base/sub/file.json", Windows: true, }, { // This one is parsed correctly: notice the third slash Base: `file:///\Base\sub\File.json`, Expected: "file:///base/sub/file.json", Windows: true, }, { // absolute path Base: `file:/\Base\sub\File.json`, Expected: "file:///base/sub/file.json", Windows: true, }, { // windows UNC path, no drive Base: `\\host\share@1234\Folder\File.json`, Expected: "file://host/share@1234/folder/file.json", Windows: true, }, { // repair invalid use of leading "." on windows Base: `file:///.\Base\sub\File.json`, Expected: "file://$cwd/base/sub/file.json", Windows: true, }, { Base: `file:/E:\Base\sub\File.json`, Expected: "file:///e:/base/sub/file.json", Windows: true, }, { // repair URI (windows) // This one exhibits an example of invalid URI (missing a 3rd "/") Base: `file://E:\Base\sub\File.json`, Expected: "file:///e:/base/sub/file.json", Windows: true, }, { // escaped characters in base (1) Base: `file:///c:/base (x86)/spec.json`, Expected: `file:///c:/base%20%28x86%29/spec.json`, }, } { testCase := toPin if testCase.Windows && runtime.GOOS != windowsOS { continue } if testCase.NonWindows && runtime.GOOS == windowsOS { continue } t.Run(testCase.Base, func(t testing.T) { t.Parallel() expected := strings.ReplaceAll(strings.ReplaceAll(testCase.Expected, "$cwd", cwd), "$dir", path.Dir(cwd)) require.Equalf(t, expected, normalizeBase(testCase.Base), "for base %q", testCase.Base) // check for idempotence require.Equalf(t, expected, normalizeBase(normalizeBase(testCase.Base)), "expected idempotent behavior on base %q", testCase.Base) }) } } func TestNormalizer_Denormalize(t testing.T) { cwd, err := os.Getwd() require.NoError(t, err) for _, toPin := range []struct { OriginalBase, Ref, Expected, ID string Windows bool NonWindows bool }{ { OriginalBase: "file:///a/b/c/file.json", Ref: "#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json#ignoredFragment", Ref: "#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "https://user:password@example.com/a/b/c/file.json", Ref: "https://user:password@example.com/a/b/c/other.json#/definitions/X", Expected: "other.json#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/items.json#/definitions/X", Expected: "items.json#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "https:///x/y/z/items.json#/definitions/X", Expected: "https:///x/y/z/items.json#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/file.json#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/d/other.json#/definitions/X", Expected: "d/other.json#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/file.json#", Expected: "", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/d/file.json", Expected: "d/file.json", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/file.json", Expected: "", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/../other.json#/definitions/X", Expected: "../other.json#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", Ref: "file:///a/b/c/../../other.json#/definitions/X", Expected: "../../other.json#/definitions/X", }, { // we may end up in this situation following ../.. in paths OriginalBase: "file:///a1/b/c/file.json", Ref: "file:///a2/b/c/file.json#/definitions/X", Expected: "file:///a2/b/c/file.json#/definitions/X", }, { OriginalBase: "file:///file.json", Ref: "file:///file.json#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file://host/file.json", Ref: "file://host/file.json#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file://host1/file.json", Ref: "file://host2/file.json#/definitions/X", Expected: "file://host2/file.json#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", ID: "https://myschema/", Ref: "file:///a/b/c/file.json#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", ID: "https://myschema/", Ref: "https://myschema#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file:///a/b/c/file.json", ID: "https://myschema/", Ref: "https://myschema#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file:///folder/file.json", ID: "https://example.com/schema", Ref: "https://example.com/schema#/definitions/X", Expected: "#/definitions/X", }, { OriginalBase: "file:///folder/file.json", ID: "https://example.com/schema", Ref: "https://example.com/schema/other-file.json#/definitions/X", Expected: "https://example.com/other-file.json#/definitions/X", }, } { testCase := toPin if testCase.Windows && runtime.GOOS != windowsOS { // windows only continue } if testCase.NonWindows && runtime.GOOS == windowsOS { // non-windows only continue } t.Run(testCase.Ref, func(t testing.T) { t.Parallel() expected := strings.ReplaceAll(testCase.Expected, "$cwd", cwd) ref := MustCreateRef(testCase.Ref) newRef := denormalizeRef(&ref, testCase.OriginalBase, testCase.ID) require.NotNil(t, newRef) require.Equalf(t, expected, newRef.String(), "expected %s, but got %s", testCase.Expected, newRef.String()) }) } }	17.95 KB	2025-05-25 12:27
📄 normalizer_windows.go // -build windows // 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 spec import ( "net/url" "os" "path" "path/filepath" "strings" ) // absPath makes a file path absolute and compatible with a URI path component // // The parameter must be a path, not an URI. func absPath(in string) string { // NOTE(windows): filepath.Abs exhibits a special behavior on windows for empty paths. // See https://github.com/golang/go/issues/24441 if in == "" { in = "." } anchored, err := filepath.Abs(in) if err != nil { specLogger.Printf("warning: could not resolve current working directory: %v", err) return in } pth := strings.ReplaceAll(strings.ToLower(anchored), `\`, `/`) if !strings.HasPrefix(pth, "/") { pth = "/" + pth } return path.Clean(pth) } // repairURI tolerates invalid file URIs with common typos // such as 'file://E:\folder\file', that break the regular URL parser. // // Adopting the same defaults as for unixes (e.g. return an empty path) would // result into a counter-intuitive result for that case (e.g. E:\folder\file is // eventually resolved as the current directory). The repair will detect the missing "/". // // Note that this only works for the file scheme. func repairURI(in string) (url.URL, string) { const prefix = fileScheme + "://" if !strings.HasPrefix(in, prefix) { // giving up: resolve to empty path u, _ := parseURL("") return u, "" } // attempt the repair, stripping the scheme should be sufficient u, _ := parseURL(strings.TrimPrefix(in, prefix)) debugLog("repaired URI: original: %q, repaired: %q", in, u.String()) return u, u.String() } // fixWindowsURI tolerates an absolute file path on windows such as C:\Base\File.yaml or \\host\share\Base\File.yaml // and makes it a canonical URI: file:///c:/base/file.yaml // // Catch 22 notes for Windows: // // There may be a drive letter on windows (it is lower-cased) // * There may be a share UNC, e.g. \\server\folder\data.xml // * Paths are case insensitive // * Paths may already contain slashes // * Paths must be slashed // // NOTE: there is no escaping. "/" may be valid separators just like "\". // We don't use ToSlash() (which escapes everything) because windows now also // tolerates the use of "/". Hence, both C:\File.yaml and C:/File.yaml will work. func fixWindowsURI(u url.URL, in string) { drive := filepath.VolumeName(in) if len(drive) > 0 { if len(u.Scheme) == 1 && strings.EqualFold(u.Scheme, drive[:1]) { // a path with a drive letter u.Scheme = fileScheme u.Host = "" u.Path = strings.Join([]string{drive, u.Opaque, u.Path}, `/`) // reconstruct the full path component (no fragment, no query) } else if u.Host == "" && strings.HasPrefix(u.Path, drive) { // a path with a \\host volume // NOTE: the special host@port syntax for UNC is not supported (yet) u.Scheme = fileScheme // this is a modified version of filepath.Dir() to apply on the VolumeName itself i := len(drive) - 1 for i >= 0 && !os.IsPathSeparator(drive[i]) { i-- } host := drive[:i] // \\host\share => host u.Path = strings.TrimPrefix(u.Path, host) u.Host = strings.TrimPrefix(host, `\\`) } u.Opaque = "" u.Path = strings.ReplaceAll(strings.ToLower(u.Path), `\`, `/`) // ensure we form an absolute path if !strings.HasPrefix(u.Path, "/") { u.Path = "/" + u.Path } u.Path = path.Clean(u.Path) return } if u.Scheme == fileScheme { // Handle dodgy cases for file://{...} URIs on windows. // A canonical URI should always be followed by an absolute path. // // Examples: // file:///folder/file => valid, unchanged // * file:///c:\folder\file => slashed // * file:///./folder/file => valid, cleaned to remove the dot // * file:///.\folder\file => remapped to cwd // * file:///. => dodgy, remapped to / (consistent with the behavior on unix) // * file:///.. => dodgy, remapped to / (consistent with the behavior on unix) if (!path.IsAbs(u.Path) && !filepath.IsAbs(u.Path)) \|\| (strings.HasPrefix(u.Path, `/.`) && strings.Contains(u.Path, `\`)) { // ensure we form an absolute path u.Path, _ = filepath.Abs(strings.TrimLeft(u.Path, `/`)) if !strings.HasPrefix(u.Path, "/") { u.Path = "/" + u.Path } } u.Path = strings.ToLower(u.Path) } // NOTE: lower case normalization does not propagate to inner resources, // generated when rebasing: when joining a relative URI with a file to an absolute base, // only the base is currently lower-cased. // // For now, we assume this is good enough for most use cases // and try not to generate too many differences // between the output produced on different platforms. u.Path = path.Clean(strings.ReplaceAll(u.Path, `\`, `/`)) }	5.15 KB	2025-05-25 12:27
📄 operation.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 spec import ( "bytes" "encoding/gob" "encoding/json" "sort" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) func init() { gob.Register(map[string]interface{}{}) gob.Register([]interface{}{}) } // OperationProps describes an operation // // NOTES: // - schemes, when present must be from [http, https, ws, wss]: see validate // - Security is handled as a special case: see MarshalJSON function type OperationProps struct { Description string `json:"description,omitempty"` Consumes []string `json:"consumes,omitempty"` Produces []string `json:"produces,omitempty"` Schemes []string `json:"schemes,omitempty"` Tags []string `json:"tags,omitempty"` Summary string `json:"summary,omitempty"` ExternalDocs ExternalDocumentation `json:"externalDocs,omitempty"` ID string `json:"operationId,omitempty"` Deprecated bool `json:"deprecated,omitempty"` Security []map[string][]string `json:"security,omitempty"` Parameters []Parameter `json:"parameters,omitempty"` Responses Responses `json:"responses,omitempty"` } // MarshalJSON takes care of serializing operation properties to JSON // // We use a custom marhaller here to handle a special cases related to // the Security field. We need to preserve zero length slice // while omitting the field when the value is nil/unset. func (op OperationProps) MarshalJSON() ([]byte, error) { type Alias OperationProps if op.Security == nil { return json.Marshal(&struct { Security []map[string][]string `json:"security,omitempty"` Alias }{ Security: op.Security, Alias: (Alias)(&op), }) } return json.Marshal(&struct { Security []map[string][]string `json:"security"` Alias }{ Security: op.Security, Alias: (Alias)(&op), }) } // Operation describes a single API operation on a path. // // For more information: http://goo.gl/8us55a#operationObject type Operation struct { VendorExtensible OperationProps } // SuccessResponse gets a success response model func (o Operation) SuccessResponse() (Response, int, bool) { if o.Responses == nil { return nil, 0, false } responseCodes := make([]int, 0, len(o.Responses.StatusCodeResponses)) for k := range o.Responses.StatusCodeResponses { if k >= 200 && k < 300 { responseCodes = append(responseCodes, k) } } if len(responseCodes) > 0 { sort.Ints(responseCodes) v := o.Responses.StatusCodeResponses[responseCodes[0]] return &v, responseCodes[0], true } return o.Responses.Default, 0, false } // JSONLookup look up a value by the json property name func (o Operation) JSONLookup(token string) (interface{}, error) { if ex, ok := o.Extensions[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(o.OperationProps, token) return r, err } // UnmarshalJSON hydrates this items instance with the data from JSON func (o Operation) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &o.OperationProps); err != nil { return err } return json.Unmarshal(data, &o.VendorExtensible) } // MarshalJSON converts this items object to JSON func (o Operation) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(o.OperationProps) if err != nil { return nil, err } b2, err := json.Marshal(o.VendorExtensible) if err != nil { return nil, err } concated := swag.ConcatJSON(b1, b2) return concated, nil } // NewOperation creates a new operation instance. // It expects an ID as parameter but not passing an ID is also valid. func NewOperation(id string) Operation { op := new(Operation) op.ID = id return op } // WithID sets the ID property on this operation, allows for chaining. func (o Operation) WithID(id string) Operation { o.ID = id return o } // WithDescription sets the description on this operation, allows for chaining func (o Operation) WithDescription(description string) Operation { o.Description = description return o } // WithSummary sets the summary on this operation, allows for chaining func (o Operation) WithSummary(summary string) Operation { o.Summary = summary return o } // WithExternalDocs sets/removes the external docs for/from this operation. // When you pass empty strings as params the external documents will be removed. // When you pass non-empty string as one value then those values will be used on the external docs object. // So when you pass a non-empty description, you should also pass the url and vice versa. func (o Operation) WithExternalDocs(description, url string) Operation { if description == "" && url == "" { o.ExternalDocs = nil return o } if o.ExternalDocs == nil { o.ExternalDocs = &ExternalDocumentation{} } o.ExternalDocs.Description = description o.ExternalDocs.URL = url return o } // Deprecate marks the operation as deprecated func (o Operation) Deprecate() Operation { o.Deprecated = true return o } // Undeprecate marks the operation as not deprected func (o Operation) Undeprecate() Operation { o.Deprecated = false return o } // WithConsumes adds media types for incoming body values func (o Operation) WithConsumes(mediaTypes ...string) Operation { o.Consumes = append(o.Consumes, mediaTypes...) return o } // WithProduces adds media types for outgoing body values func (o Operation) WithProduces(mediaTypes ...string) Operation { o.Produces = append(o.Produces, mediaTypes...) return o } // WithTags adds tags for this operation func (o Operation) WithTags(tags ...string) Operation { o.Tags = append(o.Tags, tags...) return o } // AddParam adds a parameter to this operation, when a parameter for that location // and with that name already exists it will be replaced func (o Operation) AddParam(param Parameter) Operation { if param == nil { return o } for i, p := range o.Parameters { if p.Name == param.Name && p.In == param.In { params := make([]Parameter, 0, len(o.Parameters)+1) params = append(params, o.Parameters[:i]...) params = append(params, param) params = append(params, o.Parameters[i+1:]...) o.Parameters = params return o } } o.Parameters = append(o.Parameters, param) return o } // RemoveParam removes a parameter from the operation func (o Operation) RemoveParam(name, in string) Operation { for i, p := range o.Parameters { if p.Name == name && p.In == in { o.Parameters = append(o.Parameters[:i], o.Parameters[i+1:]...) return o } } return o } // SecuredWith adds a security scope to this operation. func (o Operation) SecuredWith(name string, scopes ...string) Operation { o.Security = append(o.Security, map[string][]string{name: scopes}) return o } // WithDefaultResponse adds a default response to the operation. // Passing a nil value will remove the response func (o Operation) WithDefaultResponse(response Response) Operation { return o.RespondsWith(0, response) } // RespondsWith adds a status code response to the operation. // When the code is 0 the value of the response will be used as default response value. // When the value of the response is nil it will be removed from the operation func (o Operation) RespondsWith(code int, response Response) Operation { if o.Responses == nil { o.Responses = new(Responses) } if code == 0 { o.Responses.Default = response return o } if response == nil { delete(o.Responses.StatusCodeResponses, code) return o } if o.Responses.StatusCodeResponses == nil { o.Responses.StatusCodeResponses = make(map[int]Response) } o.Responses.StatusCodeResponses[code] = response return o } type opsAlias OperationProps type gobAlias struct { Security []map[string]struct { List []string Pad bool } Alias opsAlias SecurityIsEmpty bool } // GobEncode provides a safe gob encoder for Operation, including empty security requirements func (o Operation) GobEncode() ([]byte, error) { raw := struct { Ext VendorExtensible Props OperationProps }{ Ext: o.VendorExtensible, Props: o.OperationProps, } var b bytes.Buffer err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } // GobDecode provides a safe gob decoder for Operation, including empty security requirements func (o Operation) GobDecode(b []byte) error { var raw struct { Ext VendorExtensible Props OperationProps } buf := bytes.NewBuffer(b) err := gob.NewDecoder(buf).Decode(&raw) if err != nil { return err } o.VendorExtensible = raw.Ext o.OperationProps = raw.Props return nil } // GobEncode provides a safe gob encoder for Operation, including empty security requirements func (op OperationProps) GobEncode() ([]byte, error) { raw := gobAlias{ Alias: (opsAlias)(&op), } var b bytes.Buffer if op.Security == nil { // nil security requirement err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } if len(op.Security) == 0 { // empty, but non-nil security requirement raw.SecurityIsEmpty = true raw.Alias.Security = nil err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } raw.Security = make([]map[string]struct { List []string Pad bool }, 0, len(op.Security)) for _, req := range op.Security { v := make(map[string]struct { List []string Pad bool }, len(req)) for k, val := range req { v[k] = struct { List []string Pad bool }{ List: val, } } raw.Security = append(raw.Security, v) } err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } // GobDecode provides a safe gob decoder for Operation, including empty security requirements func (op OperationProps) GobDecode(b []byte) error { var raw gobAlias buf := bytes.NewBuffer(b) err := gob.NewDecoder(buf).Decode(&raw) if err != nil { return err } if raw.Alias == nil { return nil } switch { case raw.SecurityIsEmpty: // empty, but non-nil security requirement raw.Alias.Security = []map[string][]string{} case len(raw.Alias.Security) == 0: // nil security requirement raw.Alias.Security = nil default: raw.Alias.Security = make([]map[string][]string, 0, len(raw.Security)) for _, req := range raw.Security { v := make(map[string][]string, len(req)) for k, val := range req { v[k] = make([]string, 0, len(val.List)) v[k] = append(v[k], val.List...) } raw.Alias.Security = append(raw.Alias.Security, v) } } op = (*OperationProps)(raw.Alias) return nil }	10.84 KB	2025-05-25 12:27
📄 operation_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 spec import ( "bytes" "encoding/gob" "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var operation = Operation{ VendorExtensible: VendorExtensible{ Extensions: map[string]interface{}{ "x-framework": "go-swagger", }, }, OperationProps: OperationProps{ Description: "operation description", Consumes: []string{"application/json", "application/x-yaml"}, Produces: []string{"application/json", "application/x-yaml"}, Schemes: []string{"http", "https"}, Tags: []string{"dogs"}, Summary: "the summary of the operation", ID: "sendCat", Deprecated: true, Security: []map[string][]string{ { "apiKey": {}, }, }, Parameters: []Parameter{ {Refable: Refable{Ref: MustCreateRef("Cat")}}, }, Responses: &Responses{ ResponsesProps: ResponsesProps{ Default: &Response{ ResponseProps: ResponseProps{ Description: "void response", }, }, }, }, }, } const operationJSON = `{ "description": "operation description", "x-framework": "go-swagger", "consumes": [ "application/json", "application/x-yaml" ], "produces": [ "application/json", "application/x-yaml" ], "schemes": ["http", "https"], "tags": ["dogs"], "summary": "the summary of the operation", "operationId": "sendCat", "deprecated": true, "security": [ { "apiKey": [] } ], "parameters": [{"$ref":"Cat"}], "responses": { "default": { "description": "void response" } } }` func TestSuccessResponse(t testing.T) { ope := &Operation{} resp, n, f := ope.SuccessResponse() assert.Nil(t, resp) assert.Equal(t, 0, n) assert.False(t, f) resp, n, f = operation.SuccessResponse() require.NotNil(t, resp) assert.Equal(t, "void response", resp.Description) assert.Equal(t, 0, n) assert.False(t, f) require.NoError(t, json.Unmarshal([]byte(operationJSON), ope)) ope = ope.RespondsWith(301, &Response{ ResponseProps: ResponseProps{ Description: "failure", }, }) resp, n, f = ope.SuccessResponse() require.NotNil(t, resp) assert.Equal(t, "void response", resp.Description) assert.Equal(t, 0, n) assert.False(t, f) ope = ope.RespondsWith(200, &Response{ ResponseProps: ResponseProps{ Description: "success", }, }) resp, n, f = ope.SuccessResponse() require.NotNil(t, resp) assert.Equal(t, "success", resp.Description) assert.Equal(t, 200, n) assert.True(t, f) } func TestOperationBuilder(t testing.T) { ope := NewOperation("").WithID("operationID") ope = ope.RespondsWith(200, &Response{ ResponseProps: ResponseProps{ Description: "success", }, }). WithDefaultResponse(&Response{ ResponseProps: ResponseProps{ Description: "default", }, }). SecuredWith("scheme-name", "scope1", "scope2"). WithConsumes("application/json"). WithProduces("application/json"). Deprecate(). WithTags("this", "that"). AddParam(nil). AddParam(QueryParam("myQueryParam").Typed("integer", "int32")). AddParam(QueryParam("myQueryParam").Typed("string", "hostname")). AddParam(PathParam("myPathParam").Typed("string", "uuid")). WithDescription("test operation"). WithSummary("my summary"). WithExternalDocs("some doc", "https://www.example.com") jazon, err := json.MarshalIndent(ope, "", " ") require.NoError(t, err) assert.JSONEq(t, `{ "operationId": "operationID", "description": "test operation", "summary": "my summary", "externalDocs": { "description": "some doc", "url": "https://www.example.com" }, "security": [ { "scheme-name": [ "scope1", "scope2" ] } ], "consumes": [ "application/json" ], "produces": [ "application/json" ], "tags": [ "this", "that" ], "deprecated": true, "parameters": [ { "type": "string", "format": "hostname", "name": "myQueryParam", "in": "query" }, { "type": "string", "format": "uuid", "name": "myPathParam", "in": "path", "required": true } ], "responses": { "200": { "description": "success" }, "default": { "description": "default" } } }`, string(jazon)) // check token lookup token, err := ope.JSONLookup("responses") require.NoError(t, err) jazon, err = json.MarshalIndent(token, "", " ") require.NoError(t, err) assert.JSONEq(t, `{ "200": { "description": "success" }, "default": { "description": "default" } }`, string(jazon)) // check delete methods ope = ope.RespondsWith(200, nil). RemoveParam("myQueryParam", "query"). RemoveParam("myPathParam", "path"). RemoveParam("fakeParam", "query"). Undeprecate(). WithExternalDocs("", "") jazon, err = json.MarshalIndent(ope, "", " ") require.NoError(t, err) assert.JSONEq(t, `{ "security": [ { "scheme-name": [ "scope1", "scope2" ] } ], "description": "test operation", "consumes": [ "application/json" ], "produces": [ "application/json" ], "tags": [ "this", "that" ], "summary": "my summary", "operationId": "operationID", "responses": { "default": { "description": "default" } } }`, string(jazon)) } func TestIntegrationOperation(t testing.T) { var actual Operation require.NoError(t, json.Unmarshal([]byte(operationJSON), &actual)) assert.EqualValues(t, actual, operation) assertParsesJSON(t, operationJSON, operation) } func TestSecurityProperty(t testing.T) { // Ensure we omit security key when unset securityNotSet := OperationProps{} jsonResult, err := json.Marshal(securityNotSet) require.NoError(t, err) assert.NotContains(t, string(jsonResult), "security", "security key should be omitted when unset") // Ensure we preserve the security key when it contains an empty (zero length) slice securityContainsEmptyArray := OperationProps{ Security: []map[string][]string{}, } jsonResult, err = json.Marshal(securityContainsEmptyArray) require.NoError(t, err) var props OperationProps require.NoError(t, json.Unmarshal(jsonResult, &props)) assert.Equal(t, securityContainsEmptyArray, props) } func TestOperationGobEncoding(t testing.T) { // 1. empty scope in security requirements: "security": [ { "apiKey": [] } ], doTestOperationGobEncoding(t, operationJSON) // 2. nil security requirements doTestOperationGobEncoding(t, `{ "description": "operation description", "x-framework": "go-swagger", "consumes": [ "application/json", "application/x-yaml" ], "produces": [ "application/json", "application/x-yaml" ], "schemes": ["http", "https"], "tags": ["dogs"], "summary": "the summary of the operation", "operationId": "sendCat", "deprecated": true, "parameters": [{"$ref":"Cat"}], "responses": { "default": { "description": "void response" } } }`) // 3. empty security requirement doTestOperationGobEncoding(t, `{ "description": "operation description", "x-framework": "go-swagger", "consumes": [ "application/json", "application/x-yaml" ], "produces": [ "application/json", "application/x-yaml" ], "schemes": ["http", "https"], "tags": ["dogs"], "security": [], "summary": "the summary of the operation", "operationId": "sendCat", "deprecated": true, "parameters": [{"$ref":"Cat"}], "responses": { "default": { "description": "void response" } } }`) // 4. non-empty security requirements doTestOperationGobEncoding(t, `{ "description": "operation description", "x-framework": "go-swagger", "consumes": [ "application/json", "application/x-yaml" ], "produces": [ "application/json", "application/x-yaml" ], "schemes": ["http", "https"], "tags": ["dogs"], "summary": "the summary of the operation", "security": [ { "scoped-auth": [ "phone", "email" ] , "api-key": []} ], "operationId": "sendCat", "deprecated": true, "parameters": [{"$ref":"Cat"}], "responses": { "default": { "description": "void response" } } }`) } func doTestOperationGobEncoding(t testing.T, fixture string) { var src, dst Operation require.NoError(t, json.Unmarshal([]byte(fixture), &src)) doTestAnyGobEncoding(t, &src, &dst) } func doTestAnyGobEncoding(t *testing.T, src, dst interface{}) { expectedJSON, _ := json.MarshalIndent(src, "", " ") var b bytes.Buffer err := gob.NewEncoder(&b).Encode(src) require.NoError(t, err) err = gob.NewDecoder(&b).Decode(dst) require.NoError(t, err) jazon, err := json.MarshalIndent(dst, "", " ") require.NoError(t, err) assert.JSONEq(t, string(expectedJSON), string(jazon)) }	9.47 KB	2025-05-25 12:27
📄 parameter.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 spec import ( "encoding/json" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // QueryParam creates a query parameter func QueryParam(name string) Parameter { return &Parameter{ParamProps: ParamProps{Name: name, In: "query"}} } // HeaderParam creates a header parameter, this is always required by default func HeaderParam(name string) Parameter { return &Parameter{ParamProps: ParamProps{Name: name, In: "header", Required: true}} } // PathParam creates a path parameter, this is always required func PathParam(name string) Parameter { return &Parameter{ParamProps: ParamProps{Name: name, In: "path", Required: true}} } // BodyParam creates a body parameter func BodyParam(name string, schema Schema) Parameter { return &Parameter{ParamProps: ParamProps{Name: name, In: "body", Schema: schema}} } // FormDataParam creates a body parameter func FormDataParam(name string) Parameter { return &Parameter{ParamProps: ParamProps{Name: name, In: "formData"}} } // FileParam creates a body parameter func FileParam(name string) Parameter { return &Parameter{ParamProps: ParamProps{Name: name, In: "formData"}, SimpleSchema: SimpleSchema{Type: "file"}} } // SimpleArrayParam creates a param for a simple array (string, int, date etc) func SimpleArrayParam(name, tpe, fmt string) Parameter { return &Parameter{ParamProps: ParamProps{Name: name}, SimpleSchema: SimpleSchema{Type: jsonArray, CollectionFormat: "csv", Items: &Items{SimpleSchema: SimpleSchema{Type: tpe, Format: fmt}}}} } // ParamRef creates a parameter that's a json reference func ParamRef(uri string) Parameter { p := new(Parameter) p.Ref = MustCreateRef(uri) return p } // ParamProps describes the specific attributes of an operation parameter // // NOTE: // - Schema is defined when "in" == "body": see validate // - AllowEmptyValue is allowed where "in" == "query" \|\| "formData" type ParamProps struct { Description string `json:"description,omitempty"` Name string `json:"name,omitempty"` In string `json:"in,omitempty"` Required bool `json:"required,omitempty"` Schema Schema `json:"schema,omitempty"` AllowEmptyValue bool `json:"allowEmptyValue,omitempty"` } // Parameter a unique parameter is defined by a combination of a [name](#parameterName) and [location](#parameterIn). // // There are five possible parameter types. // - Path - Used together with [Path Templating](#pathTemplating), where the parameter value is actually part // of the operation's URL. This does not include the host or base path of the API. For example, in `/items/{itemId}`, // the path parameter is `itemId`. // - Query - Parameters that are appended to the URL. For example, in `/items?id=###`, the query parameter is `id`. // - Header - Custom headers that are expected as part of the request. // - Body - The payload that's appended to the HTTP request. Since there can only be one payload, there can only be // _one_ body parameter. The name of the body parameter has no effect on the parameter itself and is used for // documentation purposes only. Since Form parameters are also in the payload, body and form parameters cannot exist // together for the same operation. // - Form - Used to describe the payload of an HTTP request when either `application/x-www-form-urlencoded` or // `multipart/form-data` are used as the content type of the request (in Swagger's definition, // the [`consumes`](#operationConsumes) property of an operation). This is the only parameter type that can be used // to send files, thus supporting the `file` type. Since form parameters are sent in the payload, they cannot be // declared together with a body parameter for the same operation. Form parameters have a different format based on // the content-type used (for further details, consult http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4). // - `application/x-www-form-urlencoded` - Similar to the format of Query parameters but as a payload. // For example, `foo=1&bar=swagger` - both `foo` and `bar` are form parameters. This is normally used for simple // parameters that are being transferred. // - `multipart/form-data` - each parameter takes a section in the payload with an internal header. // For example, for the header `Content-Disposition: form-data; name="submit-name"` the name of the parameter is // `submit-name`. This type of form parameters is more commonly used for file transfers. // // For more information: http://goo.gl/8us55a#parameterObject type Parameter struct { Refable CommonValidations SimpleSchema VendorExtensible ParamProps } // JSONLookup look up a value by the json property name func (p Parameter) JSONLookup(token string) (interface{}, error) { if ex, ok := p.Extensions[token]; ok { return &ex, nil } if token == jsonRef { return &p.Ref, nil } r, _, err := jsonpointer.GetForToken(p.CommonValidations, token) if err != nil && !strings.HasPrefix(err.Error(), "object has no field") { return nil, err } if r != nil { return r, nil } r, _, err = jsonpointer.GetForToken(p.SimpleSchema, token) if err != nil && !strings.HasPrefix(err.Error(), "object has no field") { return nil, err } if r != nil { return r, nil } r, _, err = jsonpointer.GetForToken(p.ParamProps, token) return r, err } // WithDescription a fluent builder method for the description of the parameter func (p Parameter) WithDescription(description string) Parameter { p.Description = description return p } // Named a fluent builder method to override the name of the parameter func (p Parameter) Named(name string) Parameter { p.Name = name return p } // WithLocation a fluent builder method to override the location of the parameter func (p Parameter) WithLocation(in string) Parameter { p.In = in return p } // Typed a fluent builder method for the type of the parameter value func (p Parameter) Typed(tpe, format string) Parameter { p.Type = tpe p.Format = format return p } // CollectionOf a fluent builder method for an array parameter func (p Parameter) CollectionOf(items Items, format string) Parameter { p.Type = jsonArray p.Items = items p.CollectionFormat = format return p } // WithDefault sets the default value on this parameter func (p Parameter) WithDefault(defaultValue interface{}) Parameter { p.AsOptional() // with default implies optional p.Default = defaultValue return p } // AllowsEmptyValues flags this parameter as being ok with empty values func (p Parameter) AllowsEmptyValues() Parameter { p.AllowEmptyValue = true return p } // NoEmptyValues flags this parameter as not liking empty values func (p Parameter) NoEmptyValues() Parameter { p.AllowEmptyValue = false return p } // AsOptional flags this parameter as optional func (p Parameter) AsOptional() Parameter { p.Required = false return p } // AsRequired flags this parameter as required func (p Parameter) AsRequired() Parameter { if p.Default != nil { // with a default required makes no sense return p } p.Required = true return p } // WithMaxLength sets a max length value func (p Parameter) WithMaxLength(max int64) Parameter { p.MaxLength = &max return p } // WithMinLength sets a min length value func (p Parameter) WithMinLength(min int64) Parameter { p.MinLength = &min return p } // WithPattern sets a pattern value func (p Parameter) WithPattern(pattern string) Parameter { p.Pattern = pattern return p } // WithMultipleOf sets a multiple of value func (p Parameter) WithMultipleOf(number float64) Parameter { p.MultipleOf = &number return p } // WithMaximum sets a maximum number value func (p Parameter) WithMaximum(max float64, exclusive bool) Parameter { p.Maximum = &max p.ExclusiveMaximum = exclusive return p } // WithMinimum sets a minimum number value func (p Parameter) WithMinimum(min float64, exclusive bool) Parameter { p.Minimum = &min p.ExclusiveMinimum = exclusive return p } // WithEnum sets a the enum values (replace) func (p Parameter) WithEnum(values ...interface{}) Parameter { p.Enum = append([]interface{}{}, values...) return p } // WithMaxItems sets the max items func (p Parameter) WithMaxItems(size int64) Parameter { p.MaxItems = &size return p } // WithMinItems sets the min items func (p Parameter) WithMinItems(size int64) Parameter { p.MinItems = &size return p } // UniqueValues dictates that this array can only have unique items func (p Parameter) UniqueValues() Parameter { p.UniqueItems = true return p } // AllowDuplicates this array can have duplicates func (p Parameter) AllowDuplicates() Parameter { p.UniqueItems = false return p } // WithValidations is a fluent method to set parameter validations func (p Parameter) WithValidations(val CommonValidations) Parameter { p.SetValidations(SchemaValidations{CommonValidations: val}) return p } // UnmarshalJSON hydrates this items instance with the data from JSON func (p Parameter) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &p.CommonValidations); err != nil { return err } if err := json.Unmarshal(data, &p.Refable); err != nil { return err } if err := json.Unmarshal(data, &p.SimpleSchema); err != nil { return err } if err := json.Unmarshal(data, &p.VendorExtensible); err != nil { return err } return json.Unmarshal(data, &p.ParamProps) } // MarshalJSON converts this items object to JSON func (p Parameter) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(p.CommonValidations) if err != nil { return nil, err } b2, err := json.Marshal(p.SimpleSchema) if err != nil { return nil, err } b3, err := json.Marshal(p.Refable) if err != nil { return nil, err } b4, err := json.Marshal(p.VendorExtensible) if err != nil { return nil, err } b5, err := json.Marshal(p.ParamProps) if err != nil { return nil, err } return swag.ConcatJSON(b3, b1, b2, b4, b5), nil }	10.38 KB	2025-05-25 12:27
📄 parameters_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 spec import ( "encoding/json" "testing" "github.com/go-openapi/swag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var parameter = Parameter{ VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{ "x-framework": "swagger-go", }}, Refable: Refable{Ref: MustCreateRef("Dog")}, CommonValidations: CommonValidations{ Maximum: float64Ptr(100), ExclusiveMaximum: true, ExclusiveMinimum: true, Minimum: float64Ptr(5), MaxLength: int64Ptr(100), MinLength: int64Ptr(5), Pattern: "\\w{1,5}\\w+", MaxItems: int64Ptr(100), MinItems: int64Ptr(5), UniqueItems: true, MultipleOf: float64Ptr(5), Enum: []interface{}{"hello", "world"}, }, SimpleSchema: SimpleSchema{ Type: "string", Format: "date", CollectionFormat: "csv", Items: &Items{ Refable: Refable{Ref: MustCreateRef("Cat")}, }, Default: "8", }, ParamProps: ParamProps{ Name: "param-name", In: "header", Required: true, Schema: &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}, Description: "the description of this parameter", }, } var parameterJSON = `{ "items": { "$ref": "Cat" }, "x-framework": "swagger-go", "$ref": "Dog", "description": "the description of this parameter", "maximum": 100, "minimum": 5, "exclusiveMaximum": true, "exclusiveMinimum": true, "maxLength": 100, "minLength": 5, "pattern": "\\w{1,5}\\w+", "maxItems": 100, "minItems": 5, "uniqueItems": true, "multipleOf": 5, "enum": ["hello", "world"], "type": "string", "format": "date", "name": "param-name", "in": "header", "required": true, "schema": { "type": "string" }, "collectionFormat": "csv", "default": "8" }` func TestIntegrationParameter(t testing.T) { var actual Parameter require.NoError(t, json.Unmarshal([]byte(parameterJSON), &actual)) assert.EqualValues(t, actual, parameter) assertParsesJSON(t, parameterJSON, parameter) } func TestParameterSerialization(t testing.T) { items := &Items{ SimpleSchema: SimpleSchema{Type: "string"}, } intItems := &Items{ SimpleSchema: SimpleSchema{Type: "int", Format: "int32"}, } assertSerializeJSON(t, QueryParam("").Typed("string", ""), `{"type":"string","in":"query"}`) assertSerializeJSON(t, QueryParam("").CollectionOf(items, "multi"), `{"type":"array","items":{"type":"string"},"collectionFormat":"multi","in":"query"}`) assertSerializeJSON(t, PathParam("").Typed("string", ""), `{"type":"string","in":"path","required":true}`) assertSerializeJSON(t, PathParam("").CollectionOf(items, "multi"), `{"type":"array","items":{"type":"string"},"collectionFormat":"multi","in":"path","required":true}`) assertSerializeJSON(t, PathParam("").CollectionOf(intItems, "multi"), `{"type":"array","items":{"type":"int","format":"int32"},"collectionFormat":"multi","in":"path","required":true}`) assertSerializeJSON(t, HeaderParam("").Typed("string", ""), `{"type":"string","in":"header","required":true}`) assertSerializeJSON(t, HeaderParam("").CollectionOf(items, "multi"), `{"type":"array","items":{"type":"string"},"collectionFormat":"multi","in":"header","required":true}`) schema := &Schema{SchemaProps: SchemaProps{ Properties: map[string]Schema{ "name": {SchemaProps: SchemaProps{ Type: []string{"string"}, }}, }, }} refSchema := &Schema{ SchemaProps: SchemaProps{Ref: MustCreateRef("Cat")}, } assertSerializeJSON(t, BodyParam("", schema), `{"in":"body","schema":{"properties":{"name":{"type":"string"}}}}`) assertSerializeJSON(t, BodyParam("", refSchema), `{"in":"body","schema":{"$ref":"Cat"}}`) // array body param assertSerializeJSON(t, BodyParam("", ArrayProperty(RefProperty("Cat"))), `{"in":"body","schema":{"type":"array","items":{"$ref":"Cat"}}}`) } func TestParameterGobEncoding(t testing.T) { var src, dst Parameter require.NoError(t, json.Unmarshal([]byte(parameterJSON), &src)) doTestAnyGobEncoding(t, &src, &dst) } func TestParametersWithValidation(t testing.T) { p := new(Parameter).WithValidations(CommonValidations{MaxLength: swag.Int64(15)}) assert.EqualValues(t, swag.Int64(15), p.MaxLength) }	4.76 KB	2025-05-25 12:27
📄 path_item.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 spec import ( "encoding/json" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // PathItemProps the path item specific properties type PathItemProps struct { Get Operation `json:"get,omitempty"` Put Operation `json:"put,omitempty"` Post Operation `json:"post,omitempty"` Delete Operation `json:"delete,omitempty"` Options Operation `json:"options,omitempty"` Head Operation `json:"head,omitempty"` Patch Operation `json:"patch,omitempty"` Parameters []Parameter `json:"parameters,omitempty"` } // PathItem describes the operations available on a single path. // A Path Item may be empty, due to [ACL constraints](http://goo.gl/8us55a#securityFiltering). // The path itself is still exposed to the documentation viewer but they will // not know which operations and parameters are available. // // For more information: http://goo.gl/8us55a#pathItemObject type PathItem struct { Refable VendorExtensible PathItemProps } // JSONLookup look up a value by the json property name func (p PathItem) JSONLookup(token string) (interface{}, error) { if ex, ok := p.Extensions[token]; ok { return &ex, nil } if token == jsonRef { return &p.Ref, nil } r, _, err := jsonpointer.GetForToken(p.PathItemProps, token) return r, err } // UnmarshalJSON hydrates this items instance with the data from JSON func (p PathItem) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &p.Refable); err != nil { return err } if err := json.Unmarshal(data, &p.VendorExtensible); err != nil { return err } return json.Unmarshal(data, &p.PathItemProps) } // MarshalJSON converts this items object to JSON func (p PathItem) MarshalJSON() ([]byte, error) { b3, err := json.Marshal(p.Refable) if err != nil { return nil, err } b4, err := json.Marshal(p.VendorExtensible) if err != nil { return nil, err } b5, err := json.Marshal(p.PathItemProps) if err != nil { return nil, err } concated := swag.ConcatJSON(b3, b4, b5) return concated, nil }	2.6 KB	2025-05-25 12:27
📄 path_item_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var pathItem = PathItem{ Refable: Refable{Ref: MustCreateRef("Dog")}, VendorExtensible: VendorExtensible{ Extensions: map[string]interface{}{ "x-framework": "go-swagger", }, }, PathItemProps: PathItemProps{ Get: &Operation{ OperationProps: OperationProps{Description: "get operation description"}, }, Put: &Operation{ OperationProps: OperationProps{Description: "put operation description"}, }, Post: &Operation{ OperationProps: OperationProps{Description: "post operation description"}, }, Delete: &Operation{ OperationProps: OperationProps{Description: "delete operation description"}, }, Options: &Operation{ OperationProps: OperationProps{Description: "options operation description"}, }, Head: &Operation{ OperationProps: OperationProps{Description: "head operation description"}, }, Patch: &Operation{ OperationProps: OperationProps{Description: "patch operation description"}, }, Parameters: []Parameter{ { ParamProps: ParamProps{In: "path"}, }, }, }, } const pathItemJSON = `{ "$ref": "Dog", "x-framework": "go-swagger", "get": { "description": "get operation description" }, "put": { "description": "put operation description" }, "post": { "description": "post operation description" }, "delete": { "description": "delete operation description" }, "options": { "description": "options operation description" }, "head": { "description": "head operation description" }, "patch": { "description": "patch operation description" }, "parameters": [{"in":"path"}] }` func TestIntegrationPathItem(t *testing.T) { var actual PathItem require.NoError(t, json.Unmarshal([]byte(pathItemJSON), &actual)) assert.EqualValues(t, actual, pathItem) assertParsesJSON(t, pathItemJSON, pathItem) }	2.45 KB	2025-05-25 12:27
📄 paths.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 spec import ( "encoding/json" "fmt" "strings" "github.com/go-openapi/swag" ) // Paths holds the relative paths to the individual endpoints. // The path is appended to the [`basePath`](http://goo.gl/8us55a#swaggerBasePath) in order // to construct the full URL. // The Paths may be empty, due to [ACL constraints](http://goo.gl/8us55a#securityFiltering). // // For more information: http://goo.gl/8us55a#pathsObject type Paths struct { VendorExtensible Paths map[string]PathItem `json:"-"` // custom serializer to flatten this, each entry must start with "/" } // JSONLookup look up a value by the json property name func (p Paths) JSONLookup(token string) (interface{}, error) { if pi, ok := p.Paths[token]; ok { return &pi, nil } if ex, ok := p.Extensions[token]; ok { return &ex, nil } return nil, fmt.Errorf("object has no field %q", token) } // UnmarshalJSON hydrates this items instance with the data from JSON func (p *Paths) UnmarshalJSON(data []byte) error { var res map[string]json.RawMessage if err := json.Unmarshal(data, &res); err != nil { return err } for k, v := range res { if strings.HasPrefix(strings.ToLower(k), "x-") { if p.Extensions == nil { p.Extensions = make(map[string]interface{}) } var d interface{} if err := json.Unmarshal(v, &d); err != nil { return err } p.Extensions[k] = d } if strings.HasPrefix(k, "/") { if p.Paths == nil { p.Paths = make(map[string]PathItem) } var pi PathItem if err := json.Unmarshal(v, &pi); err != nil { return err } p.Paths[k] = pi } } return nil } // MarshalJSON converts this items object to JSON func (p Paths) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(p.VendorExtensible) if err != nil { return nil, err } pths := make(map[string]PathItem) for k, v := range p.Paths { if strings.HasPrefix(k, "/") { pths[k] = v } } b2, err := json.Marshal(pths) if err != nil { return nil, err } concated := swag.ConcatJSON(b1, b2) return concated, nil }	2.57 KB	2025-05-25 12:27
📄 paths_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var paths = Paths{ VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-framework": "go-swagger"}}, Paths: map[string]PathItem{ "/": { Refable: Refable{Ref: MustCreateRef("cats")}, }, }, } const pathsJSON = `{"x-framework":"go-swagger","/":{"$ref":"cats"}}` func TestIntegrationPaths(t *testing.T) { var actual Paths require.NoError(t, json.Unmarshal([]byte(pathsJSON), &actual)) assert.EqualValues(t, actual, paths) assertParsesJSON(t, pathsJSON, paths) }	1.2 KB	2025-05-25 12:27
📄 properties.go package spec import ( "bytes" "encoding/json" "reflect" "sort" ) // OrderSchemaItem holds a named schema (e.g. from a property of an object) type OrderSchemaItem struct { Name string Schema } // OrderSchemaItems is a sortable slice of named schemas. // The ordering is defined by the x-order schema extension. type OrderSchemaItems []OrderSchemaItem // MarshalJSON produces a json object with keys defined by the name schemas // of the OrderSchemaItems slice, keeping the original order of the slice. func (items OrderSchemaItems) MarshalJSON() ([]byte, error) { buf := bytes.NewBuffer(nil) buf.WriteString("{") for i := range items { if i > 0 { buf.WriteString(",") } buf.WriteString("\"") buf.WriteString(items[i].Name) buf.WriteString("\":") bs, err := json.Marshal(&items[i].Schema) if err != nil { return nil, err } buf.Write(bs) } buf.WriteString("}") return buf.Bytes(), nil } func (items OrderSchemaItems) Len() int { return len(items) } func (items OrderSchemaItems) Swap(i, j int) { items[i], items[j] = items[j], items[i] } func (items OrderSchemaItems) Less(i, j int) (ret bool) { ii, oki := items[i].Extensions.GetInt("x-order") ij, okj := items[j].Extensions.GetInt("x-order") if oki { if okj { defer func() { if err := recover(); err != nil { defer func() { if err = recover(); err != nil { ret = items[i].Name < items[j].Name } }() ret = reflect.ValueOf(ii).String() < reflect.ValueOf(ij).String() } }() return ii < ij } return true } else if okj { return false } return items[i].Name < items[j].Name } // SchemaProperties is a map representing the properties of a Schema object. // It knows how to transform its keys into an ordered slice. type SchemaProperties map[string]Schema // ToOrderedSchemaItems transforms the map of properties into a sortable slice func (properties SchemaProperties) ToOrderedSchemaItems() OrderSchemaItems { items := make(OrderSchemaItems, 0, len(properties)) for k, v := range properties { items = append(items, OrderSchemaItem{ Name: k, Schema: v, }) } sort.Sort(items) return items } // MarshalJSON produces properties as json, keeping their order. func (properties SchemaProperties) MarshalJSON() ([]byte, error) { if properties == nil { return []byte("null"), nil } return json.Marshal(properties.ToOrderedSchemaItems()) }	2.35 KB	2025-05-25 12:27
📄 properties_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 spec import ( "testing" ) func TestPropertySerialization(t testing.T) { strProp := StringProperty() strProp.Enum = append(strProp.Enum, "a", "b") prop := &Schema{SchemaProps: SchemaProps{ Items: &SchemaOrArray{Schemas: []Schema{ {SchemaProps: SchemaProps{Type: []string{"string"}}}, {SchemaProps: SchemaProps{Type: []string{"string"}}}, }}, }} var propSerData = []struct { Schema Schema JSON string }{ {BooleanProperty(), `{"type":"boolean"}`}, {DateProperty(), `{"type":"string","format":"date"}`}, {DateTimeProperty(), `{"type":"string","format":"date-time"}`}, {Float64Property(), `{"type":"number","format":"double"}`}, {Float32Property(), `{"type":"number","format":"float"}`}, {Int32Property(), `{"type":"integer","format":"int32"}`}, {Int64Property(), `{"type":"integer","format":"int64"}`}, {MapProperty(StringProperty()), `{"type":"object","additionalProperties":{"type":"string"}}`}, {MapProperty(Int32Property()), `{"type":"object","additionalProperties":{"type":"integer","format":"int32"}}`}, {RefProperty("Dog"), `{"$ref":"Dog"}`}, {StringProperty(), `{"type":"string"}`}, {strProp, `{"type":"string","enum":["a","b"]}`}, {ArrayProperty(StringProperty()), `{"type":"array","items":{"type":"string"}}`}, {prop, `{"items":[{"type":"string"},{"type":"string"}]}`}, } for _, v := range propSerData { t.Log("roundtripping for", v.JSON) assertSerializeJSON(t, v.Schema, v.JSON) assertParsesJSON(t, v.JSON, v.Schema) } }	2.05 KB	2025-05-25 12:27
📄 ref.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 spec import ( "bytes" "encoding/gob" "encoding/json" "net/http" "os" "path/filepath" "github.com/go-openapi/jsonreference" ) // Refable is a struct for things that accept a $ref property type Refable struct { Ref Ref } // MarshalJSON marshals the ref to json func (r Refable) MarshalJSON() ([]byte, error) { return r.Ref.MarshalJSON() } // UnmarshalJSON unmarshalss the ref from json func (r Refable) UnmarshalJSON(d []byte) error { return json.Unmarshal(d, &r.Ref) } // Ref represents a json reference that is potentially resolved type Ref struct { jsonreference.Ref } // RemoteURI gets the remote uri part of the ref func (r Ref) RemoteURI() string { if r.String() == "" { return "" } u := r.GetURL() u.Fragment = "" return u.String() } // IsValidURI returns true when the url the ref points to can be found func (r Ref) IsValidURI(basepaths ...string) bool { if r.String() == "" { return true } v := r.RemoteURI() if v == "" { return true } if r.HasFullURL { //nolint:noctx,gosec rr, err := http.Get(v) if err != nil { return false } defer rr.Body.Close() return rr.StatusCode/100 == 2 } if !(r.HasFileScheme \|\| r.HasFullFilePath \|\| r.HasURLPathOnly) { return false } // check for local file pth := v if r.HasURLPathOnly { base := "." if len(basepaths) > 0 { base = filepath.Dir(filepath.Join(basepaths...)) } p, e := filepath.Abs(filepath.ToSlash(filepath.Join(base, pth))) if e != nil { return false } pth = p } fi, err := os.Stat(filepath.ToSlash(pth)) if err != nil { return false } return !fi.IsDir() } // Inherits creates a new reference from a parent and a child // If the child cannot inherit from the parent, an error is returned func (r Ref) Inherits(child Ref) (Ref, error) { ref, err := r.Ref.Inherits(child.Ref) if err != nil { return nil, err } return &Ref{Ref: ref}, nil } // NewRef creates a new instance of a ref object // returns an error when the reference uri is an invalid uri func NewRef(refURI string) (Ref, error) { ref, err := jsonreference.New(refURI) if err != nil { return Ref{}, err } return Ref{Ref: ref}, nil } // MustCreateRef creates a ref object but panics when refURI is invalid. // Use the NewRef method for a version that returns an error. func MustCreateRef(refURI string) Ref { return Ref{Ref: jsonreference.MustCreateRef(refURI)} } // MarshalJSON marshals this ref into a JSON object func (r Ref) MarshalJSON() ([]byte, error) { str := r.String() if str == "" { if r.IsRoot() { return []byte(`{"$ref":""}`), nil } return []byte("{}"), nil } v := map[string]interface{}{"$ref": str} return json.Marshal(v) } // UnmarshalJSON unmarshals this ref from a JSON object func (r Ref) UnmarshalJSON(d []byte) error { var v map[string]interface{} if err := json.Unmarshal(d, &v); err != nil { return err } return r.fromMap(v) } // GobEncode provides a safe gob encoder for Ref func (r Ref) GobEncode() ([]byte, error) { var b bytes.Buffer raw, err := r.MarshalJSON() if err != nil { return nil, err } err = gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } // GobDecode provides a safe gob decoder for Ref func (r Ref) GobDecode(b []byte) error { var raw []byte buf := bytes.NewBuffer(b) err := gob.NewDecoder(buf).Decode(&raw) if err != nil { return err } return json.Unmarshal(raw, r) } func (r Ref) fromMap(v map[string]interface{}) error { if v == nil { return nil } if vv, ok := v["$ref"]; ok { if str, ok := vv.(string); ok { ref, err := jsonreference.New(str) if err != nil { return err } *r = Ref{Ref: ref} } } return nil }	4.17 KB	2025-05-25 12:27
📄 ref_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 spec import ( "bytes" "encoding/gob" "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // pin pointing go-swagger/go-swagger#1816 issue with cloning ref's func TestCloneRef(t *testing.T) { var b bytes.Buffer src := MustCreateRef("#/definitions/test") require.NoError(t, gob.NewEncoder(&b).Encode(&src), ) var dst Ref require.NoError(t, gob.NewDecoder(&b).Decode(&dst), ) jazon, err := json.Marshal(dst) require.NoError(t, err) assert.Equal(t, `{"$ref":"#/definitions/test"}`, string(jazon)) }	1.15 KB	2025-05-25 12:27
📄 resolver.go package spec import ( "fmt" "github.com/go-openapi/swag" ) func resolveAnyWithBase(root interface{}, ref Ref, result interface{}, options ExpandOptions) error { options = optionsOrDefault(options) resolver := defaultSchemaLoader(root, options, nil, nil) if err := resolver.Resolve(ref, result, options.RelativeBase); err != nil { return err } return nil } // ResolveRefWithBase resolves a reference against a context root with preservation of base path func ResolveRefWithBase(root interface{}, ref Ref, options ExpandOptions) (Schema, error) { result := new(Schema) if err := resolveAnyWithBase(root, ref, result, options); err != nil { return nil, err } return result, nil } // ResolveRef resolves a reference for a schema against a context root // ref is guaranteed to be in root (no need to go to external files) // // ResolveRef is ONLY called from the code generation module func ResolveRef(root interface{}, ref Ref) (Schema, error) { res, _, err := ref.GetPointer().Get(root) if err != nil { return nil, err } switch sch := res.(type) { case Schema: return &sch, nil case Schema: return sch, nil case map[string]interface{}: newSch := new(Schema) if err = swag.DynamicJSONToStruct(sch, newSch); err != nil { return nil, err } return newSch, nil default: return nil, fmt.Errorf("type: %T: %w", sch, ErrUnknownTypeForReference) } } // ResolveParameterWithBase resolves a parameter reference against a context root and base path func ResolveParameterWithBase(root interface{}, ref Ref, options ExpandOptions) (Parameter, error) { result := new(Parameter) if err := resolveAnyWithBase(root, &ref, result, options); err != nil { return nil, err } return result, nil } // ResolveParameter resolves a parameter reference against a context root func ResolveParameter(root interface{}, ref Ref) (Parameter, error) { return ResolveParameterWithBase(root, ref, nil) } // ResolveResponseWithBase resolves response a reference against a context root and base path func ResolveResponseWithBase(root interface{}, ref Ref, options ExpandOptions) (Response, error) { result := new(Response) err := resolveAnyWithBase(root, &ref, result, options) if err != nil { return nil, err } return result, nil } // ResolveResponse resolves response a reference against a context root func ResolveResponse(root interface{}, ref Ref) (Response, error) { return ResolveResponseWithBase(root, ref, nil) } // ResolvePathItemWithBase resolves response a path item against a context root and base path func ResolvePathItemWithBase(root interface{}, ref Ref, options ExpandOptions) (PathItem, error) { result := new(PathItem) if err := resolveAnyWithBase(root, &ref, result, options); err != nil { return nil, err } return result, nil } // ResolvePathItem resolves response a path item against a context root and base path // // Deprecated: use ResolvePathItemWithBase instead func ResolvePathItem(root interface{}, ref Ref, options ExpandOptions) (PathItem, error) { return ResolvePathItemWithBase(root, ref, options) } // ResolveItemsWithBase resolves parameter items reference against a context root and base path. // // NOTE: stricly speaking, this construct is not supported by Swagger 2.0. // Similarly, $ref are forbidden in response headers. func ResolveItemsWithBase(root interface{}, ref Ref, options ExpandOptions) (Items, error) { result := new(Items) if err := resolveAnyWithBase(root, &ref, result, options); err != nil { return nil, err } return result, nil } // ResolveItems resolves parameter items reference against a context root and base path. // // Deprecated: use ResolveItemsWithBase instead func ResolveItems(root interface{}, ref Ref, options ExpandOptions) (Items, error) { return ResolveItemsWithBase(root, ref, options) }	3.75 KB	2025-05-25 12:27
📄 resolver_test.go package spec import ( "encoding/json" "net/http" "net/http/httptest" "os" "path/filepath" "testing" "github.com/go-openapi/jsonpointer" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestResolveRef(t testing.T) { var root interface{} require.NoError(t, json.Unmarshal([]byte(PetStore20), &root)) ref, err := NewRef("#/definitions/Category") require.NoError(t, err) sch, err := ResolveRef(root, &ref) require.NoError(t, err) b, err := sch.MarshalJSON() require.NoError(t, err) assert.JSONEq(t, `{"id":"Category","properties":{"id":{"type":"integer","format":"int64"},"name":{"type":"string"}}}`, string(b)) // WithBase variant sch, err = ResolveRefWithBase(root, &ref, &ExpandOptions{ RelativeBase: "/", }) require.NoError(t, err) b, err = sch.MarshalJSON() require.NoError(t, err) assert.JSONEq(t, `{"id":"Category","properties":{"id":{"type":"integer","format":"int64"},"name":{"type":"string"}}}`, string(b)) } func TestResolveResponse(t testing.T) { specDoc, err := jsonDoc(filepath.Join("fixtures", "expansion", "all-the-things.json")) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(specDoc, spec)) // Resolve with root version resp := spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200] resp2, err := ResolveResponse(spec, resp.Ref) require.NoError(t, err) // resolve resolves the ref, but dos not expand jazon := asJSON(t, resp2) assert.JSONEq(t, `{ "$ref": "#/responses/petResponse" }`, jazon) } func TestResolveResponseWithBase(t testing.T) { specDoc, err := jsonDoc(crossFileRefFixture) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(specDoc, spec)) // Resolve with root version resp := spec.Paths.Paths["/"].Get.Responses.StatusCodeResponses[200] resp2, err := ResolveResponseWithBase(spec, resp.Ref, &ExpandOptions{RelativeBase: crossFileRefFixture}) require.NoError(t, err) // resolve resolves the ref, but dos not expand jazon := asJSON(t, resp2) assert.JSONEq(t, `{ "$ref": "#/responses/petResponse" }`, jazon) } func TestResolveParam(t testing.T) { specDoc, err := jsonDoc(filepath.Join("fixtures", "expansion", "all-the-things.json")) require.NoError(t, err) var spec Swagger require.NoError(t, json.Unmarshal(specDoc, &spec)) param := spec.Paths.Paths["/pets/{id}"].Get.Parameters[0] par, err := ResolveParameter(spec, param.Ref) require.NoError(t, err) jazon := asJSON(t, par) assert.JSONEq(t, `{ "name": "id", "in": "path", "description": "ID of pet to fetch", "required": true, "type": "integer", "format": "int64" }`, jazon) } func TestResolveParamWithBase(t testing.T) { specDoc, err := jsonDoc(crossFileRefFixture) require.NoError(t, err) var spec Swagger require.NoError(t, json.Unmarshal(specDoc, &spec)) param := spec.Paths.Paths["/pets"].Get.Parameters[0] par, err := ResolveParameterWithBase(spec, param.Ref, &ExpandOptions{RelativeBase: crossFileRefFixture}) require.NoError(t, err) jazon := asJSON(t, par) assert.JSONEq(t, `{ "description":"ID of pet to fetch", "format":"int64", "in":"path", "name":"id", "required":true, "type":"integer" }`, jazon) } func TestResolveRemoteRef_RootSame(t testing.T) { fileserver := http.FileServer(http.Dir(specs)) server := httptest.NewServer(fileserver) defer server.Close() rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) // the filename doesn't matter because ref will eventually point to refed.json specBase := normalizeBase(filepath.Join(specs, "anyotherfile.json")) var result0 Swagger ref0, _ := NewRef(server.URL + "/refed.json#") resolver0 := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver0.Resolve(&ref0, &result0, "")) assertSpecs(t, result0, rootDoc) var result1 Swagger ref1, _ := NewRef("./refed.json") resolver1 := defaultSchemaLoader(rootDoc, &ExpandOptions{ RelativeBase: specBase, }, nil, nil) require.NoError(t, resolver1.Resolve(&ref1, &result1, specBase)) assertSpecs(t, result1, rootDoc) } func TestResolveRemoteRef_FromFragment(t testing.T) { fileserver := http.FileServer(http.Dir(specs)) server := httptest.NewServer(fileserver) defer server.Close() rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt Schema ref, err := NewRef(server.URL + "/refed.json#/definitions/pet") require.NoError(t, err) context := newResolverContext(&ExpandOptions{PathLoader: jsonDoc}) resolver := &schemaLoader{root: rootDoc, cache: defaultResolutionCache(), context: context} require.NoError(t, resolver.Resolve(&ref, &tgt, "")) assert.Equal(t, []string{"id", "name"}, tgt.Required) } func TestResolveRemoteRef_FromInvalidFragment(t testing.T) { fileserver := http.FileServer(http.Dir(specs)) server := httptest.NewServer(fileserver) defer server.Close() rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt Schema ref, err := NewRef(server.URL + "/refed.json#/definitions/NotThere") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.Error(t, resolver.Resolve(&ref, &tgt, "")) } /* This next test will have to wait until we do full $ID analysis for every subschema on every file that is referenced / / For now, TestResolveRemoteRef_WithNestedResolutionContext replaces this next test / // func TestResolveRemoteRef_WithNestedResolutionContextWithFragment_WithParentID(t testing.T) { // server := resolutionContextServer() // defer server.Close() // // rootDoc := new(Swagger) // b, err := os.ReadFile("fixtures/specs/refed.json") // require.NoError(t, err) && assert.NoError(t, json.Unmarshal(b, rootDoc)) // // var tgt Schema // ref, err := NewRef(server.URL + "/resolution2.json#/items/items") // require.NoError(t, err) // // resolver := defaultSchemaLoader(rootDoc, nil, nil,nil) // require.NoError(t, resolver.Resolve(&ref, &tgt, "")) // assert.Equal(t, StringOrArray([]string{"file"}), tgt.Type) // } func TestResolveRemoteRef_ToParameter(t testing.T) { fileserver := http.FileServer(http.Dir(specs)) server := httptest.NewServer(fileserver) defer server.Close() rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt Parameter ref, err := NewRef(server.URL + "/refed.json#/parameters/idParam") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, "")) assert.Equal(t, "id", tgt.Name) assert.Equal(t, "path", tgt.In) assert.Equal(t, "ID of pet to fetch", tgt.Description) assert.True(t, tgt.Required) assert.Equal(t, "integer", tgt.Type) assert.Equal(t, "int64", tgt.Format) } func TestResolveRemoteRef_ToPathItem(t testing.T) { fileserver := http.FileServer(http.Dir(specs)) server := httptest.NewServer(fileserver) defer server.Close() rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt PathItem ref, err := NewRef(server.URL + "/refed.json#/paths/" + jsonpointer.Escape("/pets/{id}")) require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, "")) assert.Equal(t, rootDoc.Paths.Paths["/pets/{id}"].Get, tgt.Get) } func TestResolveRemoteRef_ToResponse(t testing.T) { fileserver := http.FileServer(http.Dir(specs)) server := httptest.NewServer(fileserver) defer server.Close() rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt Response ref, err := NewRef(server.URL + "/refed.json#/responses/petResponse") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, "")) assert.Equal(t, rootDoc.Responses["petResponse"], tgt) } func TestResolveLocalRef_SameRoot(t testing.T) { rootDoc := new(Swagger) require.NoError(t, json.Unmarshal(PetStoreJSONMessage, rootDoc)) result := new(Swagger) ref, _ := NewRef("#") resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, result, "")) assert.Equal(t, rootDoc, result) } func TestResolveLocalRef_FromFragment(t testing.T) { rootDoc := new(Swagger) require.NoError(t, json.Unmarshal(PetStoreJSONMessage, rootDoc)) var tgt Schema ref, err := NewRef("#/definitions/Category") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, "")) assert.Equal(t, "Category", tgt.ID) } func TestResolveLocalRef_FromInvalidFragment(t testing.T) { rootDoc := new(Swagger) require.NoError(t, json.Unmarshal(PetStoreJSONMessage, rootDoc)) var tgt Schema ref, err := NewRef("#/definitions/NotThere") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.Error(t, resolver.Resolve(&ref, &tgt, "")) } func TestResolveLocalRef_Parameter(t testing.T) { rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) basePath := filepath.Join(specs, "refed.json") require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt Parameter ref, err := NewRef("#/parameters/idParam") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, basePath)) assert.Equal(t, "id", tgt.Name) assert.Equal(t, "path", tgt.In) assert.Equal(t, "ID of pet to fetch", tgt.Description) assert.True(t, tgt.Required) assert.Equal(t, "integer", tgt.Type) assert.Equal(t, "int64", tgt.Format) } func TestResolveLocalRef_PathItem(t testing.T) { rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) basePath := filepath.Join(specs, "refed.json") require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt PathItem ref, err := NewRef("#/paths/" + jsonpointer.Escape("/pets/{id}")) require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, basePath)) assert.Equal(t, rootDoc.Paths.Paths["/pets/{id}"].Get, tgt.Get) } func TestResolveLocalRef_Response(t testing.T) { rootDoc := new(Swagger) b, err := os.ReadFile(filepath.Join(specs, "refed.json")) require.NoError(t, err) basePath := filepath.Join(specs, "refed.json") require.NoError(t, json.Unmarshal(b, rootDoc)) var tgt Response ref, err := NewRef("#/responses/petResponse") require.NoError(t, err) resolver := defaultSchemaLoader(rootDoc, nil, nil, nil) require.NoError(t, resolver.Resolve(&ref, &tgt, basePath)) assert.Equal(t, rootDoc.Responses["petResponse"], tgt) } func TestResolvePathItem(t testing.T) { spec := new(Swagger) specDoc, err := jsonDoc(pathItemsFixture) require.NoError(t, err) require.NoError(t, json.Unmarshal(specDoc, spec)) // Resolve use case pth := spec.Paths.Paths["/todos"] pathItem, err := ResolvePathItem(spec, pth.Ref, &ExpandOptions{RelativeBase: pathItemsFixture}) require.NoError(t, err) jazon := asJSON(t, pathItem) assert.JSONEq(t, `{ "get": { "responses": { "200": { "description": "List Todos", "schema": { "type": "array", "items": { "type": "string" } } }, "404": { "description": "error" } } } }`, jazon) } func TestResolveExtraItem(t *testing.T) { // go-openapi extra goodie: $ref in simple schema Items and Headers spec := new(Swagger) specDoc, err := jsonDoc(extraRefFixture) require.NoError(t, err) require.NoError(t, json.Unmarshal(specDoc, spec)) // Resolve param Items use case: here we explicitly resolve the unsuppord case parm := spec.Paths.Paths["/employees"].Get.Parameters[0] parmItem, err := ResolveItems(spec, parm.Items.Ref, &ExpandOptions{RelativeBase: extraRefFixture}) require.NoError(t, err) jazon := asJSON(t, parmItem) assert.JSONEq(t, `{ "type": "integer", "format": "int32" }`, jazon) // Resolve header Items use case: here we explicitly resolve the unsuppord case hdr := spec.Paths.Paths["/employees"].Get.Responses.StatusCodeResponses[200].Headers["X-header"] hdrItem, err := ResolveItems(spec, hdr.Items.Ref, &ExpandOptions{RelativeBase: extraRefFixture}) require.NoError(t, err) jazon = asJSON(t, hdrItem) assert.JSONEq(t, `{ "type": "string", "format": "uuid" }`, jazon) }	12.75 KB	2025-05-25 12:27
📄 response.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 spec import ( "encoding/json" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // ResponseProps properties specific to a response type ResponseProps struct { Description string `json:"description"` Schema Schema `json:"schema,omitempty"` Headers map[string]Header `json:"headers,omitempty"` Examples map[string]interface{} `json:"examples,omitempty"` } // Response describes a single response from an API Operation. // // For more information: http://goo.gl/8us55a#responseObject type Response struct { Refable ResponseProps VendorExtensible } // JSONLookup look up a value by the json property name func (r Response) JSONLookup(token string) (interface{}, error) { if ex, ok := r.Extensions[token]; ok { return &ex, nil } if token == "$ref" { return &r.Ref, nil } ptr, _, err := jsonpointer.GetForToken(r.ResponseProps, token) return ptr, err } // UnmarshalJSON hydrates this items instance with the data from JSON func (r Response) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &r.ResponseProps); err != nil { return err } if err := json.Unmarshal(data, &r.Refable); err != nil { return err } return json.Unmarshal(data, &r.VendorExtensible) } // MarshalJSON converts this items object to JSON func (r Response) MarshalJSON() ([]byte, error) { var ( b1 []byte err error ) if r.Ref.String() == "" { // when there is no $ref, empty description is rendered as an empty string b1, err = json.Marshal(r.ResponseProps) } else { // when there is $ref inside the schema, description should be omitempty-ied b1, err = json.Marshal(struct { Description string `json:"description,omitempty"` Schema Schema `json:"schema,omitempty"` Headers map[string]Header `json:"headers,omitempty"` Examples map[string]interface{} `json:"examples,omitempty"` }{ Description: r.ResponseProps.Description, Schema: r.ResponseProps.Schema, Examples: r.ResponseProps.Examples, }) } if err != nil { return nil, err } b2, err := json.Marshal(r.Refable) if err != nil { return nil, err } b3, err := json.Marshal(r.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2, b3), nil } // NewResponse creates a new response instance func NewResponse() Response { return new(Response) } // ResponseRef creates a response as a json reference func ResponseRef(url string) Response { resp := NewResponse() resp.Ref = MustCreateRef(url) return resp } // WithDescription sets the description on this response, allows for chaining func (r Response) WithDescription(description string) Response { r.Description = description return r } // WithSchema sets the schema on this response, allows for chaining. // Passing a nil argument removes the schema from this response func (r Response) WithSchema(schema Schema) Response { r.Schema = schema return r } // AddHeader adds a header to this response func (r Response) AddHeader(name string, header Header) Response { if header == nil { return r.RemoveHeader(name) } if r.Headers == nil { r.Headers = make(map[string]Header) } r.Headers[name] = header return r } // RemoveHeader removes a header from this response func (r Response) RemoveHeader(name string) Response { delete(r.Headers, name) return r } // AddExample adds an example to this response func (r Response) AddExample(mediaType string, example interface{}) Response { if r.Examples == nil { r.Examples = make(map[string]interface{}) } r.Examples[mediaType] = example return r }	4.17 KB	2025-05-25 12:27
📄 response_test.go // Copyright 2017 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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var response = Response{ Refable: Refable{Ref: MustCreateRef("Dog")}, VendorExtensible: VendorExtensible{ Extensions: map[string]interface{}{ "x-go-name": "PutDogExists", }, }, ResponseProps: ResponseProps{ Description: "Dog exists", Schema: &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}, }, } const responseJSON = `{ "$ref": "Dog", "x-go-name": "PutDogExists", "description": "Dog exists", "schema": { "type": "string" } }` func TestIntegrationResponse(t testing.T) { var actual Response require.NoError(t, json.Unmarshal([]byte(responseJSON), &actual)) assert.EqualValues(t, actual, response) assertParsesJSON(t, responseJSON, response) } func TestJSONLookupResponse(t testing.T) { res, err := response.JSONLookup("$ref") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, &Ref{}, res) var ok bool ref, ok := res.(Ref) require.True(t, ok) assert.EqualValues(t, MustCreateRef("Dog"), ref) var def string res, err = response.JSONLookup("description") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, def, res) def, ok = res.(string) require.True(t, ok) assert.Equal(t, "Dog exists", def) var x interface{} res, err = response.JSONLookup("x-go-name") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, x, res) x, ok = res.(interface{}) require.True(t, ok) assert.EqualValues(t, "PutDogExists", x) res, err = response.JSONLookup("unknown") require.Error(t, err) require.Nil(t, res) } func TestResponseBuild(t testing.T) { resp := NewResponse(). WithDescription("some response"). WithSchema(new(Schema).Typed("object", "")). AddHeader("x-header", ResponseHeader().Typed("string", "")). AddExample("application/json", `{"key":"value"}`) jazon, err := json.MarshalIndent(resp, "", " ") require.NoError(t, err) assert.JSONEq(t, `{ "description": "some response", "schema": { "type": "object" }, "headers": { "x-header": { "type": "string" } }, "examples": { "application/json": "{\"key\":\"value\"}" } }`, string(jazon)) }	2.85 KB	2025-05-25 12:27
📄 responses.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 spec import ( "encoding/json" "fmt" "reflect" "strconv" "strings" "github.com/go-openapi/swag" ) // Responses is a container for the expected responses of an operation. // The container maps a HTTP response code to the expected response. // It is not expected from the documentation to necessarily cover all possible HTTP response codes, // since they may not be known in advance. However, it is expected from the documentation to cover // a successful operation response and any known errors. // // The `default` can be used a default response object for all HTTP codes that are not covered // individually by the specification. // // The `Responses Object` MUST contain at least one response code, and it SHOULD be the response // for a successful operation call. // // For more information: http://goo.gl/8us55a#responsesObject type Responses struct { VendorExtensible ResponsesProps } // JSONLookup implements an interface to customize json pointer lookup func (r Responses) JSONLookup(token string) (interface{}, error) { if token == "default" { return r.Default, nil } if ex, ok := r.Extensions[token]; ok { return &ex, nil } if i, err := strconv.Atoi(token); err == nil { if scr, ok := r.StatusCodeResponses[i]; ok { return scr, nil } } return nil, fmt.Errorf("object has no field %q", token) } // UnmarshalJSON hydrates this items instance with the data from JSON func (r Responses) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &r.ResponsesProps); err != nil { return err } if err := json.Unmarshal(data, &r.VendorExtensible); err != nil { return err } if reflect.DeepEqual(ResponsesProps{}, r.ResponsesProps) { r.ResponsesProps = ResponsesProps{} } return nil } // MarshalJSON converts this items object to JSON func (r Responses) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(r.ResponsesProps) if err != nil { return nil, err } b2, err := json.Marshal(r.VendorExtensible) if err != nil { return nil, err } concated := swag.ConcatJSON(b1, b2) return concated, nil } // ResponsesProps describes all responses for an operation. // It tells what is the default response and maps all responses with a // HTTP status code. type ResponsesProps struct { Default Response StatusCodeResponses map[int]Response } // MarshalJSON marshals responses as JSON func (r ResponsesProps) MarshalJSON() ([]byte, error) { toser := map[string]Response{} if r.Default != nil { toser["default"] = r.Default } for k, v := range r.StatusCodeResponses { toser[strconv.Itoa(k)] = v } return json.Marshal(toser) } // UnmarshalJSON unmarshals responses from JSON func (r ResponsesProps) UnmarshalJSON(data []byte) error { var res map[string]json.RawMessage if err := json.Unmarshal(data, &res); err != nil { return err } if v, ok := res["default"]; ok { var defaultRes Response if err := json.Unmarshal(v, &defaultRes); err != nil { return err } r.Default = &defaultRes delete(res, "default") } for k, v := range res { if !strings.HasPrefix(k, "x-") { var statusCodeResp Response if err := json.Unmarshal(v, &statusCodeResp); err != nil { return err } if nk, err := strconv.Atoi(k); err == nil { if r.StatusCodeResponses == nil { r.StatusCodeResponses = map[int]Response{} } r.StatusCodeResponses[nk] = statusCodeResp } } } return nil }	3.91 KB	2025-05-25 12:27
📄 responses_test.go // Copyright 2017 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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var responses = Responses{ VendorExtensible: VendorExtensible{ Extensions: map[string]interface{}{ "x-go-name": "PutDogExists", }, }, ResponsesProps: ResponsesProps{ StatusCodeResponses: map[int]Response{ 200: { Refable: Refable{Ref: MustCreateRef("Dog")}, VendorExtensible: VendorExtensible{ Extensions: map[string]interface{}{ "x-go-name": "PutDogExists", }, }, ResponseProps: ResponseProps{ Description: "Dog exists", Schema: &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}, }, }, }, }, } const responsesJSON = `{ "x-go-name": "PutDogExists", "200": { "$ref": "Dog", "x-go-name": "PutDogExists", "description": "Dog exists", "schema": { "type": "string" } } }` func TestIntegrationResponses(t testing.T) { var actual Responses require.NoError(t, json.Unmarshal([]byte(responsesJSON), &actual)) assert.EqualValues(t, actual, responses) assertParsesJSON(t, responsesJSON, responses) } func TestJSONLookupResponses(t testing.T) { resp200, ok := responses.StatusCodeResponses[200] require.True(t, ok) res, err := resp200.JSONLookup("$ref") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, &Ref{}, res) ref, ok := res.(Ref) require.True(t, ok) assert.EqualValues(t, MustCreateRef("Dog"), ref) var def string res, err = resp200.JSONLookup("description") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, def, res) def, ok = res.(string) require.True(t, ok) assert.Equal(t, "Dog exists", def) var x interface{} res, err = responses.JSONLookup("x-go-name") require.NoError(t, err) require.NotNil(t, res) require.IsType(t, x, res) x, ok = res.(interface{}) require.True(t, ok) assert.EqualValues(t, "PutDogExists", x) res, err = responses.JSONLookup("unknown") require.Error(t, err) require.Nil(t, res) } func TestResponsesBuild(t testing.T) { resp := NewResponse(). WithDescription("some response"). WithSchema(new(Schema).Typed("object", "")). AddHeader("x-header", ResponseHeader().Typed("string", "")). AddExample("application/json", `{"key":"value"}`) jazon, _ := json.MarshalIndent(resp, "", " ") assert.JSONEq(t, `{ "description": "some response", "schema": { "type": "object" }, "headers": { "x-header": { "type": "string" } }, "examples": { "application/json": "{\"key\":\"value\"}" } }`, string(jazon)) }	3.18 KB	2025-05-25 12:27
📄 schema.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 spec import ( "encoding/json" "fmt" "strings" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // BooleanProperty creates a boolean property func BooleanProperty() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"boolean"}}} } // BoolProperty creates a boolean property func BoolProperty() Schema { return BooleanProperty() } // StringProperty creates a string property func StringProperty() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}} } // CharProperty creates a string property func CharProperty() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}} } // Float64Property creates a float64/double property func Float64Property() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "double"}} } // Float32Property creates a float32/float property func Float32Property() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"number"}, Format: "float"}} } // Int8Property creates an int8 property func Int8Property() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int8"}} } // Int16Property creates an int16 property func Int16Property() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int16"}} } // Int32Property creates an int32 property func Int32Property() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int32"}} } // Int64Property creates an int64 property func Int64Property() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}} } // StrFmtProperty creates a property for the named string format func StrFmtProperty(format string) Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: format}} } // DateProperty creates a date property func DateProperty() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date"}} } // DateTimeProperty creates a date time property func DateTimeProperty() Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"string"}, Format: "date-time"}} } // MapProperty creates a map property func MapProperty(property Schema) Schema { return &Schema{SchemaProps: SchemaProps{Type: []string{"object"}, AdditionalProperties: &SchemaOrBool{Allows: true, Schema: property}}} } // RefProperty creates a ref property func RefProperty(name string) Schema { return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}} } // RefSchema creates a ref property func RefSchema(name string) Schema { return &Schema{SchemaProps: SchemaProps{Ref: MustCreateRef(name)}} } // ArrayProperty creates an array property func ArrayProperty(items Schema) Schema { if items == nil { return &Schema{SchemaProps: SchemaProps{Type: []string{"array"}}} } return &Schema{SchemaProps: SchemaProps{Items: &SchemaOrArray{Schema: items}, Type: []string{"array"}}} } // ComposedSchema creates a schema with allOf func ComposedSchema(schemas ...Schema) Schema { s := new(Schema) s.AllOf = schemas return s } // SchemaURL represents a schema url type SchemaURL string // MarshalJSON marshal this to JSON func (r SchemaURL) MarshalJSON() ([]byte, error) { if r == "" { return []byte("{}"), nil } v := map[string]interface{}{"$schema": string(r)} return json.Marshal(v) } // UnmarshalJSON unmarshal this from JSON func (r SchemaURL) UnmarshalJSON(data []byte) error { var v map[string]interface{} if err := json.Unmarshal(data, &v); err != nil { return err } return r.fromMap(v) } func (r SchemaURL) fromMap(v map[string]interface{}) error { if v == nil { return nil } if vv, ok := v["$schema"]; ok { if str, ok := vv.(string); ok { u, err := parseURL(str) if err != nil { return err } r = SchemaURL(u.String()) } } return nil } // SchemaProps describes a JSON schema (draft 4) type SchemaProps struct { ID string `json:"id,omitempty"` Ref Ref `json:"-"` Schema SchemaURL `json:"-"` Description string `json:"description,omitempty"` Type StringOrArray `json:"type,omitempty"` Nullable bool `json:"nullable,omitempty"` Format string `json:"format,omitempty"` Title string `json:"title,omitempty"` Default interface{} `json:"default,omitempty"` Maximum float64 `json:"maximum,omitempty"` ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"` Minimum float64 `json:"minimum,omitempty"` ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"` MaxLength int64 `json:"maxLength,omitempty"` MinLength int64 `json:"minLength,omitempty"` Pattern string `json:"pattern,omitempty"` MaxItems int64 `json:"maxItems,omitempty"` MinItems int64 `json:"minItems,omitempty"` UniqueItems bool `json:"uniqueItems,omitempty"` MultipleOf float64 `json:"multipleOf,omitempty"` Enum []interface{} `json:"enum,omitempty"` MaxProperties int64 `json:"maxProperties,omitempty"` MinProperties int64 `json:"minProperties,omitempty"` Required []string `json:"required,omitempty"` Items SchemaOrArray `json:"items,omitempty"` AllOf []Schema `json:"allOf,omitempty"` OneOf []Schema `json:"oneOf,omitempty"` AnyOf []Schema `json:"anyOf,omitempty"` Not Schema `json:"not,omitempty"` Properties SchemaProperties `json:"properties,omitempty"` AdditionalProperties SchemaOrBool `json:"additionalProperties,omitempty"` PatternProperties SchemaProperties `json:"patternProperties,omitempty"` Dependencies Dependencies `json:"dependencies,omitempty"` AdditionalItems SchemaOrBool `json:"additionalItems,omitempty"` Definitions Definitions `json:"definitions,omitempty"` } // SwaggerSchemaProps are additional properties supported by swagger schemas, but not JSON-schema (draft 4) type SwaggerSchemaProps struct { Discriminator string `json:"discriminator,omitempty"` ReadOnly bool `json:"readOnly,omitempty"` XML XMLObject `json:"xml,omitempty"` ExternalDocs ExternalDocumentation `json:"externalDocs,omitempty"` Example interface{} `json:"example,omitempty"` } // Schema the schema object allows the definition of input and output data types. // These types can be objects, but also primitives and arrays. // This object is based on the [JSON Schema Specification Draft 4](http://json-schema.org/) // and uses a predefined subset of it. // On top of this subset, there are extensions provided by this specification to allow for more complete documentation. // // For more information: http://goo.gl/8us55a#schemaObject type Schema struct { VendorExtensible SchemaProps SwaggerSchemaProps ExtraProps map[string]interface{} `json:"-"` } // JSONLookup implements an interface to customize json pointer lookup func (s Schema) JSONLookup(token string) (interface{}, error) { if ex, ok := s.Extensions[token]; ok { return &ex, nil } if ex, ok := s.ExtraProps[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(s.SchemaProps, token) if r != nil \|\| (err != nil && !strings.HasPrefix(err.Error(), "object has no field")) { return r, err } r, _, err = jsonpointer.GetForToken(s.SwaggerSchemaProps, token) return r, err } // WithID sets the id for this schema, allows for chaining func (s Schema) WithID(id string) Schema { s.ID = id return s } // WithTitle sets the title for this schema, allows for chaining func (s Schema) WithTitle(title string) Schema { s.Title = title return s } // WithDescription sets the description for this schema, allows for chaining func (s Schema) WithDescription(description string) Schema { s.Description = description return s } // WithProperties sets the properties for this schema func (s Schema) WithProperties(schemas map[string]Schema) Schema { s.Properties = schemas return s } // SetProperty sets a property on this schema func (s Schema) SetProperty(name string, schema Schema) Schema { if s.Properties == nil { s.Properties = make(map[string]Schema) } s.Properties[name] = schema return s } // WithAllOf sets the all of property func (s Schema) WithAllOf(schemas ...Schema) Schema { s.AllOf = schemas return s } // WithMaxProperties sets the max number of properties an object can have func (s Schema) WithMaxProperties(max int64) Schema { s.MaxProperties = &max return s } // WithMinProperties sets the min number of properties an object must have func (s Schema) WithMinProperties(min int64) Schema { s.MinProperties = &min return s } // Typed sets the type of this schema for a single value item func (s Schema) Typed(tpe, format string) Schema { s.Type = []string{tpe} s.Format = format return s } // AddType adds a type with potential format to the types for this schema func (s Schema) AddType(tpe, format string) Schema { s.Type = append(s.Type, tpe) if format != "" { s.Format = format } return s } // AsNullable flags this schema as nullable. func (s Schema) AsNullable() Schema { s.Nullable = true return s } // CollectionOf a fluent builder method for an array parameter func (s Schema) CollectionOf(items Schema) Schema { s.Type = []string{jsonArray} s.Items = &SchemaOrArray{Schema: &items} return s } // WithDefault sets the default value on this parameter func (s Schema) WithDefault(defaultValue interface{}) Schema { s.Default = defaultValue return s } // WithRequired flags this parameter as required func (s Schema) WithRequired(items ...string) Schema { s.Required = items return s } // AddRequired adds field names to the required properties array func (s Schema) AddRequired(items ...string) Schema { s.Required = append(s.Required, items...) return s } // WithMaxLength sets a max length value func (s Schema) WithMaxLength(max int64) Schema { s.MaxLength = &max return s } // WithMinLength sets a min length value func (s Schema) WithMinLength(min int64) Schema { s.MinLength = &min return s } // WithPattern sets a pattern value func (s Schema) WithPattern(pattern string) Schema { s.Pattern = pattern return s } // WithMultipleOf sets a multiple of value func (s Schema) WithMultipleOf(number float64) Schema { s.MultipleOf = &number return s } // WithMaximum sets a maximum number value func (s Schema) WithMaximum(max float64, exclusive bool) Schema { s.Maximum = &max s.ExclusiveMaximum = exclusive return s } // WithMinimum sets a minimum number value func (s Schema) WithMinimum(min float64, exclusive bool) Schema { s.Minimum = &min s.ExclusiveMinimum = exclusive return s } // WithEnum sets a the enum values (replace) func (s Schema) WithEnum(values ...interface{}) Schema { s.Enum = append([]interface{}{}, values...) return s } // WithMaxItems sets the max items func (s Schema) WithMaxItems(size int64) Schema { s.MaxItems = &size return s } // WithMinItems sets the min items func (s Schema) WithMinItems(size int64) Schema { s.MinItems = &size return s } // UniqueValues dictates that this array can only have unique items func (s Schema) UniqueValues() Schema { s.UniqueItems = true return s } // AllowDuplicates this array can have duplicates func (s Schema) AllowDuplicates() Schema { s.UniqueItems = false return s } // AddToAllOf adds a schema to the allOf property func (s Schema) AddToAllOf(schemas ...Schema) Schema { s.AllOf = append(s.AllOf, schemas...) return s } // WithDiscriminator sets the name of the discriminator field func (s Schema) WithDiscriminator(discriminator string) Schema { s.Discriminator = discriminator return s } // AsReadOnly flags this schema as readonly func (s Schema) AsReadOnly() Schema { s.ReadOnly = true return s } // AsWritable flags this schema as writeable (not read-only) func (s Schema) AsWritable() Schema { s.ReadOnly = false return s } // WithExample sets the example for this schema func (s Schema) WithExample(example interface{}) Schema { s.Example = example return s } // WithExternalDocs sets/removes the external docs for/from this schema. // When you pass empty strings as params the external documents will be removed. // When you pass non-empty string as one value then those values will be used on the external docs object. // So when you pass a non-empty description, you should also pass the url and vice versa. func (s Schema) WithExternalDocs(description, url string) Schema { if description == "" && url == "" { s.ExternalDocs = nil return s } if s.ExternalDocs == nil { s.ExternalDocs = &ExternalDocumentation{} } s.ExternalDocs.Description = description s.ExternalDocs.URL = url return s } // WithXMLName sets the xml name for the object func (s Schema) WithXMLName(name string) Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Name = name return s } // WithXMLNamespace sets the xml namespace for the object func (s Schema) WithXMLNamespace(namespace string) Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Namespace = namespace return s } // WithXMLPrefix sets the xml prefix for the object func (s Schema) WithXMLPrefix(prefix string) Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Prefix = prefix return s } // AsXMLAttribute flags this object as xml attribute func (s Schema) AsXMLAttribute() Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Attribute = true return s } // AsXMLElement flags this object as an xml node func (s Schema) AsXMLElement() Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Attribute = false return s } // AsWrappedXML flags this object as wrapped, this is mostly useful for array types func (s Schema) AsWrappedXML() Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Wrapped = true return s } // AsUnwrappedXML flags this object as an xml node func (s Schema) AsUnwrappedXML() Schema { if s.XML == nil { s.XML = new(XMLObject) } s.XML.Wrapped = false return s } // SetValidations defines all schema validations. // // NOTE: Required, ReadOnly, AllOf, AnyOf, OneOf and Not are not considered. func (s Schema) SetValidations(val SchemaValidations) { s.Maximum = val.Maximum s.ExclusiveMaximum = val.ExclusiveMaximum s.Minimum = val.Minimum s.ExclusiveMinimum = val.ExclusiveMinimum s.MaxLength = val.MaxLength s.MinLength = val.MinLength s.Pattern = val.Pattern s.MaxItems = val.MaxItems s.MinItems = val.MinItems s.UniqueItems = val.UniqueItems s.MultipleOf = val.MultipleOf s.Enum = val.Enum s.MinProperties = val.MinProperties s.MaxProperties = val.MaxProperties s.PatternProperties = val.PatternProperties } // WithValidations is a fluent method to set schema validations func (s Schema) WithValidations(val SchemaValidations) Schema { s.SetValidations(val) return s } // Validations returns a clone of the validations for this schema func (s Schema) Validations() SchemaValidations { return SchemaValidations{ CommonValidations: CommonValidations{ Maximum: s.Maximum, ExclusiveMaximum: s.ExclusiveMaximum, Minimum: s.Minimum, ExclusiveMinimum: s.ExclusiveMinimum, MaxLength: s.MaxLength, MinLength: s.MinLength, Pattern: s.Pattern, MaxItems: s.MaxItems, MinItems: s.MinItems, UniqueItems: s.UniqueItems, MultipleOf: s.MultipleOf, Enum: s.Enum, }, MinProperties: s.MinProperties, MaxProperties: s.MaxProperties, PatternProperties: s.PatternProperties, } } // MarshalJSON marshal this to JSON func (s Schema) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(s.SchemaProps) if err != nil { return nil, fmt.Errorf("schema props %v", err) } b2, err := json.Marshal(s.VendorExtensible) if err != nil { return nil, fmt.Errorf("vendor props %v", err) } b3, err := s.Ref.MarshalJSON() if err != nil { return nil, fmt.Errorf("ref prop %v", err) } b4, err := s.Schema.MarshalJSON() if err != nil { return nil, fmt.Errorf("schema prop %v", err) } b5, err := json.Marshal(s.SwaggerSchemaProps) if err != nil { return nil, fmt.Errorf("common validations %v", err) } var b6 []byte if s.ExtraProps != nil { jj, err := json.Marshal(s.ExtraProps) if err != nil { return nil, fmt.Errorf("extra props %v", err) } b6 = jj } return swag.ConcatJSON(b1, b2, b3, b4, b5, b6), nil } // UnmarshalJSON marshal this from JSON func (s Schema) UnmarshalJSON(data []byte) error { props := struct { SchemaProps SwaggerSchemaProps }{} if err := json.Unmarshal(data, &props); err != nil { return err } sch := Schema{ SchemaProps: props.SchemaProps, SwaggerSchemaProps: props.SwaggerSchemaProps, } var d map[string]interface{} if err := json.Unmarshal(data, &d); err != nil { return err } _ = sch.Ref.fromMap(d) _ = sch.Schema.fromMap(d) delete(d, "$ref") delete(d, "$schema") for _, pn := range swag.DefaultJSONNameProvider.GetJSONNames(s) { delete(d, pn) } for k, vv := range d { lk := strings.ToLower(k) if strings.HasPrefix(lk, "x-") { if sch.Extensions == nil { sch.Extensions = map[string]interface{}{} } sch.Extensions[k] = vv continue } if sch.ExtraProps == nil { sch.ExtraProps = map[string]interface{}{} } sch.ExtraProps[k] = vv } *s = sch return nil }	18.14 KB	2025-05-25 12:27
📄 schema_loader.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 spec import ( "encoding/json" "fmt" "log" "net/url" "reflect" "strings" "github.com/go-openapi/swag" ) // PathLoader is a function to use when loading remote refs. // // This is a package level default. It may be overridden or bypassed by // specifying the loader in ExpandOptions. // // NOTE: if you are using the go-openapi/loads package, it will override // this value with its own default (a loader to retrieve YAML documents as // well as JSON ones). var PathLoader = func(pth string) (json.RawMessage, error) { data, err := swag.LoadFromFileOrHTTP(pth) if err != nil { return nil, err } return json.RawMessage(data), nil } // resolverContext allows to share a context during spec processing. // At the moment, it just holds the index of circular references found. type resolverContext struct { // circulars holds all visited circular references, to shortcircuit $ref resolution. // // This structure is privately instantiated and needs not be locked against // concurrent access, unless we chose to implement a parallel spec walking. circulars map[string]bool basePath string loadDoc func(string) (json.RawMessage, error) rootID string } func newResolverContext(options ExpandOptions) resolverContext { expandOptions := optionsOrDefault(options) // path loader may be overridden by options var loader func(string) (json.RawMessage, error) if expandOptions.PathLoader == nil { loader = PathLoader } else { loader = expandOptions.PathLoader } return &resolverContext{ circulars: make(map[string]bool), basePath: expandOptions.RelativeBase, // keep the root base path in context loadDoc: loader, } } type schemaLoader struct { root interface{} options ExpandOptions cache ResolutionCache context resolverContext } func (r schemaLoader) transitiveResolver(basePath string, ref Ref) schemaLoader { if ref.IsRoot() \|\| ref.HasFragmentOnly { return r } baseRef := MustCreateRef(basePath) currentRef := normalizeRef(&ref, basePath) if strings.HasPrefix(currentRef.String(), baseRef.String()) { return r } // set a new root against which to resolve rootURL := currentRef.GetURL() rootURL.Fragment = "" root, _ := r.cache.Get(rootURL.String()) // shallow copy of resolver options to set a new RelativeBase when // traversing multiple documents newOptions := r.options newOptions.RelativeBase = rootURL.String() return defaultSchemaLoader(root, newOptions, r.cache, r.context) } func (r schemaLoader) updateBasePath(transitive schemaLoader, basePath string) string { if transitive != r { if transitive.options != nil && transitive.options.RelativeBase != "" { return normalizeBase(transitive.options.RelativeBase) } } return basePath } func (r schemaLoader) resolveRef(ref Ref, target interface{}, basePath string) error { tgt := reflect.ValueOf(target) if tgt.Kind() != reflect.Ptr { return ErrResolveRefNeedsAPointer } if ref.GetURL() == nil { return nil } var ( res interface{} data interface{} err error ) // Resolve against the root if it isn't nil, and if ref is pointing at the root, or has a fragment only which means // it is pointing somewhere in the root. root := r.root if (ref.IsRoot() \|\| ref.HasFragmentOnly) && root == nil && basePath != "" { if baseRef, erb := NewRef(basePath); erb == nil { root, _, _, _ = r.load(baseRef.GetURL()) } } if (ref.IsRoot() \|\| ref.HasFragmentOnly) && root != nil { data = root } else { baseRef := normalizeRef(ref, basePath) data, _, _, err = r.load(baseRef.GetURL()) if err != nil { return err } } res = data if ref.String() != "" { res, _, err = ref.GetPointer().Get(data) if err != nil { return err } } return swag.DynamicJSONToStruct(res, target) } func (r schemaLoader) load(refURL url.URL) (interface{}, url.URL, bool, error) { debugLog("loading schema from url: %s", refURL) toFetch := refURL toFetch.Fragment = "" var err error pth := toFetch.String() normalized := normalizeBase(pth) debugLog("loading doc from: %s", normalized) data, fromCache := r.cache.Get(normalized) if fromCache { return data, toFetch, fromCache, nil } b, err := r.context.loadDoc(normalized) if err != nil { return nil, url.URL{}, false, err } var doc interface{} if err := json.Unmarshal(b, &doc); err != nil { return nil, url.URL{}, false, err } r.cache.Set(normalized, doc) return doc, toFetch, fromCache, nil } // isCircular detects cycles in sequences of $ref. // // It relies on a private context (which needs not be locked). func (r schemaLoader) isCircular(ref Ref, basePath string, parentRefs ...string) (foundCycle bool) { normalizedRef := normalizeURI(ref.String(), basePath) if _, ok := r.context.circulars[normalizedRef]; ok { // circular $ref has been already detected in another explored cycle foundCycle = true return } foundCycle = swag.ContainsStrings(parentRefs, normalizedRef) // normalized windows url's are lower cased if foundCycle { r.context.circulars[normalizedRef] = true } return } // Resolve resolves a reference against basePath and stores the result in target. // // Resolve is not in charge of following references: it only resolves ref by following its URL. // // If the schema the ref is referring to holds nested refs, Resolve doesn't resolve them. // // If basePath is an empty string, ref is resolved against the root schema stored in the schemaLoader struct func (r schemaLoader) Resolve(ref Ref, target interface{}, basePath string) error { return r.resolveRef(ref, target, basePath) } func (r schemaLoader) deref(input interface{}, parentRefs []string, basePath string) error { var ref Ref switch refable := input.(type) { case Schema: ref = &refable.Ref case Parameter: ref = &refable.Ref case Response: ref = &refable.Ref case PathItem: ref = &refable.Ref default: return fmt.Errorf("unsupported type: %T: %w", input, ErrDerefUnsupportedType) } curRef := ref.String() if curRef == "" { return nil } normalizedRef := normalizeRef(ref, basePath) normalizedBasePath := normalizedRef.RemoteURI() if r.isCircular(normalizedRef, basePath, parentRefs...) { return nil } if err := r.resolveRef(ref, input, basePath); r.shouldStopOnError(err) { return err } if ref.String() == "" \|\| ref.String() == curRef { // done with rereferencing return nil } parentRefs = append(parentRefs, normalizedRef.String()) return r.deref(input, parentRefs, normalizedBasePath) } func (r schemaLoader) shouldStopOnError(err error) bool { if err != nil && !r.options.ContinueOnError { return true } if err != nil { log.Println(err) } return false } func (r schemaLoader) setSchemaID(target interface{}, id, basePath string) (string, string) { debugLog("schema has ID: %s", id) // handling the case when id is a folder // remember that basePath has to point to a file var refPath string if strings.HasSuffix(id, "/") { // ensure this is detected as a file, not a folder refPath = fmt.Sprintf("%s%s", id, "placeholder.json") } else { refPath = id } // updates the current base path // important: ID can be a relative path // * registers target to be fetchable from the new base proposed by this id newBasePath := normalizeURI(refPath, basePath) // store found IDs for possible future reuse in $ref r.cache.Set(newBasePath, target) // the root document has an ID: all $ref relative to that ID may // be rebased relative to the root document if basePath == r.context.basePath { debugLog("root document is a schema with ID: %s (normalized as:%s)", id, newBasePath) r.context.rootID = newBasePath } return newBasePath, refPath } func defaultSchemaLoader( root interface{}, expandOptions ExpandOptions, cache ResolutionCache, context resolverContext) *schemaLoader { if expandOptions == nil { expandOptions = &ExpandOptions{} } cache = cacheOrDefault(cache) if expandOptions.RelativeBase == "" { // if no relative base is provided, assume the root document // contains all $ref, or at least, that the relative documents // may be resolved from the current working directory. expandOptions.RelativeBase = baseForRoot(root, cache) } debugLog("effective expander options: %#v", expandOptions) if context == nil { context = newResolverContext(expandOptions) } return &schemaLoader{ root: root, options: expandOptions, cache: cache, context: context, } }	8.86 KB	2025-05-25 12:27
📄 schema_loader_test.go package spec import ( "encoding/json" "path/filepath" "testing" "github.com/stretchr/testify/require" ) func TestLoader_Issue145(t testing.T) { t.Run("with ExpandSpec", func(t testing.T) { basePath := filepath.Join("fixtures", "bugs", "145", "Program Files (x86)", "AppName", "todos.json") todosDoc, err := jsonDoc(basePath) require.NoError(t, err) spec := new(Swagger) require.NoError(t, json.Unmarshal(todosDoc, spec)) require.NoError(t, ExpandSpec(spec, &ExpandOptions{RelativeBase: basePath})) }) t.Run("with ExpandSchema", func(t *testing.T) { basePath := filepath.Join("fixtures", "bugs", "145", "Program Files (x86)", "AppName", "ref.json") schemaDoc, err := jsonDoc(basePath) require.NoError(t, err) sch := new(Schema) require.NoError(t, json.Unmarshal(schemaDoc, sch)) require.NoError(t, ExpandSchema(sch, nil, nil)) }) }	873 B	2025-05-25 12:27
📄 schema_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 spec import ( "encoding/json" "testing" "github.com/go-openapi/swag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var schema = Schema{ VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{"x-framework": "go-swagger"}}, SchemaProps: SchemaProps{ Ref: MustCreateRef("Cat"), Type: []string{"string"}, Format: "date", Description: "the description of this schema", Title: "the title", Default: "blah", Maximum: float64Ptr(100), ExclusiveMaximum: true, ExclusiveMinimum: true, Minimum: float64Ptr(5), MaxLength: int64Ptr(100), MinLength: int64Ptr(5), Pattern: "\\w{1,5}\\w+", MaxItems: int64Ptr(100), MinItems: int64Ptr(5), UniqueItems: true, MultipleOf: float64Ptr(5), Enum: []interface{}{"hello", "world"}, MaxProperties: int64Ptr(5), MinProperties: int64Ptr(1), Required: []string{"id", "name"}, Items: &SchemaOrArray{Schema: &Schema{SchemaProps: SchemaProps{Type: []string{"string"}}}}, AllOf: []Schema{{SchemaProps: SchemaProps{Type: []string{"string"}}}}, Properties: map[string]Schema{ "id": {SchemaProps: SchemaProps{Type: []string{"integer"}, Format: "int64"}}, "name": {SchemaProps: SchemaProps{Type: []string{"string"}}}, }, AdditionalProperties: &SchemaOrBool{Allows: true, Schema: &Schema{SchemaProps: SchemaProps{ Type: []string{"integer"}, Format: "int32", }}}, }, SwaggerSchemaProps: SwaggerSchemaProps{ Discriminator: "not this", ReadOnly: true, XML: &XMLObject{Name: "sch", Namespace: "io", Prefix: "sw", Attribute: true, Wrapped: true}, ExternalDocs: &ExternalDocumentation{ Description: "the documentation etc", URL: "http://readthedocs.org/swagger", }, Example: []interface{}{ map[string]interface{}{ "id": 1, "name": "a book", }, map[string]interface{}{ "id": 2, "name": "the thing", }, }, }, } var schemaJSON = `{ "x-framework": "go-swagger", "$ref": "Cat", "description": "the description of this schema", "maximum": 100, "minimum": 5, "exclusiveMaximum": true, "exclusiveMinimum": true, "maxLength": 100, "minLength": 5, "pattern": "\\w{1,5}\\w+", "maxItems": 100, "minItems": 5, "uniqueItems": true, "multipleOf": 5, "enum": ["hello", "world"], "type": "string", "format": "date", "title": "the title", "default": "blah", "maxProperties": 5, "minProperties": 1, "required": ["id", "name"], "items": { "type": "string" }, "allOf": [ { "type": "string" } ], "properties": { "id": { "type": "integer", "format": "int64" }, "name": { "type": "string" } }, "discriminator": "not this", "readOnly": true, "xml": { "name": "sch", "namespace": "io", "prefix": "sw", "wrapped": true, "attribute": true }, "externalDocs": { "description": "the documentation etc", "url": "http://readthedocs.org/swagger" }, "example": [ { "id": 1, "name": "a book" }, { "id": 2, "name": "the thing" } ], "additionalProperties": { "type": "integer", "format": "int32" } } ` func TestSchema(t testing.T) { expected := map[string]interface{}{} _ = json.Unmarshal([]byte(schemaJSON), &expected) b, err := json.Marshal(schema) require.NoError(t, err) var actual map[string]interface{} require.NoError(t, json.Unmarshal(b, &actual)) assert.Equal(t, expected, actual) actual2 := Schema{} require.NoError(t, json.Unmarshal([]byte(schemaJSON), &actual2)) assert.Equal(t, schema.Ref, actual2.Ref) assert.Equal(t, schema.Description, actual2.Description) assert.Equal(t, schema.Maximum, actual2.Maximum) assert.Equal(t, schema.Minimum, actual2.Minimum) assert.Equal(t, schema.ExclusiveMinimum, actual2.ExclusiveMinimum) assert.Equal(t, schema.ExclusiveMaximum, actual2.ExclusiveMaximum) assert.Equal(t, schema.MaxLength, actual2.MaxLength) assert.Equal(t, schema.MinLength, actual2.MinLength) assert.Equal(t, schema.Pattern, actual2.Pattern) assert.Equal(t, schema.MaxItems, actual2.MaxItems) assert.Equal(t, schema.MinItems, actual2.MinItems) assert.True(t, actual2.UniqueItems) assert.Equal(t, schema.MultipleOf, actual2.MultipleOf) assert.Equal(t, schema.Enum, actual2.Enum) assert.Equal(t, schema.Type, actual2.Type) assert.Equal(t, schema.Format, actual2.Format) assert.Equal(t, schema.Title, actual2.Title) assert.Equal(t, schema.MaxProperties, actual2.MaxProperties) assert.Equal(t, schema.MinProperties, actual2.MinProperties) assert.Equal(t, schema.Required, actual2.Required) assert.Equal(t, schema.Items, actual2.Items) assert.Equal(t, schema.AllOf, actual2.AllOf) assert.Equal(t, schema.Properties, actual2.Properties) assert.Equal(t, schema.Discriminator, actual2.Discriminator) assert.Equal(t, schema.ReadOnly, actual2.ReadOnly) assert.Equal(t, schema.XML, actual2.XML) assert.Equal(t, schema.ExternalDocs, actual2.ExternalDocs) assert.Equal(t, schema.AdditionalProperties, actual2.AdditionalProperties) assert.Equal(t, schema.Extensions, actual2.Extensions) examples := actual2.Example.([]interface{}) expEx := schema.Example.([]interface{}) ex1 := examples[0].(map[string]interface{}) ex2 := examples[1].(map[string]interface{}) exp1 := expEx[0].(map[string]interface{}) exp2 := expEx[1].(map[string]interface{}) assert.EqualValues(t, exp1["id"], ex1["id"]) assert.Equal(t, exp1["name"], ex1["name"]) assert.EqualValues(t, exp2["id"], ex2["id"]) assert.Equal(t, exp2["name"], ex2["name"]) } func BenchmarkSchemaUnmarshal(b testing.B) { for i := 0; i < b.N; i++ { sch := &Schema{} _ = sch.UnmarshalJSON([]byte(schemaJSON)) } } func TestSchemaWithValidation(t *testing.T) { s := new(Schema).WithValidations(SchemaValidations{CommonValidations: CommonValidations{MaxLength: swag.Int64(15)}}) assert.EqualValues(t, swag.Int64(15), s.MaxLength) val := mkVal() s = new(Schema).WithValidations(val) assert.EqualValues(t, val, s.Validations()) }	6.64 KB	2025-05-25 12:27
📁 schemas	-	2025-05-25 12:27
📄 security_scheme.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 spec import ( "encoding/json" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) const ( basic = "basic" apiKey = "apiKey" oauth2 = "oauth2" implicit = "implicit" password = "password" application = "application" accessCode = "accessCode" ) // BasicAuth creates a basic auth security scheme func BasicAuth() SecurityScheme { return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{Type: basic}} } // APIKeyAuth creates an api key auth security scheme func APIKeyAuth(fieldName, valueSource string) SecurityScheme { return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{Type: apiKey, Name: fieldName, In: valueSource}} } // OAuth2Implicit creates an implicit flow oauth2 security scheme func OAuth2Implicit(authorizationURL string) SecurityScheme { return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ Type: oauth2, Flow: implicit, AuthorizationURL: authorizationURL, }} } // OAuth2Password creates a password flow oauth2 security scheme func OAuth2Password(tokenURL string) SecurityScheme { return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ Type: oauth2, Flow: password, TokenURL: tokenURL, }} } // OAuth2Application creates an application flow oauth2 security scheme func OAuth2Application(tokenURL string) SecurityScheme { return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ Type: oauth2, Flow: application, TokenURL: tokenURL, }} } // OAuth2AccessToken creates an access token flow oauth2 security scheme func OAuth2AccessToken(authorizationURL, tokenURL string) SecurityScheme { return &SecurityScheme{SecuritySchemeProps: SecuritySchemeProps{ Type: oauth2, Flow: accessCode, AuthorizationURL: authorizationURL, TokenURL: tokenURL, }} } // SecuritySchemeProps describes a swagger security scheme in the securityDefinitions section type SecuritySchemeProps struct { Description string `json:"description,omitempty"` Type string `json:"type"` Name string `json:"name,omitempty"` // api key In string `json:"in,omitempty"` // api key Flow string `json:"flow,omitempty"` // oauth2 AuthorizationURL string `json:"authorizationUrl"` // oauth2 TokenURL string `json:"tokenUrl,omitempty"` // oauth2 Scopes map[string]string `json:"scopes,omitempty"` // oauth2 } // AddScope adds a scope to this security scheme func (s SecuritySchemeProps) AddScope(scope, description string) { if s.Scopes == nil { s.Scopes = make(map[string]string) } s.Scopes[scope] = description } // SecurityScheme allows the definition of a security scheme that can be used by the operations. // Supported schemes are basic authentication, an API key (either as a header or as a query parameter) // and OAuth2's common flows (implicit, password, application and access code). // // For more information: http://goo.gl/8us55a#securitySchemeObject type SecurityScheme struct { VendorExtensible SecuritySchemeProps } // JSONLookup implements an interface to customize json pointer lookup func (s SecurityScheme) JSONLookup(token string) (interface{}, error) { if ex, ok := s.Extensions[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(s.SecuritySchemeProps, token) return r, err } // MarshalJSON marshal this to JSON func (s SecurityScheme) MarshalJSON() ([]byte, error) { var ( b1 []byte err error ) if s.Type == oauth2 && (s.Flow == "implicit" \|\| s.Flow == "accessCode") { // when oauth2 for implicit or accessCode flows, empty AuthorizationURL is added as empty string b1, err = json.Marshal(s.SecuritySchemeProps) } else { // when not oauth2, empty AuthorizationURL should be omitted b1, err = json.Marshal(struct { Description string `json:"description,omitempty"` Type string `json:"type"` Name string `json:"name,omitempty"` // api key In string `json:"in,omitempty"` // api key Flow string `json:"flow,omitempty"` // oauth2 AuthorizationURL string `json:"authorizationUrl,omitempty"` // oauth2 TokenURL string `json:"tokenUrl,omitempty"` // oauth2 Scopes map[string]string `json:"scopes,omitempty"` // oauth2 }{ Description: s.Description, Type: s.Type, Name: s.Name, In: s.In, Flow: s.Flow, AuthorizationURL: s.AuthorizationURL, TokenURL: s.TokenURL, Scopes: s.Scopes, }) } if err != nil { return nil, err } b2, err := json.Marshal(s.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2), nil } // UnmarshalJSON marshal this from JSON func (s SecurityScheme) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &s.SecuritySchemeProps); err != nil { return err } return json.Unmarshal(data, &s.VendorExtensible) }	5.71 KB	2025-05-25 12:27
📄 spec.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 spec import ( "encoding/json" ) //go:generate curl -L --progress -o ./schemas/v2/schema.json http://swagger.io/v2/schema.json //go:generate curl -L --progress -o ./schemas/jsonschema-draft-04.json http://json-schema.org/draft-04/schema //go:generate go-bindata -pkg=spec -prefix=./schemas -ignore=.\.md ./schemas/... //go:generate perl -pi -e s,Json,JSON,g bindata.go const ( // SwaggerSchemaURL the url for the swagger 2.0 schema to validate specs SwaggerSchemaURL = "http://swagger.io/v2/schema.json#" // JSONSchemaURL the url for the json schema JSONSchemaURL = "http://json-schema.org/draft-04/schema#" ) // MustLoadJSONSchemaDraft04 panics when Swagger20Schema returns an error func MustLoadJSONSchemaDraft04() Schema { d, e := JSONSchemaDraft04() if e != nil { panic(e) } return d } // JSONSchemaDraft04 loads the json schema document for json shema draft04 func JSONSchemaDraft04() (Schema, error) { b, err := jsonschemaDraft04JSONBytes() if err != nil { return nil, err } schema := new(Schema) if err := json.Unmarshal(b, schema); err != nil { return nil, err } return schema, nil } // MustLoadSwagger20Schema panics when Swagger20Schema returns an error func MustLoadSwagger20Schema() Schema { d, e := Swagger20Schema() if e != nil { panic(e) } return d } // Swagger20Schema loads the swagger 2.0 schema from the embedded assets func Swagger20Schema() (*Schema, error) { b, err := v2SchemaJSONBytes() if err != nil { return nil, err } schema := new(Schema) if err := json.Unmarshal(b, schema); err != nil { return nil, err } return schema, nil }	2.16 KB	2025-05-25 12:27
📄 spec_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 spec_test import ( "path/filepath" "strings" "testing" "github.com/go-openapi/spec" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Test unitary fixture for dev and bug fixing func TestSpec_Issue2743(t testing.T) { t.Run("should expand but produce unresolvable $ref", func(t testing.T) { path := filepath.Join("fixtures", "bugs", "2743", "working", "spec.yaml") sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader}), ) t.Run("all $ref do not resolve when expanding again", func(t testing.T) { err := spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader}) require.Error(t, err) require.ErrorContains(t, err, filepath.FromSlash("swagger/paths/swagger/user/index.yml")) }) }) t.Run("should expand and produce resolvable $ref", func(t testing.T) { path := filepath.Join("fixtures", "bugs", "2743", "not-working", "spec.yaml") sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader}), ) t.Run("all $ref properly reolve when expanding again", func(t testing.T) { require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader}), ) require.NotContainsf(t, asJSON(t, sp), "$ref", "all $ref's should have been expanded properly") }) }) } func TestSpec_Issue1429(t testing.T) { path := filepath.Join("fixtures", "bugs", "1429", "swagger.yaml") // load and full expand sp := loadOrFail(t, path) err := spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader}) require.NoError(t, err) // assert well expanded require.Truef(t, (sp.Paths != nil && sp.Paths.Paths != nil), "expected paths to be available in fixture") assertPaths1429(t, sp) for _, def := range sp.Definitions { assert.Empty(t, def.Ref) } // reload and SkipSchemas: true sp = loadOrFail(t, path) err = spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader}) require.NoError(t, err) // assert well resolved require.Truef(t, (sp.Paths != nil && sp.Paths.Paths != nil), "expected paths to be available in fixture") assertPaths1429SkipSchema(t, sp) for _, def := range sp.Definitions { assert.Contains(t, def.Ref.String(), "responses.yaml#/definitions/") } } func assertPaths1429(t testing.TB, sp spec.Swagger) { for _, pi := range sp.Paths.Paths { for _, param := range pi.Get.Parameters { require.NotNilf(t, param.Schema, "expected param schema not to be nil") // all param fixtures are body param with schema // all $ref expanded assert.Equal(t, "", param.Schema.Ref.String()) } for code, response := range pi.Get.Responses.StatusCodeResponses { // all response fixtures are with StatusCodeResponses, but 200 if code == 200 { assert.Nilf(t, response.Schema, "expected response schema to be nil") continue } require.NotNilf(t, response.Schema, "expected response schema not to be nil") assert.Equal(t, "", response.Schema.Ref.String()) } } } func assertPaths1429SkipSchema(t testing.TB, sp spec.Swagger) { for _, pi := range sp.Paths.Paths { for _, param := range pi.Get.Parameters { require.NotNilf(t, param.Schema, "expected param schema not to be nil") // all param fixtures are body param with schema switch param.Name { case "plainRequest": // this one is expanded assert.Equal(t, "", param.Schema.Ref.String()) continue case "nestedBody": // this one is local assert.Truef(t, strings.HasPrefix(param.Schema.Ref.String(), "#/definitions/"), "expected rooted definitions $ref, got: %s", param.Schema.Ref.String()) continue case "remoteRequest": assert.Contains(t, param.Schema.Ref.String(), "remote/remote.yaml#/") continue } assert.Contains(t, param.Schema.Ref.String(), "responses.yaml#/") } for code, response := range pi.Get.Responses.StatusCodeResponses { // all response fixtures are with StatusCodeResponses, but 200 switch code { case 200: assert.Nilf(t, response.Schema, "expected response schema to be nil") continue case 204: assert.Contains(t, response.Schema.Ref.String(), "remote/remote.yaml#/") continue case 404: assert.Equal(t, "", response.Schema.Ref.String()) continue } assert.Containsf(t, response.Schema.Ref.String(), "responses.yaml#/", "expected remote ref at resp. %d", code) } } } func TestSpec_MoreLocalExpansion(t testing.T) { path := filepath.Join("fixtures", "local_expansion", "spec2.yaml") // load and full expand sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) // asserts all $ref are expanded assert.NotContains(t, asJSON(t, sp), `"$ref"`) } func TestSpec_Issue69(t testing.T) { // this checks expansion for the dapperbox spec (circular ref issues) path := filepath.Join("fixtures", "bugs", "69", "dapperbox.json") // expand with relative path // load and expand sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) // asserts all $ref expanded jazon := asJSON(t, sp) // circular $ref are not expanded: however, they point to the expanded root document // assert all $ref match "$ref": "#/definitions/something" assertRefInJSON(t, jazon, "#/definitions") // assert all $ref expand correctly against the spec assertRefExpand(t, jazon, "", sp) } func TestSpec_Issue1621(t testing.T) { path := filepath.Join("fixtures", "bugs", "1621", "fixture-1621.yaml") // expand with relative path // load and expand sp := loadOrFail(t, path) err := spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader}) require.NoError(t, err) // asserts all $ref expanded jazon := asJSON(t, sp) assertNoRef(t, jazon) } func TestSpec_Issue1614(t testing.T) { path := filepath.Join("fixtures", "bugs", "1614", "gitea.json") // expand with relative path // load and expand sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) // asserts all $ref expanded jazon := asJSON(t, sp) // assert all $ref match "$ref": "#/definitions/something" assertRefInJSON(t, jazon, "#/definitions") // assert all $ref expand correctly against the spec assertRefExpand(t, jazon, "", sp) // now with option CircularRefAbsolute: circular $ref are not denormalized and are kept absolute. // This option is essentially for debugging purpose. sp = loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{ RelativeBase: path, SkipSchemas: false, AbsoluteCircularRef: true, PathLoader: testLoader, })) // asserts all $ref expanded jazon = asJSON(t, sp) // assert all $ref match "$ref": "file://{file}#/definitions/something" assertRefInJSONRegexp(t, jazon, `file://./gitea.json#/definitions/`) // assert all $ref expand correctly against the spec assertRefExpand(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path}) } func TestSpec_Issue2113(t testing.T) { // this checks expansion with nested specs path := filepath.Join("fixtures", "bugs", "2113", "base.yaml") // load and expand sp := loadOrFail(t, path) err := spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader}) require.NoError(t, err) // asserts all $ref expanded jazon := asJSON(t, sp) // assert all $ref match have been expanded assertNoRef(t, jazon) // now trying with SkipSchemas sp = loadOrFail(t, path) err = spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader}) require.NoError(t, err) jazon = asJSON(t, sp) // assert all $ref match assertRefInJSONRegexp(t, jazon, `^(schemas/dummy/dummy.yaml)\|(schemas/example/example.yaml)`) // assert all $ref resolve correctly against the spec assertRefResolve(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) // assert all $ref expand correctly against the spec assertRefExpand(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) } func TestSpec_Issue2113_External(t testing.T) { // Exercises the SkipSchema mode (used by spec flattening in go-openapi/analysis). // Provides more ground for testing with schemas nested in $refs // this checks expansion with nested specs path := filepath.Join("fixtures", "skipschema", "external_definitions_valid.yml") // load and expand, skipping schema expansion sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader})) // asserts all $ref are expanded as expected jazon := asJSON(t, sp) assertRefInJSONRegexp(t, jazon, `^(external/definitions.yml#/definitions)\|(external/errors.yml#/error)\|(external/nestedParams.yml#/bodyParam)`) // assert all $ref resolve correctly against the spec assertRefResolve(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) // assert all $ref in jazon expand correctly against the spec assertRefExpand(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) // expansion can be iterated again, including schemas require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) jazon = asJSON(t, sp) assertNoRef(t, jazon) // load and expand everything sp = loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) jazon = asJSON(t, sp) assertNoRef(t, jazon) } func TestSpec_Issue2113_SkipSchema(t testing.T) { // Exercises the SkipSchema mode from spec flattening in go-openapi/analysis // Provides more ground for testing with schemas nested in $refs // this checks expansion with nested specs path := filepath.Join("fixtures", "flatten", "flatten.yml") // load and expand, skipping schema expansion sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader})) jazon := asJSON(t, sp) // asserts all $ref are expanded as expected assertRefInJSONRegexp(t, jazon, `^(external/definitions.yml#/definitions)\|(#/definitions/namedAgain)\|(external/errors.yml#/error)`) // assert all $ref resolve correctly against the spec assertRefResolve(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) assertRefExpand(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) // load and expand, including schemas sp = loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) jazon = asJSON(t, sp) assertNoRef(t, jazon) } func TestSpec_PointersLoop(t testing.T) { // this a spec that cannot be flattened (self-referencing pointer). // however, it should be expanded without errors // this checks expansion with nested specs path := filepath.Join("fixtures", "more_circulars", "pointers", "fixture-pointers-loop.yaml") // load and expand, skipping schema expansion sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: true, PathLoader: testLoader})) jazon := asJSON(t, sp) assertRefExpand(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) sp = loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, &spec.ExpandOptions{RelativeBase: path, SkipSchemas: false, PathLoader: testLoader})) // cannot guarantee which ref will be kept, but only one remains: expand reduces all $ref down // to the last self-referencing one (the one picked changes from one run to another, depending // on where during the walk the cycle is detected). jazon = asJSON(t, sp) m := rex.FindAllStringSubmatch(jazon, -1) require.NotEmpty(t, m) refs := make(map[string]struct{}, 5) for _, matched := range m { subMatch := matched[1] refs[subMatch] = struct{}{} } require.Len(t, refs, 1) assertRefExpand(t, jazon, "", sp, &spec.ExpandOptions{RelativeBase: path, PathLoader: testLoader}) } func TestSpec_Issue102(t testing.T) { // go-openapi/validate/issues#102 path := filepath.Join("fixtures", "bugs", "102", "fixture-102.json") sp := loadOrFail(t, path) require.NoError(t, spec.ExpandSpec(sp, nil)) jazon := asJSON(t, sp) assertRefInJSONRegexp(t, jazon, `^#/definitions/Error$`) sp = loadOrFail(t, path) sch := spec.RefSchema("#/definitions/Error") require.NoError(t, spec.ExpandSchema(sch, sp, nil)) jazon = asJSON(t, sch) assertRefInJSONRegexp(t, jazon, "^#/definitions/Error$") sp = loadOrFail(t, path) sch = spec.RefSchema("#/definitions/Error") resp := spec.NewResponse().WithDescription("ok").WithSchema(sch) require.NoError(t, spec.ExpandResponseWithRoot(resp, sp, nil)) jazon = asJSON(t, resp) assertRefInJSONRegexp(t, jazon, "^#/definitions/Error$") sp = loadOrFail(t, path) sch = spec.RefSchema("#/definitions/Error") param := spec.BodyParam("error", sch) require.NoError(t, spec.ExpandParameterWithRoot(param, sp, nil)) jazon = asJSON(t, resp) assertRefInJSONRegexp(t, jazon, "^#/definitions/Error$") }	13.99 KB	2025-05-25 12:27
📄 structs_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 spec import ( "encoding/json" "reflect" "testing" "github.com/stretchr/testify/assert" "gopkg.in/yaml.v3" ) func assertSerializeJSON(t testing.TB, actual interface{}, expected string) bool { ser, err := json.Marshal(actual) if err != nil { return assert.Fail(t, "unable to marshal to json (%s): %#v", err, actual) } return assert.Equal(t, expected, string(ser)) } func assertSerializeYAML(t testing.TB, actual interface{}, expected string) bool { ser, err := yaml.Marshal(actual) if err != nil { return assert.Fail(t, "unable to marshal to yaml (%s): %#v", err, actual) } return assert.Equal(t, expected, string(ser)) } func derefTypeOf(expected interface{}) (tpe reflect.Type) { tpe = reflect.TypeOf(expected) if tpe.Kind() == reflect.Ptr { tpe = tpe.Elem() } return } func isPointed(expected interface{}) (pointed bool) { tpe := reflect.TypeOf(expected) if tpe.Kind() == reflect.Ptr { pointed = true } return } func assertParsesJSON(t testing.TB, actual string, expected interface{}) bool { parsed := reflect.New(derefTypeOf(expected)) err := json.Unmarshal([]byte(actual), parsed.Interface()) if err != nil { return assert.Fail(t, "unable to unmarshal from json (%s): %s", err, actual) } act := parsed.Interface() if !isPointed(expected) { act = reflect.Indirect(parsed).Interface() } return assert.Equal(t, expected, act) } func assertParsesYAML(t testing.TB, actual string, expected interface{}) bool { parsed := reflect.New(derefTypeOf(expected)) err := yaml.Unmarshal([]byte(actual), parsed.Interface()) if err != nil { return assert.Fail(t, "unable to unmarshal from yaml (%s): %s", err, actual) } act := parsed.Interface() if !isPointed(expected) { act = reflect.Indirect(parsed).Interface() } return assert.EqualValues(t, expected, act) } func TestSerialization_SerializeJSON(t testing.T) { assertSerializeJSON(t, []string{"hello"}, "[\"hello\"]") assertSerializeJSON(t, []string{"hello", "world", "and", "stuff"}, "[\"hello\",\"world\",\"and\",\"stuff\"]") assertSerializeJSON(t, StringOrArray(nil), "null") assertSerializeJSON(t, SchemaOrArray{ Schemas: []Schema{ {SchemaProps: SchemaProps{Type: []string{"string"}}}}, }, "[{\"type\":\"string\"}]") assertSerializeJSON(t, SchemaOrArray{ Schemas: []Schema{ {SchemaProps: SchemaProps{Type: []string{"string"}}}, {SchemaProps: SchemaProps{Type: []string{"string"}}}, }}, "[{\"type\":\"string\"},{\"type\":\"string\"}]") assertSerializeJSON(t, SchemaOrArray{}, "null") } func TestSerialization_DeserializeJSON(t testing.T) { // String assertParsesJSON(t, "\"hello\"", StringOrArray([]string{"hello"})) assertParsesJSON(t, "[\"hello\",\"world\",\"and\",\"stuff\"]", StringOrArray([]string{"hello", "world", "and", "stuff"})) assertParsesJSON(t, "[\"hello\",\"world\",null,\"stuff\"]", StringOrArray([]string{"hello", "world", "", "stuff"})) assertParsesJSON(t, "null", StringOrArray(nil)) // Schema assertParsesJSON(t, "{\"type\":\"string\"}", SchemaOrArray{Schema: &Schema{ SchemaProps: SchemaProps{Type: []string{"string"}}}, }) assertParsesJSON(t, "[{\"type\":\"string\"},{\"type\":\"string\"}]", &SchemaOrArray{ Schemas: []Schema{ {SchemaProps: SchemaProps{Type: []string{"string"}}}, {SchemaProps: SchemaProps{Type: []string{"string"}}}, }, }) assertParsesJSON(t, "null", SchemaOrArray{}) }	3.88 KB	2025-05-25 12:27
📄 swagger.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 spec import ( "bytes" "encoding/gob" "encoding/json" "fmt" "strconv" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // Swagger this is the root document object for the API specification. // It combines what previously was the Resource Listing and API Declaration (version 1.2 and earlier) // together into one document. // // For more information: http://goo.gl/8us55a#swagger-object- type Swagger struct { VendorExtensible SwaggerProps } // JSONLookup look up a value by the json property name func (s Swagger) JSONLookup(token string) (interface{}, error) { if ex, ok := s.Extensions[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(s.SwaggerProps, token) return r, err } // MarshalJSON marshals this swagger structure to json func (s Swagger) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(s.SwaggerProps) if err != nil { return nil, err } b2, err := json.Marshal(s.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2), nil } // UnmarshalJSON unmarshals a swagger spec from json func (s Swagger) UnmarshalJSON(data []byte) error { var sw Swagger if err := json.Unmarshal(data, &sw.SwaggerProps); err != nil { return err } if err := json.Unmarshal(data, &sw.VendorExtensible); err != nil { return err } s = sw return nil } // GobEncode provides a safe gob encoder for Swagger, including extensions func (s Swagger) GobEncode() ([]byte, error) { var b bytes.Buffer raw := struct { Props SwaggerProps Ext VendorExtensible }{ Props: s.SwaggerProps, Ext: s.VendorExtensible, } err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } // GobDecode provides a safe gob decoder for Swagger, including extensions func (s Swagger) GobDecode(b []byte) error { var raw struct { Props SwaggerProps Ext VendorExtensible } buf := bytes.NewBuffer(b) err := gob.NewDecoder(buf).Decode(&raw) if err != nil { return err } s.SwaggerProps = raw.Props s.VendorExtensible = raw.Ext return nil } // SwaggerProps captures the top-level properties of an Api specification // // NOTE: validation rules // - the scheme, when present must be from [http, https, ws, wss] // - BasePath must start with a leading "/" // - Paths is required type SwaggerProps struct { ID string `json:"id,omitempty"` Consumes []string `json:"consumes,omitempty"` Produces []string `json:"produces,omitempty"` Schemes []string `json:"schemes,omitempty"` Swagger string `json:"swagger,omitempty"` Info Info `json:"info,omitempty"` Host string `json:"host,omitempty"` BasePath string `json:"basePath,omitempty"` Paths Paths `json:"paths"` Definitions Definitions `json:"definitions,omitempty"` Parameters map[string]Parameter `json:"parameters,omitempty"` Responses map[string]Response `json:"responses,omitempty"` SecurityDefinitions SecurityDefinitions `json:"securityDefinitions,omitempty"` Security []map[string][]string `json:"security,omitempty"` Tags []Tag `json:"tags,omitempty"` ExternalDocs ExternalDocumentation `json:"externalDocs,omitempty"` } type swaggerPropsAlias SwaggerProps type gobSwaggerPropsAlias struct { Security []map[string]struct { List []string Pad bool } Alias swaggerPropsAlias SecurityIsEmpty bool } // GobEncode provides a safe gob encoder for SwaggerProps, including empty security requirements func (o SwaggerProps) GobEncode() ([]byte, error) { raw := gobSwaggerPropsAlias{ Alias: (swaggerPropsAlias)(&o), } var b bytes.Buffer if o.Security == nil { // nil security requirement err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } if len(o.Security) == 0 { // empty, but non-nil security requirement raw.SecurityIsEmpty = true raw.Alias.Security = nil err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } raw.Security = make([]map[string]struct { List []string Pad bool }, 0, len(o.Security)) for _, req := range o.Security { v := make(map[string]struct { List []string Pad bool }, len(req)) for k, val := range req { v[k] = struct { List []string Pad bool }{ List: val, } } raw.Security = append(raw.Security, v) } err := gob.NewEncoder(&b).Encode(raw) return b.Bytes(), err } // GobDecode provides a safe gob decoder for SwaggerProps, including empty security requirements func (o SwaggerProps) GobDecode(b []byte) error { var raw gobSwaggerPropsAlias buf := bytes.NewBuffer(b) err := gob.NewDecoder(buf).Decode(&raw) if err != nil { return err } if raw.Alias == nil { return nil } switch { case raw.SecurityIsEmpty: // empty, but non-nil security requirement raw.Alias.Security = []map[string][]string{} case len(raw.Alias.Security) == 0: // nil security requirement raw.Alias.Security = nil default: raw.Alias.Security = make([]map[string][]string, 0, len(raw.Security)) for _, req := range raw.Security { v := make(map[string][]string, len(req)) for k, val := range req { v[k] = make([]string, 0, len(val.List)) v[k] = append(v[k], val.List...) } raw.Alias.Security = append(raw.Alias.Security, v) } } o = (SwaggerProps)(raw.Alias) return nil } // Dependencies represent a dependencies property type Dependencies map[string]SchemaOrStringArray // SchemaOrBool represents a schema or boolean value, is biased towards true for the boolean property type SchemaOrBool struct { Allows bool Schema Schema } // JSONLookup implements an interface to customize json pointer lookup func (s SchemaOrBool) JSONLookup(token string) (interface{}, error) { if token == "allows" { return s.Allows, nil } r, _, err := jsonpointer.GetForToken(s.Schema, token) return r, err } var jsTrue = []byte("true") var jsFalse = []byte("false") // MarshalJSON convert this object to JSON func (s SchemaOrBool) MarshalJSON() ([]byte, error) { if s.Schema != nil { return json.Marshal(s.Schema) } if s.Schema == nil && !s.Allows { return jsFalse, nil } return jsTrue, nil } // UnmarshalJSON converts this bool or schema object from a JSON structure func (s SchemaOrBool) UnmarshalJSON(data []byte) error { var nw SchemaOrBool if len(data) > 0 { if data[0] == '{' { var sch Schema if err := json.Unmarshal(data, &sch); err != nil { return err } nw.Schema = &sch } nw.Allows = !bytes.Equal(data, []byte("false")) } s = nw return nil } // SchemaOrStringArray represents a schema or a string array type SchemaOrStringArray struct { Schema Schema Property []string } // JSONLookup implements an interface to customize json pointer lookup func (s SchemaOrStringArray) JSONLookup(token string) (interface{}, error) { r, _, err := jsonpointer.GetForToken(s.Schema, token) return r, err } // MarshalJSON converts this schema object or array into JSON structure func (s SchemaOrStringArray) MarshalJSON() ([]byte, error) { if len(s.Property) > 0 { return json.Marshal(s.Property) } if s.Schema != nil { return json.Marshal(s.Schema) } return []byte("null"), nil } // UnmarshalJSON converts this schema object or array from a JSON structure func (s SchemaOrStringArray) UnmarshalJSON(data []byte) error { var first byte if len(data) > 1 { first = data[0] } var nw SchemaOrStringArray if first == '{' { var sch Schema if err := json.Unmarshal(data, &sch); err != nil { return err } nw.Schema = &sch } if first == '[' { if err := json.Unmarshal(data, &nw.Property); err != nil { return err } } s = nw return nil } // Definitions contains the models explicitly defined in this spec // An object to hold data types that can be consumed and produced by operations. // These data types can be primitives, arrays or models. // // For more information: http://goo.gl/8us55a#definitionsObject type Definitions map[string]Schema // SecurityDefinitions a declaration of the security schemes available to be used in the specification. // This does not enforce the security schemes on the operations and only serves to provide // the relevant details for each scheme. // // For more information: http://goo.gl/8us55a#securityDefinitionsObject type SecurityDefinitions map[string]SecurityScheme // StringOrArray represents a value that can either be a string // or an array of strings. Mainly here for serialization purposes type StringOrArray []string // Contains returns true when the value is contained in the slice func (s StringOrArray) Contains(value string) bool { for _, str := range s { if str == value { return true } } return false } // JSONLookup implements an interface to customize json pointer lookup func (s SchemaOrArray) JSONLookup(token string) (interface{}, error) { if _, err := strconv.Atoi(token); err == nil { r, _, err := jsonpointer.GetForToken(s.Schemas, token) return r, err } r, _, err := jsonpointer.GetForToken(s.Schema, token) return r, err } // UnmarshalJSON unmarshals this string or array object from a JSON array or JSON string func (s StringOrArray) UnmarshalJSON(data []byte) error { var first byte if len(data) > 1 { first = data[0] } if first == '[' { var parsed []string if err := json.Unmarshal(data, &parsed); err != nil { return err } s = StringOrArray(parsed) return nil } var single interface{} if err := json.Unmarshal(data, &single); err != nil { return err } if single == nil { return nil } switch v := single.(type) { case string: s = StringOrArray([]string{v}) return nil default: return fmt.Errorf("only string or array is allowed, not %T", single) } } // MarshalJSON converts this string or array to a JSON array or JSON string func (s StringOrArray) MarshalJSON() ([]byte, error) { if len(s) == 1 { return json.Marshal([]string(s)[0]) } return json.Marshal([]string(s)) } // SchemaOrArray represents a value that can either be a Schema // or an array of Schema. Mainly here for serialization purposes type SchemaOrArray struct { Schema Schema Schemas []Schema } // Len returns the number of schemas in this property func (s SchemaOrArray) Len() int { if s.Schema != nil { return 1 } return len(s.Schemas) } // ContainsType returns true when one of the schemas is of the specified type func (s SchemaOrArray) ContainsType(name string) bool { if s.Schema != nil { return s.Schema.Type != nil && s.Schema.Type.Contains(name) } return false } // MarshalJSON converts this schema object or array into JSON structure func (s SchemaOrArray) MarshalJSON() ([]byte, error) { if len(s.Schemas) > 0 { return json.Marshal(s.Schemas) } return json.Marshal(s.Schema) } // UnmarshalJSON converts this schema object or array from a JSON structure func (s SchemaOrArray) UnmarshalJSON(data []byte) error { var nw SchemaOrArray var first byte if len(data) > 1 { first = data[0] } if first == '{' { var sch Schema if err := json.Unmarshal(data, &sch); err != nil { return err } nw.Schema = &sch } if first == '[' { if err := json.Unmarshal(data, &nw.Schemas); err != nil { return err } } s = nw return nil } // vim:set ft=go noet sts=2 sw=2 ts=2:	11.8 KB	2025-05-25 12:27
📄 swagger_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) var spec = Swagger{ SwaggerProps: SwaggerProps{ ID: "http://localhost:3849/api-docs", Swagger: "2.0", Consumes: []string{"application/json", "application/x-yaml"}, Produces: []string{"application/json"}, Schemes: []string{"http", "https"}, Info: &info, Host: "some.api.out.there", BasePath: "/", Paths: &paths, Definitions: map[string]Schema{"Category": {SchemaProps: SchemaProps{Type: []string{"string"}}}}, Parameters: map[string]Parameter{ "categoryParam": {ParamProps: ParamProps{Name: "category", In: "query"}, SimpleSchema: SimpleSchema{Type: "string"}}, }, Responses: map[string]Response{ "EmptyAnswer": { ResponseProps: ResponseProps{ Description: "no data to return for this operation", }, }, }, SecurityDefinitions: map[string]SecurityScheme{ "internalApiKey": APIKeyAuth("api_key", "header"), }, Security: []map[string][]string{ {"internalApiKey": {}}, }, Tags: []Tag{NewTag("pets", "", nil)}, ExternalDocs: &ExternalDocumentation{Description: "the name", URL: "the url"}, }, VendorExtensible: VendorExtensible{Extensions: map[string]interface{}{ "x-some-extension": "vendor", "x-schemes": []interface{}{"unix", "amqp"}, }}, } const specJSON = `{ "id": "http://localhost:3849/api-docs", "consumes": ["application/json", "application/x-yaml"], "produces": ["application/json"], "schemes": ["http", "https"], "swagger": "2.0", "info": { "contact": { "name": "wordnik api team", "url": "http://developer.wordnik.com" }, "description": "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0` + ` specification", "license": { "name": "Creative Commons 4.0 International", "url": "http://creativecommons.org/licenses/by/4.0/" }, "termsOfService": "http://helloreverb.com/terms/", "title": "Swagger Sample API", "version": "1.0.9-abcd", "x-framework": "go-swagger" }, "host": "some.api.out.there", "basePath": "/", "paths": {"x-framework":"go-swagger","/":{"$ref":"cats"}}, "definitions": { "Category": { "type": "string"} }, "parameters": { "categoryParam": { "name": "category", "in": "query", "type": "string" } }, "responses": { "EmptyAnswer": { "description": "no data to return for this operation" } }, "securityDefinitions": { "internalApiKey": { "type": "apiKey", "in": "header", "name": "api_key" } }, "security": [{"internalApiKey":[]}], "tags": [{"name":"pets"}], "externalDocs": {"description":"the name","url":"the url"}, "x-some-extension": "vendor", "x-schemes": ["unix","amqp"] }` // func verifySpecSerialize(specJSON []byte, spec Swagger) { // expected := map[string]interface{}{} // json.Unmarshal(specJSON, &expected) // b, err := json.MarshalIndent(spec, "", " ") // So(err, ShouldBeNil) // var actual map[string]interface{} // err = json.Unmarshal(b, &actual) // So(err, ShouldBeNil) // compareSpecMaps(actual, expected) // } / // assertEquivalent is currently unused func assertEquivalent(t testing.TB, actual, expected interface{}) bool { if actual == nil \|\| expected == nil \|\| reflect.DeepEqual(actual, expected) { return true } actualType := reflect.TypeOf(actual) expectedType := reflect.TypeOf(expected) if reflect.TypeOf(actual).ConvertibleTo(expectedType) { expectedValue := reflect.ValueOf(expected) if swag.IsZero(expectedValue) && swag.IsZero(reflect.ValueOf(actual)) { return true } // Attempt comparison after type conversion if reflect.DeepEqual(actual, expectedValue.Convert(actualType).Interface()) { return true } } // Last ditch effort if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) { return true } errFmt := "Expected: '%[1]T(%[1]#v)'\nActual: '%[2]T(%[2]#v)'\n(Should be equivalent)!" return assert.Fail(t, errFmt, expected, actual) } // ShouldBeEquivalentTo is currently unused func ShouldBeEquivalentTo(actual interface{}, expecteds ...interface{}) string { expected := expecteds[0] if actual == nil \|\| expected == nil { return "" } if reflect.DeepEqual(expected, actual) { return "" } actualType := reflect.TypeOf(actual) expectedType := reflect.TypeOf(expected) if reflect.TypeOf(actual).ConvertibleTo(expectedType) { expectedValue := reflect.ValueOf(expected) if swag.IsZero(expectedValue) && swag.IsZero(reflect.ValueOf(actual)) { return "" } // Attempt comparison after type conversion if reflect.DeepEqual(actual, expectedValue.Convert(actualType).Interface()) { return "" } } // Last ditch effort if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) { return "" } errFmt := "Expected: '%[1]T(%[1]#v)'\nActual: '%[2]T(%[2]#v)'\n(Should be equivalent)!" return fmt.Sprintf(errFmt, expected, actual) } // assertSpecMaps is currently unused func assertSpecMaps(t testing.TB, actual, expected map[string]interface{}) bool { res := true if id, ok := expected["id"]; ok { res = assert.Equal(t, id, actual["id"]) } res = res && assert.Equal(t, expected["consumes"], actual["consumes"]) res = res && assert.Equal(t, expected["produces"], actual["produces"]) res = res && assert.Equal(t, expected["schemes"], actual["schemes"]) res = res && assert.Equal(t, expected["swagger"], actual["swagger"]) res = res && assert.Equal(t, expected["info"], actual["info"]) res = res && assert.Equal(t, expected["host"], actual["host"]) res = res && assert.Equal(t, expected["basePath"], actual["basePath"]) res = res && assert.Equal(t, expected["paths"], actual["paths"]) res = res && assert.Equal(t, expected["definitions"], actual["definitions"]) res = res && assert.Equal(t, expected["responses"], actual["responses"]) res = res && assert.Equal(t, expected["securityDefinitions"], actual["securityDefinitions"]) res = res && assert.Equal(t, expected["tags"], actual["tags"]) res = res && assert.Equal(t, expected["externalDocs"], actual["externalDocs"]) res = res && assert.Equal(t, expected["x-some-extension"], actual["x-some-extension"]) res = res && assert.Equal(t, expected["x-schemes"], actual["x-schemes"]) return res } / func assertSpecs(t testing.TB, actual, expected Swagger) bool { expected.Swagger = "2.0" return assert.Equal(t, expected, actual) } / // assertSpecJSON is currently unused func assertSpecJSON(t testing.TB, specJSON []byte) bool { var expected map[string]interface{} if !assert.NoError(t, json.Unmarshal(specJSON, &expected)) { return false } obj := Swagger{} if !assert.NoError(t, json.Unmarshal(specJSON, &obj)) { return false } cb, err := json.MarshalIndent(obj, "", " ") if assert.NoError(t, err) { return false } var actual map[string]interface{} if !assert.NoError(t, json.Unmarshal(cb, &actual)) { return false } return assertSpecMaps(t, expected, actual ) } / func TestSwaggerSpec_Serialize(t testing.T) { expected := make(map[string]interface{}) _ = json.Unmarshal([]byte(specJSON), &expected) b, err := json.MarshalIndent(spec, "", " ") require.NoError(t, err) var actual map[string]interface{} require.NoError(t, json.Unmarshal(b, &actual)) assert.EqualValues(t, expected, actual) } func TestSwaggerSpec_Deserialize(t testing.T) { var actual Swagger require.NoError(t, json.Unmarshal([]byte(specJSON), &actual)) assert.EqualValues(t, actual, spec) } func TestVendorExtensionStringSlice(t testing.T) { var actual Swagger require.NoError(t, json.Unmarshal([]byte(specJSON), &actual)) schemes, ok := actual.Extensions.GetStringSlice("x-schemes") require.True(t, ok) assert.EqualValues(t, []string{"unix", "amqp"}, schemes) notSlice, ok := actual.Extensions.GetStringSlice("x-some-extension") assert.Nil(t, notSlice) assert.False(t, ok) actual.AddExtension("x-another-ext", 100) notString, ok := actual.Extensions.GetStringSlice("x-another-ext") assert.Nil(t, notString) assert.False(t, ok) actual.AddExtension("x-another-slice-ext", []interface{}{100, 100}) notStringSlice, ok := actual.Extensions.GetStringSlice("x-another-slice-ext") assert.Nil(t, notStringSlice) assert.False(t, ok) _, ok = actual.Extensions.GetStringSlice("x-notfound-ext") assert.False(t, ok) } func TestOptionalSwaggerProps_Serialize(t testing.T) { minimalJSONSpec := []byte(`{ "swagger": "2.0", "info": { "version": "0.0.0", "title": "Simple API" }, "paths": { "/": { "get": { "responses": { "200": { "description": "OK" } } } } } }`) var minimalSpec Swagger err := json.Unmarshal(minimalJSONSpec, &minimalSpec) require.NoError(t, err) bytes, err := json.Marshal(&minimalSpec) require.NoError(t, err) var ms map[string]interface{} require.NoError(t, json.Unmarshal(bytes, &ms)) assert.NotContains(t, ms, "consumes") assert.NotContains(t, ms, "produces") assert.NotContains(t, ms, "schemes") assert.NotContains(t, ms, "host") assert.NotContains(t, ms, "basePath") assert.NotContains(t, ms, "definitions") assert.NotContains(t, ms, "parameters") assert.NotContains(t, ms, "responses") assert.NotContains(t, ms, "securityDefinitions") assert.NotContains(t, ms, "security") assert.NotContains(t, ms, "tags") assert.NotContains(t, ms, "externalDocs") } var minimalJSONSpec = []byte(`{ "swagger": "2.0", "info": { "version": "0.0.0", "title": "Simple API" }, "securityDefinitions": { "basic": { "type": "basic" }, "apiKey": { "type": "apiKey", "in": "header", "name": "X-API-KEY" }, "queryKey": { "type": "apiKey", "in": "query", "name": "api_key" } }, "paths": { "/": { "get": { "security": [ { "apiKey": [], "basic": [] }, {}, { "queryKey": [], "basic": [] } ], "responses": { "200": { "description": "OK" } } } } } }`) func TestSecurityRequirements(t testing.T) { var minimalSpec Swagger require.NoError(t, json.Unmarshal(minimalJSONSpec, &minimalSpec)) sec := minimalSpec.Paths.Paths["/"].Get.Security require.Len(t, sec, 3) assert.Contains(t, sec[0], "basic") assert.Contains(t, sec[0], "apiKey") assert.NotNil(t, sec[1]) assert.Empty(t, sec[1]) assert.Contains(t, sec[2], "queryKey") } func TestSwaggerGobEncoding(t testing.T) { doTestSwaggerGobEncoding(t, specJSON) doTestSwaggerGobEncoding(t, string(minimalJSONSpec)) } func doTestSwaggerGobEncoding(t testing.T, fixture string) { var src, dst Swagger require.NoError(t, json.Unmarshal([]byte(fixture), &src)) doTestAnyGobEncoding(t, &src, &dst) }	11.12 KB	2025-05-25 12:27
📄 tag.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 spec import ( "encoding/json" "github.com/go-openapi/jsonpointer" "github.com/go-openapi/swag" ) // TagProps describe a tag entry in the top level tags section of a swagger spec type TagProps struct { Description string `json:"description,omitempty"` Name string `json:"name,omitempty"` ExternalDocs ExternalDocumentation `json:"externalDocs,omitempty"` } // NewTag creates a new tag func NewTag(name, description string, externalDocs ExternalDocumentation) Tag { return Tag{TagProps: TagProps{Description: description, Name: name, ExternalDocs: externalDocs}} } // Tag allows adding meta data to a single tag that is used by the // [Operation Object](http://goo.gl/8us55a#operationObject). // It is not mandatory to have a Tag Object per tag used there. // // For more information: http://goo.gl/8us55a#tagObject type Tag struct { VendorExtensible TagProps } // JSONLookup implements an interface to customize json pointer lookup func (t Tag) JSONLookup(token string) (interface{}, error) { if ex, ok := t.Extensions[token]; ok { return &ex, nil } r, _, err := jsonpointer.GetForToken(t.TagProps, token) return r, err } // MarshalJSON marshal this to JSON func (t Tag) MarshalJSON() ([]byte, error) { b1, err := json.Marshal(t.TagProps) if err != nil { return nil, err } b2, err := json.Marshal(t.VendorExtensible) if err != nil { return nil, err } return swag.ConcatJSON(b1, b2), nil } // UnmarshalJSON marshal this from JSON func (t *Tag) UnmarshalJSON(data []byte) error { if err := json.Unmarshal(data, &t.TagProps); err != nil { return err } return json.Unmarshal(data, &t.VendorExtensible) }	2.24 KB	2025-05-25 12:27
📄 url_go19.go package spec import "net/url" func parseURL(s string) (*url.URL, error) { u, err := url.Parse(s) if err == nil { u.OmitHost = false } return u, err }	158 B	2025-05-25 12:27
📄 validations.go package spec // CommonValidations describe common JSON-schema validations type CommonValidations struct { Maximum float64 `json:"maximum,omitempty"` ExclusiveMaximum bool `json:"exclusiveMaximum,omitempty"` Minimum float64 `json:"minimum,omitempty"` ExclusiveMinimum bool `json:"exclusiveMinimum,omitempty"` MaxLength int64 `json:"maxLength,omitempty"` MinLength int64 `json:"minLength,omitempty"` Pattern string `json:"pattern,omitempty"` MaxItems int64 `json:"maxItems,omitempty"` MinItems int64 `json:"minItems,omitempty"` UniqueItems bool `json:"uniqueItems,omitempty"` MultipleOf float64 `json:"multipleOf,omitempty"` Enum []interface{} `json:"enum,omitempty"` } // SetValidations defines all validations for a simple schema. // // NOTE: the input is the larger set of validations available for schemas. // For simple schemas, MinProperties and MaxProperties are ignored. func (v CommonValidations) SetValidations(val SchemaValidations) { v.Maximum = val.Maximum v.ExclusiveMaximum = val.ExclusiveMaximum v.Minimum = val.Minimum v.ExclusiveMinimum = val.ExclusiveMinimum v.MaxLength = val.MaxLength v.MinLength = val.MinLength v.Pattern = val.Pattern v.MaxItems = val.MaxItems v.MinItems = val.MinItems v.UniqueItems = val.UniqueItems v.MultipleOf = val.MultipleOf v.Enum = val.Enum } type clearedValidation struct { Validation string Value interface{} } type clearedValidations []clearedValidation func (c clearedValidations) apply(cbs []func(string, interface{})) { for _, cb := range cbs { for _, cleared := range c { cb(cleared.Validation, cleared.Value) } } } // ClearNumberValidations clears all number validations. // // Some callbacks may be set by the caller to capture changed values. func (v CommonValidations) ClearNumberValidations(cbs ...func(string, interface{})) { done := make(clearedValidations, 0, 5) defer func() { done.apply(cbs) }() if v.Minimum != nil { done = append(done, clearedValidation{Validation: "minimum", Value: v.Minimum}) v.Minimum = nil } if v.Maximum != nil { done = append(done, clearedValidation{Validation: "maximum", Value: v.Maximum}) v.Maximum = nil } if v.ExclusiveMaximum { done = append(done, clearedValidation{Validation: "exclusiveMaximum", Value: v.ExclusiveMaximum}) v.ExclusiveMaximum = false } if v.ExclusiveMinimum { done = append(done, clearedValidation{Validation: "exclusiveMinimum", Value: v.ExclusiveMinimum}) v.ExclusiveMinimum = false } if v.MultipleOf != nil { done = append(done, clearedValidation{Validation: "multipleOf", Value: v.MultipleOf}) v.MultipleOf = nil } } // ClearStringValidations clears all string validations. // // Some callbacks may be set by the caller to capture changed values. func (v CommonValidations) ClearStringValidations(cbs ...func(string, interface{})) { done := make(clearedValidations, 0, 3) defer func() { done.apply(cbs) }() if v.Pattern != "" { done = append(done, clearedValidation{Validation: "pattern", Value: v.Pattern}) v.Pattern = "" } if v.MinLength != nil { done = append(done, clearedValidation{Validation: "minLength", Value: v.MinLength}) v.MinLength = nil } if v.MaxLength != nil { done = append(done, clearedValidation{Validation: "maxLength", Value: v.MaxLength}) v.MaxLength = nil } } // ClearArrayValidations clears all array validations. // // Some callbacks may be set by the caller to capture changed values. func (v CommonValidations) ClearArrayValidations(cbs ...func(string, interface{})) { done := make(clearedValidations, 0, 3) defer func() { done.apply(cbs) }() if v.MaxItems != nil { done = append(done, clearedValidation{Validation: "maxItems", Value: v.MaxItems}) v.MaxItems = nil } if v.MinItems != nil { done = append(done, clearedValidation{Validation: "minItems", Value: v.MinItems}) v.MinItems = nil } if v.UniqueItems { done = append(done, clearedValidation{Validation: "uniqueItems", Value: v.UniqueItems}) v.UniqueItems = false } } // Validations returns a clone of the validations for a simple schema. // // NOTE: in the context of simple schema objects, MinProperties, MaxProperties // and PatternProperties remain unset. func (v CommonValidations) Validations() SchemaValidations { return SchemaValidations{ CommonValidations: v, } } // HasNumberValidations indicates if the validations are for numbers or integers func (v CommonValidations) HasNumberValidations() bool { return v.Maximum != nil \|\| v.Minimum != nil \|\| v.MultipleOf != nil } // HasStringValidations indicates if the validations are for strings func (v CommonValidations) HasStringValidations() bool { return v.MaxLength != nil \|\| v.MinLength != nil \|\| v.Pattern != "" } // HasArrayValidations indicates if the validations are for arrays func (v CommonValidations) HasArrayValidations() bool { return v.MaxItems != nil \|\| v.MinItems != nil \|\| v.UniqueItems } // HasEnum indicates if the validation includes some enum constraint func (v CommonValidations) HasEnum() bool { return len(v.Enum) > 0 } // SchemaValidations describes the validation properties of a schema // // NOTE: at this moment, this is not embedded in SchemaProps because this would induce a breaking change // in the exported members: all initializers using litterals would fail. type SchemaValidations struct { CommonValidations PatternProperties SchemaProperties `json:"patternProperties,omitempty"` MaxProperties int64 `json:"maxProperties,omitempty"` MinProperties int64 `json:"minProperties,omitempty"` } // HasObjectValidations indicates if the validations are for objects func (v SchemaValidations) HasObjectValidations() bool { return v.MaxProperties != nil \|\| v.MinProperties != nil \|\| v.PatternProperties != nil } // SetValidations for schema validations func (v SchemaValidations) SetValidations(val SchemaValidations) { v.CommonValidations.SetValidations(val) v.PatternProperties = val.PatternProperties v.MaxProperties = val.MaxProperties v.MinProperties = val.MinProperties } // Validations for a schema func (v SchemaValidations) Validations() SchemaValidations { val := v.CommonValidations.Validations() val.PatternProperties = v.PatternProperties val.MinProperties = v.MinProperties val.MaxProperties = v.MaxProperties return val } // ClearObjectValidations returns a clone of the validations with all object validations cleared. // // Some callbacks may be set by the caller to capture changed values. func (v *SchemaValidations) ClearObjectValidations(cbs ...func(string, interface{})) { done := make(clearedValidations, 0, 3) defer func() { done.apply(cbs) }() if v.MaxProperties != nil { done = append(done, clearedValidation{Validation: "maxProperties", Value: v.MaxProperties}) v.MaxProperties = nil } if v.MinProperties != nil { done = append(done, clearedValidation{Validation: "minProperties", Value: v.MinProperties}) v.MinProperties = nil } if v.PatternProperties != nil { done = append(done, clearedValidation{Validation: "patternProperties", Value: v.PatternProperties}) v.PatternProperties = nil } }	7.12 KB	2025-05-25 12:27
📄 validations_test.go package spec import ( "testing" "github.com/go-openapi/swag" "github.com/stretchr/testify/require" ) func mkVal() SchemaValidations { return SchemaValidations{ CommonValidations: CommonValidations{ Maximum: swag.Float64(2.5), ExclusiveMaximum: true, Minimum: swag.Float64(3.4), ExclusiveMinimum: true, MaxLength: swag.Int64(15), MinLength: swag.Int64(16), Pattern: "abc", MaxItems: swag.Int64(17), MinItems: swag.Int64(18), UniqueItems: true, MultipleOf: swag.Float64(4.4), Enum: []interface{}{"a", 12.5}, }, PatternProperties: SchemaProperties{ "x": BooleanProperty(), "y": BooleanProperty(), }, MinProperties: swag.Int64(19), MaxProperties: swag.Int64(20), } } func TestValidations(t *testing.T) { var cv CommonValidations val := mkVal() cv.SetValidations(val) expectedCV := val.CommonValidations require.EqualValues(t, expectedCV, cv) require.True(t, cv.HasArrayValidations()) require.True(t, cv.HasNumberValidations()) require.True(t, cv.HasStringValidations()) require.True(t, cv.HasEnum()) cv.Enum = nil require.False(t, cv.HasEnum()) cv.MaxLength = nil require.True(t, cv.HasStringValidations()) cv.MinLength = nil require.True(t, cv.HasStringValidations()) cv.Pattern = "" require.False(t, cv.HasStringValidations()) cv.Minimum = nil require.True(t, cv.HasNumberValidations()) cv.Maximum = nil require.True(t, cv.HasNumberValidations()) cv.MultipleOf = nil require.False(t, cv.HasNumberValidations()) cv.MaxItems = nil require.True(t, cv.HasArrayValidations()) cv.MinItems = nil require.True(t, cv.HasArrayValidations()) cv.UniqueItems = false require.False(t, cv.HasArrayValidations()) val = mkVal() expectedSV := val expectedSV.PatternProperties = nil expectedSV.MinProperties = nil expectedSV.MaxProperties = nil val = mkVal() cv.SetValidations(val) require.EqualValues(t, expectedSV, cv.Validations()) var sv SchemaValidations val = mkVal() sv.SetValidations(val) expectedSV = val require.EqualValues(t, expectedSV, sv) require.EqualValues(t, val, sv.Validations()) require.True(t, sv.HasObjectValidations()) sv.MinProperties = nil require.True(t, sv.HasObjectValidations()) sv.MaxProperties = nil require.True(t, sv.HasObjectValidations()) sv.PatternProperties = nil require.False(t, sv.HasObjectValidations()) val = mkVal() cv.SetValidations(val) cv.ClearStringValidations() require.False(t, cv.HasStringValidations()) cv.ClearNumberValidations() require.False(t, cv.HasNumberValidations()) cv.ClearArrayValidations() require.False(t, cv.HasArrayValidations()) sv.SetValidations(val) sv.ClearObjectValidations(func(validation string, _ interface{}) { switch validation { case "minProperties", "maxProperties", "patternProperties": return default: t.Logf("unexpected validation %s", validation) t.Fail() } }) require.Falsef(t, sv.HasObjectValidations(), "%#v", sv) }	2.95 KB	2025-05-25 12:27
📄 xml_object.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 spec // XMLObject a metadata object that allows for more fine-tuned XML model definitions. // // For more information: http://goo.gl/8us55a#xmlObject type XMLObject struct { Name string `json:"name,omitempty"` Namespace string `json:"namespace,omitempty"` Prefix string `json:"prefix,omitempty"` Attribute bool `json:"attribute,omitempty"` Wrapped bool `json:"wrapped,omitempty"` } // WithName sets the xml name for the object func (x XMLObject) WithName(name string) XMLObject { x.Name = name return x } // WithNamespace sets the xml namespace for the object func (x XMLObject) WithNamespace(namespace string) XMLObject { x.Namespace = namespace return x } // WithPrefix sets the xml prefix for the object func (x XMLObject) WithPrefix(prefix string) XMLObject { x.Prefix = prefix return x } // AsAttribute flags this object as xml attribute func (x XMLObject) AsAttribute() XMLObject { x.Attribute = true return x } // AsElement flags this object as an xml node func (x XMLObject) AsElement() XMLObject { x.Attribute = false return x } // AsWrapped flags this object as wrapped, this is mostly useful for array types func (x XMLObject) AsWrapped() XMLObject { x.Wrapped = true return x } // AsUnwrapped flags this object as an xml node func (x XMLObject) AsUnwrapped() XMLObject { x.Wrapped = false return x }	1.93 KB	2025-05-25 12:27
📄 xml_object_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 spec import ( "encoding/json" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestXmlObject_Serialize(t testing.T) { obj1 := XMLObject{} actual, err := json.Marshal(obj1) require.NoError(t, err) assert.Equal(t, "{}", string(actual)) obj2 := XMLObject{ Name: "the name", Namespace: "the namespace", Prefix: "the prefix", Attribute: true, Wrapped: true, } actual, err = json.Marshal(obj2) require.NoError(t, err) var ad map[string]interface{} require.NoError(t, json.Unmarshal(actual, &ad)) assert.Equal(t, obj2.Name, ad["name"]) assert.Equal(t, obj2.Namespace, ad["namespace"]) assert.Equal(t, obj2.Prefix, ad["prefix"]) assert.True(t, ad["attribute"].(bool)) assert.True(t, ad["wrapped"].(bool)) } func TestXmlObject_Deserialize(t testing.T) { expected := XMLObject{} actual := XMLObject{} require.NoError(t, json.Unmarshal([]byte("{}"), &actual)) assert.Equal(t, expected, actual) completed := `{"name":"the name","namespace":"the namespace","prefix":"the prefix","attribute":true,"wrapped":true}` expected = XMLObject{ Name: "the name", Namespace: "the namespace", Prefix: "the prefix", Attribute: true, Wrapped: true, } actual = XMLObject{} require.NoError(t, json.Unmarshal([]byte(completed), &actual)) assert.Equal(t, expected, actual) }	1.93 KB	2025-05-25 12:27

Edit File:

Terminal