OpenAPI: Parameter examples and SecurityRequirement

jknack · jknack · commit 633b3863e1e0 · 2020-03-23T16:11:12.000-03:00
fix #1591
diff --git a/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/OpenApiParser.java b/modules/jooby-openapi/src/main/java/io/jooby/internal/openapi/OpenApiParser.java
@@ -15,13 +15,17 @@
 import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.security.SecurityRequirements;
+import io.swagger.v3.oas.models.examples.Example;
 import io.swagger.v3.oas.models.headers.Header;
 import io.swagger.v3.oas.models.media.ComposedSchema;
 import io.swagger.v3.oas.models.media.StringSchema;
+import io.swagger.v3.oas.models.security.SecurityRequirement;
 import org.objectweb.asm.Type;
 import org.objectweb.asm.tree.AnnotationNode;
 import org.objectweb.asm.tree.MethodNode;
 
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -30,6 +34,7 @@
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.BiConsumer;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 import static io.jooby.internal.openapi.AsmUtils.boolValue;
@@ -49,6 +54,22 @@ public static void parse(ParserContext ctx, MethodNode method, OperationExt oper
         .findFirst()
         .ifPresent(a -> swaggerOperation(ctx, operation, toMap(a)));
 
+    /** SecurityRequirements: */
+    findAnnotationByType(method.visibleAnnotations,
+        singletonList(SecurityRequirements.class.getName()))
+        .stream()
+        .map(a ->
+            (List<AnnotationNode>) toMap(a).getOrDefault("value", emptyList())
+        )
+        .forEach(a -> securityRequirements(operation, a));
+
+    /** SecurityRequirement: */
+    findAnnotationByType(method.visibleAnnotations,
+        singletonList(io.swagger.v3.oas.annotations.security.SecurityRequirement.class.getName()))
+        .stream()
+        .findFirst()
+        .ifPresent(a -> securityRequirements(operation, Collections.singletonList(a)));
+
     /** @ApiResponses: */
     findAnnotationByType(method.visibleAnnotations, singletonList(ApiResponses.class.getName()))
         .stream()
@@ -97,6 +118,9 @@ private static void swaggerOperation(ParserContext ctx, OperationExt operation,
     List<String> tags = (List<String>) annotation.getOrDefault("tags", emptyList());
     tags.forEach(operation::addTagsItem);
 
+    securityRequirements(operation,
+        (List<AnnotationNode>) annotation.getOrDefault("security", Collections.emptyList()));
+
     parameters(ctx, operation,
         (List<AnnotationNode>) annotation.getOrDefault("parameters", Collections.emptyList()));
 
@@ -105,6 +129,24 @@ private static void swaggerOperation(ParserContext ctx, OperationExt operation,
     responses(ctx, operation, annotation);
   }
 
+  private static void securityRequirements(OperationExt operation,
+      List<AnnotationNode> securityRequirements) {
+    List<SecurityRequirement> requirements = new ArrayList<>();
+    for (AnnotationNode annotation : securityRequirements) {
+      Map<String, Object> securityMap = toMap(annotation);
+      String name = (String) securityMap.get("name");
+      List<String> scopes = (List<String>) securityMap
+          .getOrDefault("scopes", Collections.emptyList());
+      SecurityRequirement requirement = new SecurityRequirement();
+      requirement.addList(name, scopes);
+
+      requirements.add(requirement);
+    }
+    if (requirements.size() > 0) {
+      operation.setSecurity(requirements);
+    }
+  }
+
   private static void requestBody(ParserContext ctx, OperationExt operation,
       Map<String, Object> annotation) {
     if (annotation.size() > 0) {
@@ -166,6 +208,31 @@ private static void parameters(ParserContext ctx, OperationExt operation,
       enumValue(parameterMap, "explode", value -> parameter.setExample(Boolean.valueOf(value)));
       stringValue(parameterMap, "ref", ref -> parameter.set$ref(RefUtils.constructRef(ref)));
       arrayOrSchema(ctx, parameterMap).ifPresent(parameter::setSchema);
+      examples(parameterMap, parameter::setExample, parameter::setExamples);
+    }
+  }
+
+  private static void examples(Map<String, Object> annotation, Consumer<String> exampleConsumer,
+      Consumer<Map<String, Example>> consumer) {
+    List<Map<String, Object>> annotations = ((List<AnnotationNode>) annotation
+        .getOrDefault("examples", emptyList())).stream()
+        .map(AsmUtils::toMap)
+        .collect(Collectors.toList());
+
+    Map<String, Example> examples = new LinkedHashMap<>();
+    stringValue(annotation, "example", exampleConsumer);
+
+    for (Map<String, Object> e : annotations) {
+      Example example = new Example();
+      stringValue(e, "summary", example::setSummary);
+      stringValue(e, "description", example::setDescription);
+      stringValue(e, "value", example::setValue);
+      stringValue(e, "externalValue", example::setExternalValue);
+      String key = (String) e.getOrDefault("name", "example" + examples.size());
+      examples.put(key, example);
+    }
+    if (examples.size() > 0) {
+      consumer.accept(examples);
     }
   }
 
diff --git a/modules/jooby-openapi/src/test/java/io/jooby/openapi/OpenAPIResult.java b/modules/jooby-openapi/src/test/java/io/jooby/openapi/OpenAPIResult.java
@@ -23,7 +23,7 @@ public RouteIterator iterator(boolean ignoreArgs) {
   }
 
   public String toYaml() {
-    return toYaml(false);
+    return toYaml(true);
   }
 
   public String toYaml(boolean validate) {
diff --git a/modules/jooby-openapi/src/test/java/issues/Issue1591.java b/modules/jooby-openapi/src/test/java/issues/Issue1591.java
@@ -0,0 +1,99 @@
+package issues;
+
+import io.jooby.openapi.OpenAPIResult;
+import io.jooby.openapi.OpenAPITest;
+import issues.i1591.App1591;
+import issues.i1591.App1591b;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Issue1591 {
+
+  @OpenAPITest(App1591.class)
+  public void shouldParseExampleFromParameters(OpenAPIResult result) {
+    assertEquals("openapi: 3.0.1\n"
+        + "info:\n"
+        + "  title: 1591 API\n"
+        + "  description: 1591 API description\n"
+        + "  version: \"1.0\"\n"
+        + "paths:\n"
+        + "  /1591:\n"
+        + "    get:\n"
+        + "      summary: Example.\n"
+        + "      operationId: missingAttributes\n"
+        + "      parameters:\n"
+        + "      - name: arg1\n"
+        + "        in: path\n"
+        + "        description: Arg 1\n"
+        + "        required: true\n"
+        + "        schema:\n"
+        + "          type: string\n"
+        + "        example: ex1\n"
+        + "      - name: arg2\n"
+        + "        in: path\n"
+        + "        required: true\n"
+        + "        schema:\n"
+        + "          type: string\n"
+        + "        examples:\n"
+        + "          example0:\n"
+        + "            value: ex2\n"
+        + "          example1:\n"
+        + "            value: ex3\n"
+        + "      responses:\n"
+        + "        \"200\":\n"
+        + "          description: Success\n"
+        + "          content:\n"
+        + "            application/json:\n"
+        + "              schema:\n"
+        + "                type: string\n", result.toYaml());
+  }
+
+  @OpenAPITest(App1591b.class)
+  public void shouldParseSecurityRequirement(OpenAPIResult result) {
+    assertEquals("openapi: 3.0.1\n"
+        + "info:\n"
+        + "  title: 1591b API\n"
+        + "  description: 1591b API description\n"
+        + "  version: \"1.0\"\n"
+        + "paths:\n"
+        + "  /securityRequirements:\n"
+        + "    get:\n"
+        + "      operationId: securityRequirements\n"
+        + "      responses:\n"
+        + "        \"200\":\n"
+        + "          description: Success\n"
+        + "          content:\n"
+        + "            application/json:\n"
+        + "              schema:\n"
+        + "                type: string\n"
+        + "      security:\n"
+        + "      - myOauth1:\n"
+        + "        - 'write: read'\n"
+        + "  /securityRequirement:\n"
+        + "    get:\n"
+        + "      operationId: securityRequirement\n"
+        + "      responses:\n"
+        + "        \"200\":\n"
+        + "          description: Success\n"
+        + "          content:\n"
+        + "            application/json:\n"
+        + "              schema:\n"
+        + "                type: string\n"
+        + "      security:\n"
+        + "      - myOauth2:\n"
+        + "        - 'write: read'\n"
+        + "  /operationSecurityRequirement:\n"
+        + "    get:\n"
+        + "      operationId: operationSecurityRequirement\n"
+        + "      responses:\n"
+        + "        \"200\":\n"
+        + "          description: Success\n"
+        + "          content:\n"
+        + "            application/json:\n"
+        + "              schema:\n"
+        + "                type: string\n"
+        + "      security:\n"
+        + "      - myOauth3:\n"
+        + "        - 'write: read'\n", result.toYaml());
+  }
+}
diff --git a/modules/jooby-openapi/src/test/java/issues/i1591/App1591.java b/modules/jooby-openapi/src/test/java/issues/i1591/App1591.java
@@ -0,0 +1,33 @@
+package issues.i1591;
+
+import io.jooby.Context;
+import io.jooby.Jooby;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+
+public class App1591 extends Jooby {
+  {
+    get("/1591", this::parameterExample);
+  }
+
+  @Operation(
+      //this value does get respected
+      summary = "Example.",
+      security = @SecurityRequirement(name = "basicAuth"),
+      //this value doesn't get respected
+      parameters = {
+          @Parameter(name = "arg1", description = "Arg 1", example = "ex1", in = ParameterIn.PATH),
+          @Parameter(name = "arg2",
+              examples = {@ExampleObject("ex2"), @ExampleObject("ex3")}, in = ParameterIn.PATH
+          )
+      }
+  )
+  private String parameterExample(Context context) {
+    String arg1 = context.path("arg1").value();
+    String arg2 = context.path("arg2").value();
+    return null;
+  }
+}
diff --git a/modules/jooby-openapi/src/test/java/issues/i1591/App1591b.java b/modules/jooby-openapi/src/test/java/issues/i1591/App1591b.java
@@ -0,0 +1,34 @@
+package issues.i1591;
+
+import io.jooby.Context;
+import io.jooby.Jooby;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import io.swagger.v3.oas.annotations.security.SecurityRequirements;
+
+public class App1591b extends Jooby {
+  {
+    get("/securityRequirements", this::securityRequirements);
+    get("/securityRequirement", this::securityRequirement);
+    get("/operationSecurityRequirement", this::operationSecurityRequirement);
+  }
+
+  @SecurityRequirements(
+      @SecurityRequirement(name = "myOauth1", scopes = "write: read")
+  )
+  private String securityRequirements(Context context) {
+    return null;
+  }
+
+  @SecurityRequirement(name = "myOauth2", scopes = "write: read")
+  private String securityRequirement(Context context) {
+    return null;
+  }
+
+  @Operation(
+      security = @SecurityRequirement(name = "myOauth3", scopes = "write: read")
+  )
+  private String operationSecurityRequirement(Context context) {
+    return null;
+  }
+}

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public RouteIterator iterator(boolean ignoreArgs) {`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public String toYaml() {`
`26`		`- return toYaml(false);`
	`26`	`+ return toYaml(true);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`public String toYaml(boolean validate) {`