Added support for Parameters

Author: padiazg

build-map-keys.go

@@ -23,4 +23,7 @@ const (
 	keyFlows            = "flows"
 	keyAuthorizationURL = "authorizationUrl"
 	keyScopes           = "scopes"
+	keyParameters       = "parameters"
+	keyRequired         = "required"
+	keySchema           = "schema"
 )

build.go

@@ -64,6 +64,7 @@ func (oas *OAS) BuildStream(w io.Writer) error {
 	if err != nil {
 		return fmt.Errorf("writing issue occurred: %w", err)
 	}
+
 	return nil
 }
 
@@ -157,6 +158,7 @@ func makeAllPathsMap(paths *Paths) pathsMap {
 		pathMap[keySecurity] = makeSecurityMap(&path.Security)
 		pathMap[keyRequestBody] = makeRequestBodyMap(&path.RequestBody)
 		pathMap[keyResponses] = makeResponsesMap(&path.Responses)
+		pathMap[keyParameters] = makeParametersMap(&path.Parameters)
 
 		allPaths[path.Route][strings.ToLower(path.HTTPMethod)] = pathMap
 	}
@@ -345,3 +347,40 @@ const emptyStr = ""
 func isStrEmpty(s string) bool {
 	return s == emptyStr
 }
+
+func makeParametersMap(parameters *Parameters) []map[string]interface{} {
+	parametersMap := []map[string]interface{}{}
+
+	for _, param := range *parameters {
+		paramMap := make(map[string]interface{})
+
+		paramMap[keyName] = param.Name
+		paramMap[keyIn] = param.In
+		paramMap[keyDescription] = param.Description
+		paramMap[keyRequired] = param.Required
+		paramMap[keySchema] = makeSchemaMap(&param.Schema)
+
+		parametersMap = append(parametersMap, paramMap)
+	}
+
+	return parametersMap
+}
+
+func makeSchemaMap(schema *Schema) map[string]interface{} {
+	schemaMap := make(map[string]interface{})
+
+	if !isStrEmpty(schema.Ref) {
+		schemaMap[keyRef] = schema.Ref
+	} else {
+		schemaMap[keyName] = schema.Name
+		schemaMap[keyType] = schema.Type
+		if len(schema.Properties) > 0 {
+			schemaMap[keyProperties] = makePropertiesMap(&schema.Properties)
+		}
+		if schema.XML.Name != "" {
+			schemaMap[keyXML] = map[string]interface{}{"name": schema.XML.Name}
+		}
+	}
+
+	return schemaMap
+}

build_test.go

@@ -2,9 +2,59 @@ package docs
 
 import (
 	"bytes"
+	"reflect"
 	"testing"
 )
 
+const (
+	buildStreamTestWant = `openapi: 3.0.1
+info:
+    title: Test
+    description: Test object
+    termsOfService: ""
+    contact:
+        email: ""
+    license:
+        name: ""
+        url: ""
+    version: ""
+externalDocs:
+    description: ""
+    url: ""
+servers: []
+tags: []
+paths: {}
+components:
+    schemas:
+        schema_testing:
+            properties:
+                EnumProp:
+                    description: short desc
+                    enum:
+                        - enum
+                        - test
+                        - strSlc
+                    type: enum
+                intProp:
+                    default: 1337
+                    description: short desc
+                    format: int64
+                    type: integer
+            type: ""
+            xml:
+                name: XML entry test
+    securitySchemes:
+        ses_scheme_testing:
+            flows:
+                implicit:
+                    authorizationUrl: http://petstore.swagger.io/oauth/dialog
+                    scopes:
+                        read:pets: Read Pets
+                        write:pets: Write to Pets
+            in: not empty
+`
+)
+
 func TestUnitBuild(t *testing.T) {
 	t.Parallel()
 
@@ -114,6 +164,8 @@ func TestUnitGetPathFromFirstElem(t *testing.T) {
 // QUICK CHECK TESTS ARE COMING WITH NEXT RELEASE.
 
 func TestOAS_BuildStream(t *testing.T) {
+	t.Parallel()
+
 	tests := []struct {
 		name    string
 		oas     *OAS
@@ -124,27 +176,19 @@ func TestOAS_BuildStream(t *testing.T) {
 			name: "success",
 			oas: &OAS{
 				OASVersion: "3.0.1",
-				Info: Info{
-					Title:       "Test",
-					Description: "Test object",
-				},
+				Info:       Info{Title: "Test", Description: "Test object"},
 				Components: Components{
 					Component{
 						Schemas: Schemas{Schema{
 							Name: "schema_testing",
 							Properties: SchemaProperties{
 								SchemaProperty{
-									Name:        "EnumProp",
-									Type:        "enum",
-									Description: "short desc",
-									Enum:        []string{"enum", "test", "strSlc"},
+									Name: "EnumProp", Type: "enum", Description: "short desc",
+									Enum: []string{"enum", "test", "strSlc"},
 								},
 								SchemaProperty{
-									Name:        "intProp",
-									Type:        "integer",
-									Format:      "int64",
-									Description: "short desc",
-									Default:     1337,
+									Name: "intProp", Type: "integer", Format: "int64",
+									Description: "short desc", Default: 1337,
 								},
 							},
 							XML: XMLEntry{Name: "XML entry test"},
@@ -156,79 +200,134 @@ func TestOAS_BuildStream(t *testing.T) {
 								Type:    "implicit",
 								AuthURL: "http://petstore.swagger.io/oauth/dialog",
 								Scopes: SecurityScopes{
-									SecurityScope{
-										Name:        "write:pets",
-										Description: "Write to Pets",
-									},
-									SecurityScope{
-										Name:        "read:pets",
-										Description: "Read Pets",
-									},
+									SecurityScope{Name: "write:pets", Description: "Write to Pets"},
+									SecurityScope{Name: "read:pets", Description: "Read Pets"},
 								},
 							}},
 						}},
 					},
 				},
 			},
 			wantErr: false,
-			wantW: `openapi: 3.0.1
-info:
-    title: Test
-    description: Test object
-    termsOfService: ""
-    contact:
-        email: ""
-    license:
-        name: ""
-        url: ""
-    version: ""
-externalDocs:
-    description: ""
-    url: ""
-servers: []
-tags: []
-paths: {}
-components:
-    schemas:
-        schema_testing:
-            $ref: ""
-            properties:
-                EnumProp:
-                    description: short desc
-                    enum:
-                        - enum
-                        - test
-                        - strSlc
-                    type: enum
-                intProp:
-                    default: 1337
-                    description: short desc
-                    format: int64
-                    type: integer
-            type: ""
-            xml:
-                name: XML entry test
-    securitySchemes:
-        ses_scheme_testing:
-            flows:
-                implicit:
-                    authorizationUrl: http://petstore.swagger.io/oauth/dialog
-                    scopes:
-                        read:pets: Read Pets
-                        write:pets: Write to Pets
-            in: not empty
-`,
+			wantW:   buildStreamTestWant,
 		},
 	}
+
 	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
+		trn := tt
+
+		t.Run(trn.name, func(t *testing.T) {
+			t.Parallel()
+
 			w := &bytes.Buffer{}
-			if err := tt.oas.BuildStream(w); (err != nil) != tt.wantErr {
-				t.Errorf("OAS.BuildStream() error = %v, wantErr %v", err, tt.wantErr)
+			if err := trn.oas.BuildStream(w); (err != nil) != trn.wantErr {
+				t.Errorf("OAS.BuildStream() error = %v, wantErr %v", err, trn.wantErr)
 				return
 			}
-			if gotW := w.String(); gotW != tt.wantW {
-				t.Errorf("OAS.BuildStream() = [%v], want {%v}", gotW, tt.wantW)
+			if gotW := w.String(); gotW != trn.wantW {
+				t.Errorf("OAS.BuildStream() = [%v], want {%v}", gotW, trn.wantW)
+			}
+		})
+	}
+}
+
+func Test_makeParametersMap(t *testing.T) {
+	type args struct {
+		parameters *Parameters
+	}
+	tests := []struct {
+		name string
+		args args
+		want []map[string]interface{}
+	}{
+		{
+			name: "success-minimal",
+			args: args{
+				parameters: &Parameters{{
+					Name:        "id",
+					In:          "path",
+					Description: "test",
+					Required:    true,
+					Schema:      Schema{Name: "id", Type: "integer"},
+				}},
+			},
+			want: []map[string]interface{}{{
+				"name":        "id",
+				"in":          "path",
+				"description": "test",
+				"required":    true,
+				"schema":      map[string]interface{}{"name": "id", "type": "integer"},
+			}},
+		},
+		{
+			name: "success-full",
+			args: args{
+				parameters: &Parameters{{
+					Name:        "id",
+					In:          "path",
+					Description: "test",
+					Required:    true,
+					Schema: Schema{
+						Name:       "id",
+						Type:       "integer",
+						Properties: SchemaProperties{{Name: "id", Type: "integer"}},
+					},
+				}},
+			},
+			want: []map[string]interface{}{{
+				"name":        "id",
+				"in":          "path",
+				"description": "test",
+				"required":    true,
+				"schema": map[string]interface{}{"name": "id", "type": "integer",
+					"properties": map[string]interface{}{
+						"id": map[string]interface{}{"type": "integer"},
+					}},
+			}},
+		},
+		{
+			name: "success-ref",
+			args: args{
+				parameters: &Parameters{{
+					Name:        "id",
+					In:          "path",
+					Description: "test",
+					Required:    true,
+					Schema:      Schema{Ref: "$some-ref"},
+				}},
+			},
+			want: []map[string]interface{}{{
+				"name":        "id",
+				"in":          "path",
+				"description": "test",
+				"required":    true,
+				"schema":      map[string]interface{}{"$ref": "$some-ref"},
+			}},
+		},
+		{
+			name: "success-xml-entry",
+			args: args{
+				parameters: &Parameters{{
+					Name:        "id",
+					In:          "path",
+					Description: "test",
+					Required:    true,
+					Schema:      Schema{Name: "id", Type: "integer", XML: XMLEntry{Name: "id"}},
+				}},
+			},
+			want: []map[string]interface{}{{
+				"name":        "id",
+				"in":          "path",
+				"description": "test",
+				"required":    true,
+				"schema":      map[string]interface{}{"name": "id", "type": "integer", "xml": map[string]interface{}{"name": "id"}},
+			}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := makeParametersMap(tt.args.parameters); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("makeParametersMap() = %+v, want %+v", got, tt.want)
 			}
 		})
 	}

models.go

@@ -103,6 +103,7 @@ type Path struct {
 	RequestBody     RequestBody      `yaml:"requestBody"`
 	Responses       Responses        `yaml:"responses"`
 	Security        SecurityEntities `yaml:"security,omitempty"`
+	Parameters      Parameters       `yaml:"parameters,omitempty"`
 	HandlerFuncName string           `yaml:"-"`
 }
 
@@ -210,6 +211,22 @@ type SecurityScope struct {
 	Description string `yaml:"description,omitempty"`
 }
 
+// Parameters
+type Parameters []Parameter
+
+type Parameter struct {
+	// If in is "path", the name field MUST correspond to a template expression occurring within the path field in the Paths Object. See Path Templating for further information.
+	// If in is "header" and the name field is "Accept", "Content-Type" or "Authorization", the parameter definition SHALL be ignored.
+	// For all other cases, the name corresponds to the parameter name used by the in property.
+	Name            string `yaml:"name,omitempty"`
+	In              string `yaml:"in,omitempty"` // "query", "header", "path" or "cookie".
+	Description     string `yaml:"description,omitempty"`
+	Required        bool   `yaml:"required,omitempty"`
+	Deprecated      bool   `yaml:"deprecated,omitempty"`
+	AllowEmptyValue bool   `yaml:"allowEmptyValue,omitempty"`
+	Schema          Schema
+}
+
 // isEmpty checks if *ExternalDocs struct is empty.
 func (ed *ExternalDocs) isEmpty() bool {
 	if ed == nil {