extract/migrate to better home, #68

Author: hauner

src/test/groovy/com/github/hauner/openapi/core/writer/java/MethodWriterSpec.groovy

@@ -301,79 +301,4 @@ class MethodWriterSpec extends Specification {
 """
     }
 
-    void "writes method with success response type when it has only empty error responses" () {
-        def endpoint = endpoint ("/foo", HttpMethod.GET) {e ->
-            e.responses { rs ->
-                rs.status ('200') { r ->
-                    r.response ('application/json', new StringDataType ())
-                }
-                rs.status ('400') { r ->
-                    r.empty ()
-                }
-                rs.status ('500') { r ->
-                    r.empty ()
-                }
-            }
-        }
-
-        when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
-
-        then:
-        target.toString () == """\
-    @CoreMapping
-    String getFoo();
-"""
-    }
-
-    void "writes method with 'Object' response when it has multiple result content types (200, default)" () {
-        def endpoint = endpoint ("/foo", HttpMethod.GET) {e ->
-            e.responses { rs ->
-                rs.status ('200') { r ->
-                    r.response ('application/json', new StringDataType ())
-                }
-                rs.status ('default') { r ->
-                    r.response ('text/plain', new StringDataType ())
-                }
-            }
-        }
-
-        when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
-
-        then:
-        target.toString () == """\
-    @CoreMapping
-    Object getFoo();
-"""
-    }
-
-    void "writes method with '?' response when it has multiple result contents types & wrapper result type" () {
-        def endpoint = endpoint ("/foo", HttpMethod.GET) {e ->
-            e.responses { rs ->
-                rs.status ('200') { r ->
-                    r.response ('application/json', new ResultDataType (
-                        'ResultWrapper',
-                        'http',
-                        new StringDataType ()))
-                }
-                rs.status ('default') { r ->
-                    r.response ('text/plain', new ResultDataType (
-                        'ResultWrapper',
-                        'http',
-                        new StringDataType ()))
-                }
-            }
-        }
-
-        when:
-        writer.write (target, endpoint, endpoint.endpointResponses.first ())
-
-        then:
-        target.toString () == """\
-    @CoreMapping
-    ResultWrapper<?> getFoo();
-"""
-    }
-
 }

src/test/kotlin/io/openapiprocessor/core/writer/java/MethodWriterResponseStyleSpec.kt

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2021 https://github.com/openapi-processor/openapi-processor-core
+ * PDX-License-Identifier: Apache-2.0
+ */
+
+package io.openapiprocessor.core.writer.java
+
+import io.kotest.core.spec.IsolationMode
+import io.kotest.core.spec.style.StringSpec
+import io.kotest.matchers.shouldBe
+import io.mockk.mockk
+import io.openapiprocessor.core.builder.api.endpoint
+import io.openapiprocessor.core.converter.ApiOptions
+import io.openapiprocessor.core.model.HttpMethod
+import io.openapiprocessor.core.model.datatypes.ResultDataType
+import io.openapiprocessor.core.model.datatypes.StringDataType
+import io.openapiprocessor.core.support.TestMappingAnnotationWriter
+import io.openapiprocessor.core.support.TestParameterAnnotationWriter
+import java.io.StringWriter
+
+class MethodWriterResponseStyleSpec: StringSpec({
+    isolationMode = IsolationMode.InstancePerTest
+
+    val apiOptions = ApiOptions()
+
+    val writer = MethodWriter (
+        apiOptions,
+        TestMappingAnnotationWriter(),
+        TestParameterAnnotationWriter(),
+        mockk<BeanValidationFactory>(),
+        mockk<JavaDocWriter>())
+
+    val target = StringWriter()
+
+    "writes method with success response type when it has only empty error responses" {
+        val endpoint = endpoint("/foo", HttpMethod.GET) {
+            responses {
+                status("200") {
+                    response("application/json", StringDataType())
+                }
+                status("400") {
+                    empty()
+                }
+                status("500") {
+                    empty()
+                }
+            }
+        }
+
+        // when:
+        writer.write (target, endpoint, endpoint.endpointResponses.first ())
+
+        // then:
+        target.toString() shouldBe
+            """    
+            |    @CoreMapping
+            |    String getFoo();
+            |
+            """.trimMargin()
+    }
+
+    "writes method with 'Object' response when it has multiple result content types (200, default)" {
+        val endpoint = endpoint("/foo", HttpMethod.GET) {
+            responses {
+                status("200") {
+                    response("application/json", StringDataType())
+                }
+                status("default") {
+                    response("text/plain", StringDataType())
+                }
+            }
+        }
+
+        // when:
+        writer.write(target, endpoint, endpoint.endpointResponses.first())
+
+        // then:
+        target.toString() shouldBe
+            """    
+            |    @CoreMapping
+            |    Object getFoo();
+            |
+            """.trimMargin()
+    }
+
+    "writes method with '?' response when it has multiple result contents types & wrapper result type" {
+        val endpoint = endpoint("/foo", HttpMethod.GET) {
+            responses {
+                status("200") {
+                    response("application/json", ResultDataType(
+                            "ResultWrapper",
+                            "http",
+                            StringDataType()
+                        )
+                    )
+                }
+                status("default") {
+                    response("text/plain", ResultDataType(
+                            "ResultWrapper",
+                            "http",
+                            StringDataType()
+                        )
+                    )
+                }
+            }
+        }
+
+        // when:
+        writer.write(target, endpoint, endpoint.endpointResponses.first())
+
+        // then:
+        target.toString() shouldBe
+            """    
+            |    @CoreMapping
+            |    ResultWrapper<?> getFoo();
+            |
+            """.trimMargin()
+    }
+
+})