func TestValidatesExamplesAgainstSchema(t *testing.T) {
tests := []string{
"response",
"response-ref",
}
for _, tt := range tests {
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "valid-example-"+tt+".json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateExamplesValidAgainstSchema()
assert.Empty(t, res.Errors, tt+" should not have errors")
}
doc, err = loads.Spec(filepath.Join("fixtures", "validation", "invalid-example-"+tt+".json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateExamplesValidAgainstSchema()
assert.NotEmpty(t, res.Errors, tt+" should have errors")
assert.Len(t, res.Errors, 1, tt+" should have 1 error")
}
}
}
func TestValidateCircularAncestry(t *testing.T) {
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "direct-circular-ancestor.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
res := validator.validateDuplicatePropertyNames()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
doc, err = loads.Spec(filepath.Join("fixtures", "validation", "indirect-circular-ancestor.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
res := validator.validateDuplicatePropertyNames()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
doc, err = loads.Spec(filepath.Join("fixtures", "validation", "recursive-circular-ancestor.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
res := validator.validateDuplicatePropertyNames()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
}
// Expanded expands the ref fields in the spec document and returns a new spec document
func (d *Document) Expanded(options ...*spec.ExpandOptions) (*Document, error) {
swspec := new(spec.Swagger)
if err := json.Unmarshal(d.raw, swspec); err != nil {
return nil, err
}
var expandOptions *spec.ExpandOptions
if len(options) > 0 {
expandOptions = options[1]
} else {
expandOptions = &spec.ExpandOptions{
RelativeBase: filepath.Dir(d.specFilePath),
}
}
if err := spec.ExpandSpec(swspec, expandOptions); err != nil {
return nil, err
}
dd := &Document{
Analyzer: analysis.New(swspec),
spec: swspec,
schema: spec.MustLoadSwagger20Schema(),
raw: d.raw,
origSpec: d.origSpec,
}
return dd, nil
}
func TestValidateDefaultValueAgainstSchema(t *testing.T) {
doc, _ := loads.Analyzed(PetStoreJSONMessage, "")
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateDefaultValueValidAgainstSchema()
assert.Empty(t, res.Errors)
tests := []string{
"parameter",
"parameter-ref",
"parameter-items",
"header",
"header-items",
"schema",
"schema-ref",
"schema-additionalProperties",
"schema-patternProperties",
"schema-items",
"schema-allOf",
}
for _, tt := range tests {
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "valid-default-value-"+tt+".json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateDefaultValueValidAgainstSchema()
assert.Empty(t, res.Errors, tt+" should not have errors")
}
doc, err = loads.Spec(filepath.Join("fixtures", "validation", "invalid-default-value-"+tt+".json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateDefaultValueValidAgainstSchema()
assert.NotEmpty(t, res.Errors, tt+" should have errors")
assert.Len(t, res.Errors, 1, tt+" should have 1 error")
}
}
}
// TestValidOpenAPISpec verifies that the open api is added
// at the proper endpoint and the spec is valid.
func TestValidOpenAPISpec(t *testing.T) {
_, etcdserver, config, assert := setUp(t)
defer etcdserver.Terminate(t)
config.GenericConfig.EnableIndex = true
config.GenericConfig.OpenAPIConfig = genericapiserver.DefaultOpenAPIConfig(openapigen.OpenAPIDefinitions)
config.GenericConfig.OpenAPIConfig.Info = &spec.Info{
InfoProps: spec.InfoProps{
Title: "Kubernetes",
Version: "unversioned",
},
}
config.GenericConfig.SwaggerConfig = genericapiserver.DefaultSwaggerConfig()
master, err := config.Complete().New()
if err != nil {
t.Fatalf("Error in bringing up the master: %v", err)
}
// make sure swagger.json is not registered before calling PrepareRun.
server := httptest.NewServer(master.GenericAPIServer.HandlerContainer.ServeMux)
defer server.Close()
resp, err := http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusNotFound, resp.StatusCode)
master.GenericAPIServer.PrepareRun()
resp, err = http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusOK, resp.StatusCode)
// as json schema
var sch spec.Schema
if assert.NoError(decodeResponse(resp, &sch)) {
validator := validate.NewSchemaValidator(spec.MustLoadSwagger20Schema(), nil, "", strfmt.Default)
res := validator.Validate(&sch)
assert.NoError(res.AsError())
}
// Validate OpenApi spec
doc, err := loads.Spec(server.URL + "/swagger.json")
if assert.NoError(err) {
validator := validate.NewSpecValidator(doc.Schema(), strfmt.Default)
res, warns := validator.Validate(doc)
assert.NoError(res.AsError())
if !warns.IsValid() {
t.Logf("Open API spec on root has some warnings : %v", warns)
}
}
}
func TestValidateNonEmptyPathParameterNames(t *testing.T) {
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "empty-path-param-name.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
res := validator.validateNonEmptyPathParamNames()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
}
func TestValidateReferencesValid(t *testing.T) {
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "valid-ref.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateReferencesValid()
assert.Empty(t, res.Errors)
}
doc, err = loads.Spec(filepath.Join("fixtures", "validation", "invalid-ref.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateReferencesValid()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
}
func TestValidateBodyFormDataParams(t *testing.T) {
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "invalid-formdata-body-params.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateDefaultValueValidAgainstSchema()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
}
func TestIssue62(t *testing.T) {
t.SkipNow()
fp := filepath.Join("fixtures", "bugs", "62", "swagger.json")
// as swagger spec
doc, err := loads.Spec(fp)
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
res, _ := validator.Validate(doc)
assert.NotEmpty(t, res.Errors)
assert.True(t, res.HasErrors())
}
}
func TestValidateDuplicatePropertyNames(t *testing.T) {
// simple allOf
doc, err := loads.Spec(filepath.Join("fixtures", "validation", "duplicateprops.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
res := validator.validateDuplicatePropertyNames()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
// nested allOf
doc, err = loads.Spec(filepath.Join("fixtures", "validation", "nestedduplicateprops.json"))
if assert.NoError(t, err) {
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
res := validator.validateDuplicatePropertyNames()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
}
}
// Analyzed creates a new analyzed spec document
func Analyzed(data json.RawMessage, version string) (*Document, error) {
if version == "" {
version = "2.0"
}
if version != "2.0" {
return nil, fmt.Errorf("spec version %q is not supported", version)
}
raw := data
trimmed := bytes.TrimSpace(data)
if len(trimmed) > 0 {
if trimmed[0] != '{' && trimmed[0] != '[' {
yml, err := fmts.BytesToYAMLDoc(trimmed)
if err != nil {
return nil, fmt.Errorf("analyzed: %v", err)
}
d, err := fmts.YAMLToJSON(yml)
if err != nil {
return nil, fmt.Errorf("analyzed: %v", err)
}
raw = d
}
}
swspec := new(spec.Swagger)
if err := json.Unmarshal(raw, swspec); err != nil {
return nil, err
}
origsqspec := new(spec.Swagger)
if err := json.Unmarshal(raw, origsqspec); err != nil {
return nil, err
}
d := &Document{
Analyzer: analysis.New(swspec),
schema: spec.MustLoadSwagger20Schema(),
spec: swspec,
raw: raw,
origSpec: origsqspec,
}
return d, nil
}
func TestValidateRequiredDefinitions(t *testing.T) {
doc, _ := loads.Analyzed(PetStoreJSONMessage, "")
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateRequiredDefinitions()
assert.Empty(t, res.Errors)
// properties
sw := doc.Spec()
def := sw.Definitions["Tag"]
def.Required = append(def.Required, "type")
sw.Definitions["Tag"] = def
res = validator.validateRequiredDefinitions()
assert.NotEmpty(t, res.Errors)
// pattern properties
def.PatternProperties = make(map[string]spec.Schema)
def.PatternProperties["ty.*"] = *spec.StringProperty()
sw.Definitions["Tag"] = def
res = validator.validateRequiredDefinitions()
assert.Empty(t, res.Errors)
def.PatternProperties = make(map[string]spec.Schema)
def.PatternProperties["^ty.$"] = *spec.StringProperty()
sw.Definitions["Tag"] = def
res = validator.validateRequiredDefinitions()
assert.NotEmpty(t, res.Errors)
// additional properties
def.PatternProperties = nil
def.AdditionalProperties = &spec.SchemaOrBool{Allows: true}
sw.Definitions["Tag"] = def
res = validator.validateRequiredDefinitions()
assert.Empty(t, res.Errors)
def.AdditionalProperties = &spec.SchemaOrBool{Allows: false}
sw.Definitions["Tag"] = def
res = validator.validateRequiredDefinitions()
assert.NotEmpty(t, res.Errors)
}
func TestIssue53(t *testing.T) {
fp := filepath.Join("fixtures", "bugs", "53", "noswagger.json")
jstext, _ := ioutil.ReadFile(fp)
// as json schema
var sch spec.Schema
if assert.NoError(t, json.Unmarshal(jstext, &sch)) {
validator := NewSchemaValidator(spec.MustLoadSwagger20Schema(), nil, "", strfmt.Default)
res := validator.Validate(&sch)
assert.False(t, res.IsValid())
assert.EqualError(t, res.Errors[0], ".swagger in body is required")
}
// as swagger spec
doc, err := loads.Spec(fp)
if assert.NoError(t, err) {
validator := NewSpecValidator(doc.Schema(), strfmt.Default)
res, _ := validator.Validate(doc)
if assert.False(t, res.IsValid()) {
assert.EqualError(t, res.Errors[0], ".swagger in body is required")
}
}
}
func TestValidateParameters(t *testing.T) {
doc, _ := loads.Analyzed(PetStoreJSONMessage, "")
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateParameters()
assert.Empty(t, res.Errors)
sw := doc.Spec()
sw.Paths.Paths["/pets"].Get.Parameters = append(sw.Paths.Paths["/pets"].Get.Parameters, *spec.QueryParam("limit").Typed("string", ""))
res = validator.validateParameters()
assert.NotEmpty(t, res.Errors)
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
sw = doc.Spec()
sw.Paths.Paths["/pets"].Post.Parameters = append(sw.Paths.Paths["/pets"].Post.Parameters, *spec.BodyParam("fake", spec.RefProperty("#/definitions/Pet")))
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res = validator.validateParameters()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
assert.Contains(t, res.Errors[0].Error(), "has more than 1 body param")
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
sw = doc.Spec()
pp := sw.Paths.Paths["/pets/{id}"]
pp.Delete = nil
var nameParams []spec.Parameter
for _, p := range pp.Parameters {
if p.Name == "id" {
p.Name = "name"
nameParams = append(nameParams, p)
}
}
pp.Parameters = nameParams
sw.Paths.Paths["/pets/{name}"] = pp
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res = validator.validateParameters()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 1)
assert.Contains(t, res.Errors[0].Error(), "overlaps with")
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
sw = doc.Spec()
pp = sw.Paths.Paths["/pets/{id}"]
pp.Delete = nil
pp.Get.Parameters = nameParams
pp.Parameters = nil
sw.Paths.Paths["/pets/{id}"] = pp
res = validator.validateParameters()
assert.NotEmpty(t, res.Errors)
assert.Len(t, res.Errors, 2)
assert.Contains(t, res.Errors[1].Error(), "is not present in path \"/pets/{id}\"")
assert.Contains(t, res.Errors[0].Error(), "has no parameter definition")
}
// TestValidOpenAPISpec verifies that the open api is added
// at the proper endpoint and the spec is valid.
func TestValidOpenAPISpec(t *testing.T) {
_, etcdserver, config, assert := setUp(t)
defer etcdserver.Terminate(t)
config.GenericConfig.OpenAPIConfig.Definitions = openapigen.OpenAPIDefinitions
config.GenericConfig.EnableOpenAPISupport = true
config.GenericConfig.EnableIndex = true
config.GenericConfig.OpenAPIConfig.Info = &spec.Info{
InfoProps: spec.InfoProps{
Title: "Kubernetes",
Version: "unversioned",
},
}
config.GenericConfig.OpenAPIConfig.GetOperationID = openapi.GetOperationID
master, err := config.Complete().New()
if err != nil {
t.Fatalf("Error in bringing up the master: %v", err)
}
// make sure swagger.json is not registered before calling install api.
server := httptest.NewServer(master.GenericAPIServer.HandlerContainer.ServeMux)
resp, err := http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusNotFound, resp.StatusCode)
master.GenericAPIServer.InstallOpenAPI()
resp, err = http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusOK, resp.StatusCode)
// as json schema
var sch spec.Schema
if assert.NoError(decodeResponse(resp, &sch)) {
validator := validate.NewSchemaValidator(spec.MustLoadSwagger20Schema(), nil, "", strfmt.Default)
res := validator.Validate(&sch)
assert.NoError(res.AsError())
}
// TODO(mehdy): The actual validation part of these tests are timing out on jerkin but passing locally. Enable it after debugging timeout issue.
disableValidation := true
// Saving specs to a temporary folder is a good way to debug spec generation without bringing up an actual
// api server.
saveSwaggerSpecs := false
// Validate OpenApi spec
doc, err := loads.Spec(server.URL + "/swagger.json")
if assert.NoError(err) {
validator := validate.NewSpecValidator(doc.Schema(), strfmt.Default)
if !disableValidation {
res, warns := validator.Validate(doc)
assert.NoError(res.AsError())
if !warns.IsValid() {
t.Logf("Open API spec on root has some warnings : %v", warns)
}
} else {
t.Logf("Validation is disabled because it is timing out on jenkins put passing locally.")
}
}
// validate specs on each end-point
resp, err = http.Get(server.URL)
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusOK, resp.StatusCode)
var list unversioned.RootPaths
if assert.NoError(decodeResponse(resp, &list)) {
for _, path := range list.Paths {
if !strings.HasPrefix(path, "/api") {
continue
}
t.Logf("Validating open API spec on %v ...", path)
if saveSwaggerSpecs {
resp, err = http.Get(server.URL + path + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusOK, resp.StatusCode)
assert.NoError(writeResponseToFile(resp, "/tmp/swagger_"+strings.Replace(path, "/", "_", -1)+".json"))
}
// Validate OpenApi spec on path
doc, err := loads.Spec(server.URL + path + "/swagger.json")
if assert.NoError(err) {
validator := validate.NewSpecValidator(doc.Schema(), strfmt.Default)
if !disableValidation {
res, warns := validator.Validate(doc)
assert.NoError(res.AsError())
if !warns.IsValid() {
t.Logf("Open API spec on %v has some warnings : %v", path, warns)
}
} else {
t.Logf("Validation is disabled because it is timing out on jenkins but passing locally.")
}
}
}
}
}
// TestValidOpenAPISpec verifies that the open api is added
// at the proper endpoint and the spec is valid.
func TestValidOpenAPISpec(t *testing.T) {
_, etcdserver, config, assert := setUp(t)
defer etcdserver.Terminate(t)
config.GenericConfig.OpenAPIConfig.Definitions = openapigen.OpenAPIDefinitions
config.GenericConfig.EnableOpenAPISupport = true
config.GenericConfig.EnableIndex = true
config.GenericConfig.OpenAPIConfig.Info = &spec.Info{
InfoProps: spec.InfoProps{
Title: "Kubernetes",
Version: "unversioned",
},
}
master, err := config.Complete().New()
if err != nil {
t.Fatalf("Error in bringing up the master: %v", err)
}
// make sure swagger.json is not registered before calling PrepareRun.
server := httptest.NewServer(master.GenericAPIServer.HandlerContainer.ServeMux)
defer server.Close()
resp, err := http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusNotFound, resp.StatusCode)
master.GenericAPIServer.PrepareRun()
resp, err = http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusOK, resp.StatusCode)
// as json schema
var sch spec.Schema
if assert.NoError(decodeResponse(resp, &sch)) {
validator := validate.NewSchemaValidator(spec.MustLoadSwagger20Schema(), nil, "", strfmt.Default)
res := validator.Validate(&sch)
assert.NoError(res.AsError())
}
// TODO(mehdy): The actual validation part of these tests are timing out on jerkin but passing locally. Enable it after debugging timeout issue.
disableValidation := true
// Validate OpenApi spec
doc, err := loads.Spec(server.URL + "/swagger.json")
if assert.NoError(err) {
validator := validate.NewSpecValidator(doc.Schema(), strfmt.Default)
if !disableValidation {
res, warns := validator.Validate(doc)
assert.NoError(res.AsError())
if !warns.IsValid() {
t.Logf("Open API spec on root has some warnings : %v", warns)
}
} else {
t.Logf("Validation is disabled because it is timing out on jenkins put passing locally.")
}
}
}
if loaders.Match(specURL.Path) {
b, err2 := loaders.Fn(path)
if err2 != nil {
return nil, err2
}
return Analyzed(b, "")
}
}
b, err := loaders.Fn(path)
if err != nil {
return nil, err
}
return Analyzed(b, "")
}
var swag20Schema = spec.MustLoadSwagger20Schema()
// Analyzed creates a new analyzed spec document
func Analyzed(data json.RawMessage, version string) (*Document, error) {
if version == "" {
version = "2.0"
}
if version != "2.0" {
return nil, fmt.Errorf("spec version %q is not supported", version)
}
swspec := new(spec.Swagger)
if err := json.Unmarshal(data, swspec); err != nil {
return nil, err
}
func TestValidateItems(t *testing.T) {
doc, _ := loads.Analyzed(PetStoreJSONMessage, "")
validator := NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
res := validator.validateItems()
assert.Empty(t, res.Errors)
// in operation parameters
sw := doc.Spec()
sw.Paths.Paths["/pets"].Get.Parameters[0].Type = "array"
res = validator.validateItems()
assert.NotEmpty(t, res.Errors)
sw.Paths.Paths["/pets"].Get.Parameters[0].Items = spec.NewItems().Typed("string", "")
res = validator.validateItems()
assert.Empty(t, res.Errors)
sw.Paths.Paths["/pets"].Get.Parameters[0].Items = spec.NewItems().Typed("array", "")
res = validator.validateItems()
assert.NotEmpty(t, res.Errors)
sw.Paths.Paths["/pets"].Get.Parameters[0].Items.Items = spec.NewItems().Typed("string", "")
res = validator.validateItems()
assert.Empty(t, res.Errors)
// in global parameters
sw.Parameters = make(map[string]spec.Parameter)
sw.Parameters["other"] = *spec.SimpleArrayParam("other", "array", "csv")
res = validator.validateItems()
assert.Empty(t, res.Errors)
//pp := spec.SimpleArrayParam("other", "array", "")
//pp.Items = nil
//sw.Parameters["other"] = *pp
//res = validator.validateItems()
//assert.NotEmpty(t, res.Errors)
// in shared path object parameters
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
sw = doc.Spec()
pa := sw.Paths.Paths["/pets"]
pa.Parameters = []spec.Parameter{*spec.SimpleArrayParam("another", "array", "csv")}
sw.Paths.Paths["/pets"] = pa
res = validator.validateItems()
assert.Empty(t, res.Errors)
pa = sw.Paths.Paths["/pets"]
pp := spec.SimpleArrayParam("other", "array", "")
pp.Items = nil
pa.Parameters = []spec.Parameter{*pp}
sw.Paths.Paths["/pets"] = pa
res = validator.validateItems()
assert.NotEmpty(t, res.Errors)
// in body param schema
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
sw = doc.Spec()
pa = sw.Paths.Paths["/pets"]
pa.Post.Parameters[0].Schema = spec.ArrayProperty(nil)
res = validator.validateItems()
assert.NotEmpty(t, res.Errors)
// in response headers
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
sw = doc.Spec()
pa = sw.Paths.Paths["/pets"]
rp := pa.Post.Responses.StatusCodeResponses[200]
var hdr spec.Header
hdr.Type = "array"
rp.Headers = make(map[string]spec.Header)
rp.Headers["X-YADA"] = hdr
pa.Post.Responses.StatusCodeResponses[200] = rp
res = validator.validateItems()
assert.NotEmpty(t, res.Errors)
// in response schema
doc, _ = loads.Analyzed(PetStoreJSONMessage, "")
validator = NewSpecValidator(spec.MustLoadSwagger20Schema(), strfmt.Default)
validator.spec = doc
validator.analyzer = analysis.New(doc.Spec())
sw = doc.Spec()
pa = sw.Paths.Paths["/pets"]
rp = pa.Post.Responses.StatusCodeResponses[200]
rp.Schema = spec.ArrayProperty(nil)
pa.Post.Responses.StatusCodeResponses[200] = rp
res = validator.validateItems()
assert.NotEmpty(t, res.Errors)
}
// TestValidOpenAPISpec verifies that the open api is added
// at the proper endpoint and the spec is valid.
func TestValidOpenAPISpec(t *testing.T) {
_, etcdserver, config, assert := setUp(t)
defer etcdserver.Terminate(t)
config.EnableOpenAPISupport = true
config.OpenAPIInfo = spec.Info{
InfoProps: spec.InfoProps{
Title: "Kubernetes",
Version: "unversioned",
},
}
master, err := New(&config)
if err != nil {
t.Fatalf("Error in bringing up the master: %v", err)
}
// make sure swagger.json is not registered before calling install api.
server := httptest.NewServer(master.HandlerContainer.ServeMux)
resp, err := http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusNotFound, resp.StatusCode)
master.InstallOpenAPI()
resp, err = http.Get(server.URL + "/swagger.json")
if !assert.NoError(err) {
t.Errorf("unexpected error: %v", err)
}
assert.Equal(http.StatusOK, resp.StatusCode)
// as json schema
var sch spec.Schema
if assert.NoError(decodeResponse(resp, &sch)) {
validator := validate.NewSchemaValidator(spec.MustLoadSwagger20Schema(), nil, "", strfmt.Default)
res := validator.Validate(&sch)
assert.NoError(res.AsError())
}
// Validate OpenApi spec
doc, err := loads.Spec(server.URL + "/swagger.json")
if assert.NoError(err) {
// TODO(mehdy): This test is timing out on jerkin but passing locally. Enable it after debugging timeout issue.
_ = validate.NewSpecValidator(doc.Schema(), strfmt.Default)
// res, _ := validator.Validate(doc)
// assert.NoError(res.AsError())
}
}