Merge pull request #19 from neotoolkit/fix/requestbodies-comp

fix(openapi): change RequestBodies obj

components.go

@@ -2,6 +2,6 @@ package openapi
 
 // Components -.
 type Components struct {
-	Schemas       Schemas `json:"schemas,omitempty" yaml:"schemas,omitempty"`
-	RequestBodies Schemas `json:"requestBodies,omitempty" yaml:"requestBodies,omitempty"`
+	Schemas       Schemas       `json:"schemas,omitempty" yaml:"schemas,omitempty"`
+	RequestBodies RequestBodies `json:"requestBodies,omitempty" yaml:"requestBodies,omitempty"`
 }

openapi.go

@@ -14,6 +14,16 @@ func (e *SchemaError) Error() string {
 	return "unknown schema " + e.Ref
 }
 
+// RequestBodyError -.
+type RequestBodyError struct {
+	Ref string
+}
+
+// Error -.
+func (e *RequestBodyError) Error() string {
+	return "unknown request body " + e.Ref
+}
+
 // OpenAPI Object
 // See specification https://swagger.io/specification/#openapi-object
 type OpenAPI struct {
@@ -26,19 +36,23 @@ type OpenAPI struct {
 	Info       Info       `json:"info" yaml:"info"`
 }
 
-// LookupByReference -.
-func (api OpenAPI) LookupByReference(ref string) (Schema, error) {
+// LookupSchemaByReference -.
+func (api OpenAPI) LookupSchemaByReference(ref string) (Schema, error) {
 	schema, ok := api.Components.Schemas[schemaKey(ref)]
 	if ok {
 		return *schema, nil
 	}
 
-	schema, ok = api.Components.RequestBodies[requestBodiesKey(ref)]
+	return Schema{}, &SchemaError{Ref: ref}
+}
+
+func (api OpenAPI) LookupRequestBodyByReference(ref string) (RequestBody, error) {
+	requestBody, ok := api.Components.RequestBodies[requestBodiesKey(ref)]
 	if ok {
-		return *schema, nil
+		return *requestBody, nil
 	}
 
-	return Schema{}, &SchemaError{Ref: ref}
+	return RequestBody{}, &RequestBodyError{Ref: ref}
 }
 
 func schemaKey(ref string) string {

openapi_test.go

@@ -20,10 +20,29 @@ func TestSchemaError(t *testing.T) {
 func TestLookupByReference(t *testing.T) {
 	api := openapi.OpenAPI{}
 
-	schema, err := api.LookupByReference("")
+	schema, err := api.LookupSchemaByReference("")
 
 	var schemaErr *openapi.SchemaError
 
 	require.Equal(t, openapi.Schema{}, schema)
 	require.True(t, errors.As(err, &schemaErr))
 }
+
+func TestRequestBodyError(t *testing.T) {
+	got := &openapi.RequestBodyError{
+		Ref: "test",
+	}
+
+	require.Equal(t, got.Error(), "unknown request body test")
+}
+
+func TestLookupRequestBodyByReference(t *testing.T) {
+	api := openapi.OpenAPI{}
+
+	schema, err := api.LookupRequestBodyByReference("")
+
+	var requestBodyErr *openapi.RequestBodyError
+
+	require.Equal(t, openapi.RequestBody{}, schema)
+	require.True(t, errors.As(err, &requestBodyErr))
+}

requestbody.go

@@ -7,3 +7,6 @@ type RequestBody struct {
 	Content     Content `json:"content,omitempty" yaml:"content,omitempty"`
 	Ref         string  `json:"$ref,omitempty" yaml:"$ref,omitempty"`
 }
+
+// RequestBodies -.
+type RequestBodies map[string]*RequestBody

schema.go

@@ -27,13 +27,13 @@ type Schemas map[string]*Schema
 
 // SchemaContext -.
 type SchemaContext interface {
-	LookupByReference(ref string) (Schema, error)
+	LookupSchemaByReference(ref string) (Schema, error)
 }
 
 // ResponseByExample -.
 func (s Schema) ResponseByExample(schemaContext SchemaContext) (interface{}, error) {
 	if s.Ref != "" {
-		schema, err := schemaContext.LookupByReference(s.Ref)
+		schema, err := schemaContext.LookupSchemaByReference(s.Ref)
 		if err != nil {
 			return nil, fmt.Errorf("lookup: %w", err)
 		}

schema_test.go

@@ -11,7 +11,7 @@ import (
 
 type schemaContextStub struct{}
 
-func (s schemaContextStub) LookupByReference(ref string) (openapi.Schema, error) {
+func (s schemaContextStub) LookupSchemaByReference(ref string) (openapi.Schema, error) {
 	userSchema := openapi.Schema{
 		Properties: openapi.Schemas{
 			"id": &openapi.Schema{