func (ss *setOpResponses) Parse(lines []string) error { if len(lines) == 0 || (len(lines) == 1 && len(lines[0]) == 0) { return nil } var def *spec.Response var scr map[int]spec.Response for _, line := range lines { kv := strings.SplitN(line, ":", 2) var key, value string if len(kv) > 1 { key = strings.TrimSpace(kv[0]) if key == "" { // this must be some weird empty line continue } value = strings.TrimSpace(kv[1]) if value == "" { var resp spec.Response if strings.EqualFold("default", key) { if def == nil { def = &resp } } else { if sc, err := strconv.Atoi(key); err == nil { if scr == nil { scr = make(map[int]spec.Response) } scr[sc] = resp } } continue } var arrays int for strings.HasPrefix(value, "[]") { arrays++ value = value[2:] } var isDefinitionRef bool var ref spec.Ref var err error if arrays == 0 { if strings.HasPrefix(value, "body:") { isDefinitionRef = true ref, err = spec.NewRef("#/definitions/" + value[5:]) } else { ref, err = spec.NewRef("#/responses/" + value) } } else { isDefinitionRef = true ref, err = spec.NewRef("#/definitions/" + value) } if err != nil { return err } if _, ok := ss.responses[value]; !ok { if _, ok := ss.definitions[value]; ok { isDefinitionRef = true ref, err = spec.NewRef("#/definitions/" + value) } } else { } if err != nil { return err } var resp spec.Response if !isDefinitionRef { resp.Ref = ref } else { resp.Schema = new(spec.Schema) if arrays == 0 { resp.Schema.Ref = ref } else { cs := resp.Schema for i := 0; i < arrays; i++ { cs.Typed("array", "") cs.Items = new(spec.SchemaOrArray) cs.Items.Schema = new(spec.Schema) cs = cs.Items.Schema } cs.Ref = ref } } if strings.EqualFold("default", key) { if def == nil { def = &resp } } else { if sc, err := strconv.Atoi(key); err == nil { if scr == nil { scr = make(map[int]spec.Response) } scr[sc] = resp } } } } ss.set(def, scr) return nil }
func (g *swaggerGenerator) generateSwaggerOperation(test IApiTest, defs spec.Definitions) (spec.Operation, error) { op := spec.Operation{} op.Responses = &spec.Responses{} op.Responses.StatusCodeResponses = map[int]spec.Response{} var description string processedQueryParams := map[string]interface{}{} processedPathParams := map[string]interface{}{} processedHeaderParams := map[string]interface{}{} for _, testCase := range test.TestCases() { // parameter definitions are collected from 2xx tests only if testCase.ExpectedHttpCode >= 200 && testCase.ExpectedHttpCode < 300 { description = testCase.Description for key, param := range testCase.Headers { if _, ok := processedHeaderParams[key]; ok { continue } specParam, err := generateSwaggerSpecParam(key, param, "header") if err != nil { return op, err } processedHeaderParams[key] = nil op.Parameters = append(op.Parameters, specParam) } for key, param := range testCase.PathParams { if _, ok := processedPathParams[key]; ok { continue } param.Required = true // path parameters are always required specParam, err := generateSwaggerSpecParam(key, param, "path") if err != nil { return op, err } processedPathParams[key] = nil op.Parameters = append(op.Parameters, specParam) } for key, param := range testCase.QueryParams { if _, ok := processedQueryParams[key]; ok { continue } specParam, err := generateSwaggerSpecParam(key, param, "query") if err != nil { return op, err } processedQueryParams[key] = nil op.Parameters = append(op.Parameters, specParam) } if testCase.RequestBody != nil { specParam := spec.Parameter{} specParam.Name = "body" specParam.In = "body" specParam.Required = true // TODO: right now it supports json, but should support marshaller depending on MIME type if content, err := json.MarshalIndent(testCase.RequestBody, "", " "); err == nil { specParam.Description = string(content) } specParam.Schema = generateSpecSchema(testCase.RequestBody, defs) op.Parameters = append(op.Parameters, specParam) } } response := spec.Response{} response.Description = testCase.Description if testCase.ExpectedData != nil { response.Schema = generateSpecSchema(testCase.ExpectedData, defs) response.Examples = map[string]interface{}{ "application/json": testCase.ExpectedData, } } op.Responses.StatusCodeResponses[testCase.ExpectedHttpCode] = response } op.Summary = description if taggable, ok := test.(ITaggable); ok { op.Tags = []string{taggable.Tag()} } return op, nil }