remember response status on grouping by content type (openapi-processor/openapi-processor-spring#339)

Author: hauner

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/framework/FrameworkAnnotations.kt

@@ -5,9 +5,10 @@
 
 package io.openapiprocessor.core.framework
 
+import io.openapiprocessor.core.model.Annotation
+import io.openapiprocessor.core.model.EndpointResponseStatus
 import io.openapiprocessor.core.model.parameters.Parameter
 import io.openapiprocessor.core.parser.HttpMethod
-import io.openapiprocessor.core.model.Annotation
 
 /**
  * provides annotation details of the framework.
@@ -29,4 +30,9 @@ interface FrameworkAnnotations {
      * @return annotation details
      */
     fun getAnnotation(parameter: Parameter): Annotation
+
+    /**
+     * provides the details of a response status annotation
+     */
+    fun getAnnotation(status: EndpointResponseStatus): Annotation
 }

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/model/Endpoint.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2019 https://github.com/openapi-processor/openapi-processor-core
+ * Copyright 2019 https://github.com/openapi-processor/openapi-processor-core
  * PDX-License-Identifier: Apache-2.0
  */
 
@@ -9,6 +9,7 @@ package io.openapiprocessor.core.model
 import io.openapiprocessor.core.model.parameters.MultipartParameter
 import io.openapiprocessor.core.model.parameters.Parameter
 import io.openapiprocessor.core.parser.HttpMethod
+import kotlin.collections.plusAssign
 
 /**
  * Endpoint properties.
@@ -38,11 +39,12 @@ class Endpoint(
      * @return the list of responses
      */
     @Deprecated("only used in class")
-    private fun getResponses (status: String): List<Response> {
+    private fun getResponses (status: String): List<ResponseWithStatus> {
         if (!responses.containsKey (status)) {
             return emptyList()
         }
         return responses.getOrDefault(status, emptyList())
+            .map { ResponseWithStatus(status, it) }
     }
 
     /**
@@ -72,30 +74,16 @@ class Endpoint(
         return contentTypes
     }
 
-    // not needed.... => EndpointResponse.getContentTypes()
     @Deprecated("only used in test")
-    fun getProducesContentTypes (status: String): List<String> {
-        val responses = getResponses (status)
-        val errors = getErrorResponses ()
-
-        val contentTypes = mutableSetOf<String>()
-        responses.forEach {
-            if (it.empty) {
-                return@forEach
-            }
-
-            contentTypes.add (it.contentType)
-        }
-
-        errors.forEach {
-            contentTypes.add (it.contentType)
-        }
-
-        return contentTypes.toList ()
+    fun getProducesContentTypes (status: String): Set<String> {
+        return endpointResponses
+            .map { it.contentTypes }
+            .flatten()
+            .toSet()
     }
 
     /**
-     * test support => extension function ?
+     * test support => extension function?
      *
      * @param status the response status
      * @return first response of status
@@ -124,7 +112,7 @@ class Endpoint(
     /**
      * checks if the endpoint has multiple success responses with different content types.
      *
-     * @return true if condition is met, otherwise false.
+     * @return true if the condition is met, otherwise false.
      */
     fun hasMultipleEndpointResponses(): Boolean {
         return endpointResponses.size > 1
@@ -134,7 +122,7 @@ class Endpoint(
      * creates groups from the responses.
      *
      * if the endpoint does provide its result in multiple content types it will create one entry
-     * for each response kind (main response). if error responses are defined they are added as
+     * for each response kind (main response). if error responses are defined, they are added as
      * error responses.
      *
      * this is used to create one controller method for each (successful) response definition.
@@ -145,56 +133,65 @@ class Endpoint(
         val successes = getSuccessResponses()
         val errors = getErrorResponses()
 
-        return successes.map { (key, responses) ->
-            EndpointResponse(responses.first(), errors, responses)
+        return successes.map { (_, statusResponses) ->
+            EndpointResponse(statusResponses.first(), errors, statusResponses)
         }
     }
 
-    private fun getSuccessResponses(): MutableMap<ContentType, MutableList<Response>> {
-        val result = mutableMapOf<ContentType, MutableList<Response>>()
-
-        // prefer responses with content type.
-        filterSuccessResponses()
-            .filter { hasContentType(it) }
-            .forEach {
-                var contentValues = result[it.contentType]
-                if (contentValues == null) {
-                    contentValues = mutableListOf()
-                    result[it.contentType] = contentValues
-                }
-                contentValues += it
+    private fun getSuccessResponses(): MutableMap<ContentType, MutableList<ResponseWithStatus>> {
+        val result = mutableMapOf<ContentType, MutableList<ResponseWithStatus>>()
+
+        responses
+            .filterKeys { isSuccessCode(it) }
+            .forEach { entry ->
+                val status = entry.key
+
+                entry.value
+                    .filter { hasContentType(it) }
+                    .forEach { response ->
+                        var contentValues = result[response.contentType]
+                        if (contentValues == null) {
+                            contentValues = mutableListOf()
+                            result[response.contentType] = contentValues
+                        }
+                        contentValues += ResponseWithStatus(status, response)
+                    }
             }
 
-        // check for responses without content type (e.g. 204) to generate a void method.
+        // check for responses without a content type (e.g., 204) to generate a void method.
         if (result.isEmpty()) {
-            filterSuccessResponses()
-                .forEach {
-                    var contentValues = result[it.contentType]
-                    if (contentValues == null) {
-                        contentValues = mutableListOf()
-                        result[it.contentType] = contentValues
-                    }
-                    contentValues += it
+            responses
+                .filterKeys { isSuccessCode(it) }
+                .forEach { entry ->
+                    val status = entry.key
+
+                    entry.value
+                        .forEach { response ->
+                            var contentValues = result[response.contentType]
+                            if (contentValues == null) {
+                                contentValues = mutableListOf()
+                                result[response.contentType] = contentValues
+                            }
+                            contentValues += ResponseWithStatus(status, response)
+                        }
                 }
         }
 
         return result
     }
 
-    private fun getErrorResponses(): Set<Response> {
+    private fun getErrorResponses(): Set<ResponseWithStatus> {
         return responses
             .filterKeys { !isSuccessCode(it) }
-            .values
-            .map { it.first() }
-            .filter { !it.empty }
+            .map { entry ->
+                val status = entry.key
+                val response = entry.value.first()
+                ResponseWithStatus(status, response)
+            }
+            .filter { !it.response.empty }
             .toSet()
     }
 
-    private fun filterSuccessResponses() = responses
-        .filterKeys { isSuccessCode(it) }
-        .values
-        .flatten()
-
     private fun isSuccessCode(code: String) = code.startsWith("2")
 
     private fun hasContentType(response: Response) = response.contentType != "?"

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/model/EndpointResponse.kt

@@ -13,37 +13,54 @@ import io.openapiprocessor.core.processor.mapping.v2.ResultStyle
  * The responses that can be returned by an endpoint method for one (successful) response.
  */
 class EndpointResponse(
-
     /**
      * success response
      */
-    private val main: Response,
+    @Deprecated("use successes", replaceWith = ReplaceWith("successes"))
+    private val main: ResponseWithStatus,
 
     /**
      * additional (error) responses
      */
-    private val errors: Set<Response>,
+    private val errors: Set<ResponseWithStatus>,
 
     /**
      * todo replace main
      * success responses
      */
-    private val successes: List<Response> = listOf()
-) {
+    private val successes: List<ResponseWithStatus> = listOf()
+): EndpointResponseStatus {
+
+    val success: Response
+        get() = main.response
+
     // todo all have the same, maybe pass as parameter
     val contentType: String
-        get() = main.contentType
+        get() = success.contentType
+
+    override val statusCode: HttpStatus
+        get() {
+            if (successes.size == 1) {
+                return successes.first().status
+            }
+
+            if (errors.size == 1) {
+                return errors.first().status
+            }
+
+            throw IllegalStateException("multiple successful or error responses without status code")
+        }
 
     /**
-     * provides the response type based on the requested style.
+     * Provides the response type based on the requested style.
      *
      * [ResultStyle.SUCCESS]
-     * - response type is the single success response type regardless of the number of available
+     * - Response type is the single success response type regardless of the number of available
      * error responses.
      *
      * [ResultStyle.ALL]
      * - If the endpoint has multiple responses the response type is `Object`. If the response is
-     * wrapped by a result data type (i.e. wrapper) the response type is `ResultDataType<?>`.
+     * wrapped by a result data type (i.e., wrapper) the response type is `ResultDataType<?>`.
      * - If the endpoint has only a success response type it is used as the response type.
      *
      * @param style required style
@@ -63,6 +80,29 @@ class EndpointResponse(
         return getSingleResponseTypeName()
     }
 
+    /**
+     * Check if the response has a single response status not equal to 200 ok. It is used to check if it is possible
+     * to generate code that automatically returns the status code (like annotation the endpoint method).
+     *
+     * [ResultStyle.SUCCESS]
+     * - True if there is a single response status not equal to 200, i.e., any success status
+     *
+     * [ResultStyle.ALL]
+     * - True if there is a single response status not equal to 200, i.e., any status
+     */
+    fun hasSingleResponse(style: ResultStyle): Boolean {
+        if (style == ResultStyle.ALL) {
+            if (successes.size == 1 && errors.isEmpty()) {
+                return successes.first().status != "200"
+            }
+        } else if (style == ResultStyle.SUCCESS) {
+            if (successes.size == 1) {
+                return successes.first().status != "200"
+            }
+        }
+        return false
+    }
+
     /**
      * test only: provides the response type.
      */
@@ -72,7 +112,7 @@ class EndpointResponse(
         }
 
     val description: String?
-    get() = main.description
+    get() = success.description
 
     /**
      * provides the imports required for {@link #getResponseType()}.
@@ -103,25 +143,25 @@ class EndpointResponse(
     val contentTypes: Set<String>
         get() {
             val result = mutableSetOf<String>()
-            if (!main.empty) {
-                result.add(main.contentType)
+            if (!success.empty) {
+                result.add(success.contentType)
             }
 
             errors.forEach {
-                result.add(it.contentType)
+                result.add(it.response.contentType)
             }
             return result
         }
 
     private fun isAnyOneOfResponse(): Boolean {
-        return main.responseType is AnyOneOfObjectDataType
+        return success.responseType is AnyOneOfObjectDataType
     }
 
     /**
      * Object or ResultDataType<?> if wrapped
      */
     private fun getMultiResponseTypeName(): String {
-        val rt = main.responseType
+        val rt = success.responseType
         if (rt is ResultDataType) {
             return rt.getNameMulti()
         }
@@ -130,7 +170,7 @@ class EndpointResponse(
 
     private fun getSingleResponseTypeName(): String {
         val types = getDistinctResponseTypes()
-            .map { r -> r.responseType.getTypeName() }
+            .map { r -> r.response.responseType.getTypeName() }
 
         if(types.size != 1) {
             throw IllegalStateException("ambiguous response types: $types")
@@ -140,7 +180,7 @@ class EndpointResponse(
     }
 
     private fun getImportsMulti(): Set<String> {
-        val rt = main.responseType
+        val rt = success.responseType
         return if (rt is ResultDataType) {
             rt.getImportsMulti()
         } else {
@@ -149,10 +189,10 @@ class EndpointResponse(
     }
 
     private fun getImportsSingle(): Set<String> {
-        return main.imports
+        return success.imports
     }
 
-    private fun getDistinctResponseTypes(): List<Response> {
-        return successes.distinctBy { response ->  response.responseType.getTypeName() }
+    private fun getDistinctResponseTypes(): List<ResponseWithStatus> {
+        return successes.distinctBy { statusResponse ->  statusResponse.response.responseType.getTypeName() }
     }
 }

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/model/EndpointResponseStatus.kt

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2015 https://github.com/openapi-processor/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.model
+
+interface EndpointResponseStatus {
+    val statusCode: HttpStatus
+}

openapi-processor-core/src/main/kotlin/io/openapiprocessor/core/model/ResponseWithStatus.kt

@@ -0,0 +1,8 @@
+/*
+ * Copyright 2015 https://github.com/openapi-processor/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.model
+
+data class ResponseWithStatus(val status: HttpStatus, val response: Response)

openapi-processor-core/src/test/groovy/io/openapiprocessor/core/model/EndpointContentTypesSpec.groovy

@@ -67,7 +67,7 @@ class EndpointContentTypesSpec extends Specification {
         }
 
         expect:
-        endpoint.getProducesContentTypes ('204') == []
+        endpoint.getProducesContentTypes ('204') == [] as Set
     }
 
     void "provides producing content types" () {