func (r RequestInfo) ToSwagger() swagger.Method {
ret := swagger.Method{
Description: r.Description,
Responses: map[string]swagger.Response{},
Parameters: nil,
Tags: []string{strings.Title(r.Group)},
}
if len(r.Params) > 0 {
ret.Parameters = make([]swagger.Param, 0)
}
for _, p := range r.Params {
if !p.Hidden {
ret.Parameters = append(ret.Parameters, p.ToSwagger())
}
}
if r.Returns != nil {
s := jsonschema.Reflect(r.Returns)
ret.Responses["default"] = swagger.Response{
Description: reflect.TypeOf(r.Returns).String(),
Schema: swagger.Schema(s),
}
} else {
ret.Responses["default"] = swagger.Response{"", jsonschema.Reflect("")}
}
return ret
}
func generateSpecSchema(item interface{}, defs spec.Definitions) *spec.Schema {
refl := jsonschema.Reflect(item)
schema := specSchemaFromJsonType(refl.Type)
schema.Definitions = map[string]spec.Schema{}
for name, def := range refl.Definitions {
defs[name] = *specSchemaFromJsonType(def)
}
return schema
}
func (g *ramlGenerator) Generate(tests []IApiTest) ([]byte, error) {
doc := g.seed // copy seed
for _, test := range tests {
// path MUST begin with '/'
path := test.Path()
if path[0] != '/' {
path = "/" + path
}
resource, ok := doc.Resources[path]
if !ok { // new resource created by default
resource.UriParameters = map[string]raml.NamedParameter{}
}
m := raml.Method{
Responses: map[raml.HTTPCode]raml.Response{},
Headers: map[raml.HTTPHeader]raml.Header{},
QueryParameters: map[string]raml.NamedParameter{},
Description: test.Description(),
Name: test.Method(),
}
processedHeaderParams := map[string]interface{}{}
processedPathParams := map[string]interface{}{}
processedQueryParams := map[string]interface{}{}
for _, testCase := range test.TestCases() {
m.Description = testCase.Description
for key, param := range testCase.PathParams {
if _, ok := processedPathParams[key]; ok {
continue
}
uriParam := generateRamlNamedParameter(key, param)
processedPathParams[key] = nil
resource.UriParameters[key] = uriParam
}
for key, param := range testCase.Headers {
if _, ok := processedHeaderParams[key]; ok {
continue
}
h := generateRamlNamedParameter(key, param)
m.Headers[raml.HTTPHeader(key)] = raml.Header(h)
processedHeaderParams[key] = nil
}
for key, param := range testCase.QueryParams {
if _, ok := processedQueryParams[key]; ok {
continue
}
queryParam := generateRamlNamedParameter(key, param)
processedQueryParams[key] = nil
m.QueryParameters[key] = queryParam
}
response := raml.Response{}
response.Description = testCase.Description
response.HTTPCode = raml.HTTPCode(testCase.ExpectedHttpCode)
if testCase.ExpectedData != nil {
schema := jsonschema.Reflect(testCase.ExpectedData)
// TODO: marshal data according to MIME type, coming soon with RAML 1.0
schemaBytes, _ := json.MarshalIndent(schema, "", " ")
response.Bodies.DefaultSchema = string(schemaBytes)
// TODO: marshal data according to MIME type, coming soon with RAML 1.0
exampleBytes, _ := json.MarshalIndent(testCase.ExpectedData, "", " ")
response.Bodies.DefaultExample = string(exampleBytes)
}
m.Responses[raml.HTTPCode(testCase.ExpectedHttpCode)] = response
}
// TODO: check if path has already assigned an method to some other test
// return error if so
switch test.Method() {
case "GET":
resource.Get = &m
case "POST":
resource.Post = &m
case "PATCH":
resource.Patch = &m
case "DELETE":
resource.Delete = &m
case "PUT":
resource.Put = &m
case "HEAD":
resource.Head = &m
}
doc.Resources[path] = resource
}
generatedDoc, err := yaml.Marshal(doc)
if err == nil {
header := []byte(fmt.Sprintf("#%%RAML %s\n", doc.RAMLVersion))
generatedDoc = append(header, generatedDoc...)
}
return generatedDoc, err
}