Issue swagger-api#1078

Adds support for content vs schema when describing more complex parameter definitionsa

Author: Darrell May

modules/swagger-parser-v3/src/main/java/io/swagger/v3/parser/processors/ParameterProcessor.java

@@ -143,8 +143,25 @@ public List<Parameter> processParameters(List<Parameter> parameters) {
             if(schema != null){
                 schemaProcessor.processSchema(schema);
             }
+            else if(parameter.getContent() != null){
+                Map<String,MediaType> content = parameter.getContent();
+                for( String mediaName : content.keySet()) {
+                    MediaType mediaType = content.get(mediaName);
+                    if(mediaType.getSchema()!= null) {
+                        schema = mediaType.getSchema();
+                        if (schema != null) {
+                            schemaProcessor.processSchema(schema);
+                        }
+                    }
+                    if(mediaType.getExamples() != null) {
+                        for(Example ex: mediaType.getExamples().values()){
+                            exampleProcessor.processExample(ex);
+                        }
+                    }
+                }
+            }
         }
 
         return processedPathLevelParameters;
     }
-}
+}

modules/swagger-parser-v3/src/test/java/io/swagger/v3/parser/processors/ParameterProcessorTest.java

@@ -42,15 +42,23 @@ public void testProcessParameters_TypesThatAreNotRefOrBody(@Injectable final Hea
                                                                @Injectable final PathParameter pathParameter) throws Exception {
         expectedModelProcessorCreation();
         new Expectations() {
-            {
+            {       
                 headerParameter.getSchema();
                 result = null;
+                headerParameter.getContent();
+                result = null;
                 queryParameter.getSchema();
                 result = null;
+                queryParameter.getContent();
+                result = null;
                 cookieParameter.getSchema();
                 result = null;
+                cookieParameter.getContent();
+                result = null;
                 pathParameter.getSchema();
                 result = null;
+                pathParameter.getContent();
+                result = null;
             }
         };
         final List<Parameter> processedParameters = new ParameterProcessor(cache, openAPI)
@@ -90,6 +98,8 @@ public void testProcessParameters_RefToHeader(
             {
                 resolvedHeaderParam.getSchema();
                 result = null;
+                resolvedHeaderParam.getContent();
+                result = null;
             }
         };
 

modules/swagger-parser-v3/src/test/java/io/swagger/v3/parser/test/OpenAPIV3ParserTest.java

@@ -11,6 +11,7 @@
 import io.swagger.v3.oas.models.Components;
 import io.swagger.v3.oas.models.OpenAPI;
 import io.swagger.v3.oas.models.Operation;
+import io.swagger.v3.oas.models.Paths;
 import io.swagger.v3.oas.models.PathItem;
 import io.swagger.v3.oas.models.headers.Header;
 import io.swagger.v3.oas.models.links.Link;
@@ -1869,7 +1870,71 @@ public void shouldParseApiWithMultipleParameterReferences() {
 
     }
 
+    @Test
+    public void shouldParseApiWithParametersUsingContentvsSchema() {
+    	// Tests that the content method of specifying the format of a parameter
+    	// gets resolved.
+    	// Test checks if an API's single parameter of array type gets fully resolved to 
+    	// referenced definitions.
+        String location = "src/test/resources/issue-1078/api.yaml";
+        ParseOptions options = new ParseOptions();
+        options.setResolve(true);
+        // This test uses an Array in the parameters, test if it get's fully resolved.
+        options.setResolveFully(true);
+        OpenAPIV3Parser tested = new OpenAPIV3Parser();
+        
+        // Parse yaml
+        SwaggerParseResult result = tested.readLocation(location, emptyList(), options);
+
+        OpenAPI api = result.getOpenAPI();
+        Paths paths = api.getPaths();
+
+        // First ensure all schemas were resolved, this is important when this library 
+        // is used to generate code
+        Components components = api.getComponents();
+        assertNotNull(components);
+        assertThat(components.getSchemas().size(), equalTo(4));
+        assertNotNull(components.getSchemas().get("LocationType"));
+        assertNotNull(components.getSchemas().get("Lat"));
+        assertNotNull(components.getSchemas().get("Long"));
+        assertNotNull(components.getSchemas().get("SearchResult"));
+        
+        PathItem apiEndpoint = paths.get("/api-endpoint-1");
+        List<Parameter> parameters = apiEndpoint.getGet().getParameters();
+        
+        // Ensure there's only one parameter in this test
+        assertThat(parameters.size(), equalTo(1));
+        
+        // We are testing content for a parameter so make sure its there.
+        Content content = parameters.get(0).getContent();
+        assertNotNull(content);
+        // spec says only one content is permitted in 3.x
+        assertThat( content.size(), equalTo(1));
+
+        // Ensure there's a media type
+        MediaType mediaType = content.entrySet().iterator().next().getValue();
+        assertNotNull(mediaType);
+
+        // This test has a single parameter of type array
+        Schema parameterSchema = mediaType.getSchema();
+        Assert.assertTrue(parameterSchema instanceof ArraySchema);
+        ArraySchema arraySchema = (ArraySchema)parameterSchema;
+
+        // Test if the item schema was resolved properly
+        Schema itemSchema = arraySchema.getItems();
+        assertNotNull(itemSchema);
+        Assert.assertTrue(itemSchema instanceof ObjectSchema);
+
+        // Ensure the referenced item's schema has been resolved.
+        ObjectSchema objSchema = (ObjectSchema)itemSchema;
+        Map<String, Schema> objectItemSchemas = objSchema.getProperties();
+        assertThat( objectItemSchemas.size(), equalTo(2));
+        Assert.assertTrue(objectItemSchemas.get("lat") instanceof IntegerSchema);
+        Assert.assertTrue(objectItemSchemas.get("long") instanceof IntegerSchema);
+        
+    }
+
     private static int getDynamicPort() {
         return new Random().ints(10000, 20000).findFirst().getAsInt();
     }
-}
+}

modules/swagger-parser-v3/src/test/resources/issue-1078/api.yaml

@@ -0,0 +1,33 @@
+openapi: 3.0.0
+info:
+  version: '1.0.0'
+  title: 'Simple Test'
+  description: 'Test of schema vs content for Query Parameters'
+
+paths:
+  /api-endpoint-1:
+    get:
+      summary: Test Service API Endpoint 1
+      operationId: SimpleTestEndpoint1
+      tags:
+        - SimpleTestEndpoint(1)
+      parameters:
+        - name: target-locations-list
+          in: query
+          description: list of locations to search near
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: './common.yaml#/components/schemas/LocationType'
+                minItems: 1
+      responses:
+        '200':
+          description: Expected response to a valid request
+          content:
+            application/json:
+              schema:
+                $ref: './common.yaml#/components/schemas/SearchResult'
+        '404':
+          $ref: './common.yaml#/components/responses/404'

modules/swagger-parser-v3/src/test/resources/issue-1078/common.yaml

@@ -0,0 +1,43 @@
+openapi: 3.0.0
+info:
+  version: '1.0.0'
+  title: 'Common Data Types'
+  description: 'Common Data Types for Test'
+
+paths: {}
+components:
+  schemas:
+
+    LocationType:
+      type: object
+      properties:
+        lat:
+          $ref: '#/components/schemas/Lat'
+        long:
+          $ref: '#/components/schemas/Long'
+      required:
+        - lat
+        - long
+
+    Lat:
+      type: integer
+    Long:
+      type: integer
+
+    SearchResult:
+      type: object
+      required:
+        - simpleTestResults
+      properties:
+        resultId:
+          type: integer
+        simpleTestResults:
+          type: array
+          items:
+            type: string
+
+
+  responses:
+    '404':
+      description: Not Found
+      type: string