chore: Use client to perform HTTP response tests (#1018)

Author: jbelkins

Sources/ClientRuntime/Util/Initialize.swift

@@ -0,0 +1,15 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import struct AwsCommonRuntimeKit.CommonRuntimeKit
+
+/// Sets up CRT-related shared resources such as the global allocator, event loops, etc.
+///
+/// Calls to CRT functions may crash the SDK if `CommonRuntimeKit.initialize()` is not called first.
+///
+/// This function may safely be called multiple times.
+public func initialize() { CommonRuntimeKit.initialize() }

Sources/SmithyTestUtil/ProtocolTestResponseClient.swift

@@ -0,0 +1,25 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import protocol SmithyHTTPAPI.HTTPClient
+import class SmithyHTTPAPI.HTTPRequest
+import class SmithyHTTPAPI.HTTPResponse
+
+public class ProtocolResponseTestClient {
+    let httpResponse: HTTPResponse
+
+    public init(httpResponse: HTTPResponse) {
+        self.httpResponse = httpResponse
+    }
+}
+
+extension ProtocolResponseTestClient: HTTPClient {
+
+    public func send(request: HTTPRequest) async throws -> HTTPResponse {
+        httpResponse
+    }
+}

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolServiceClient.kt

@@ -52,6 +52,7 @@ open class HttpProtocolServiceClient(
 
     open fun renderInitFunction() {
         writer.openBlock("public required init(config: \$L) {", "}", serviceConfig.typeName) {
+            writer.write("\$N()", ClientRuntimeTypes.Core.initialize)
             writer.write(
                 "client = \$N(engine: config.httpClientEngine, config: config.httpClientConfiguration)",
                 ClientRuntimeTypes.Http.SdkHttpClient,

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolUnitTestErrorGenerator.kt

@@ -10,59 +10,47 @@ import software.amazon.smithy.protocol.traits.Rpcv2CborTrait
 import software.amazon.smithy.protocoltests.traits.HttpResponseTestCase
 import software.amazon.smithy.swift.codegen.SwiftDependency
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.AWSProtocol
-import software.amazon.smithy.swift.codegen.integration.serde.readwrite.ResponseErrorClosureUtils
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.WireProtocol
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.awsProtocol
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.requestWireProtocol
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.responseWireProtocol
-import software.amazon.smithy.swift.codegen.model.toUpperCamelCase
+import software.amazon.smithy.swift.codegen.model.toLowerCamelCase
 import software.amazon.smithy.swift.codegen.swiftmodules.SmithyHTTPAPITypes
+import software.amazon.smithy.swift.codegen.swiftmodules.SwiftTypes
 import java.util.Base64
 
 open class HttpProtocolUnitTestErrorGenerator protected constructor(
     builder: Builder,
 ) : HttpProtocolUnitTestResponseGenerator(builder) {
     val error: Shape = builder.error ?: throw CodegenException("builder did not set an error shape")
-    override val outputShape: Shape? = error
 
     override fun renderTestBody(test: HttpResponseTestCase) {
-        outputShape?.let {
-            val operationErrorType = "${operation.toUpperCamelCase()}OutputError"
-            writer.openBlock("do {", "} catch {") {
-                renderBuildHttpResponse(test)
-                writer.write("")
-                renderInitOperationError(operationErrorType)
-                writer.write("")
-                renderCompareActualAndExpectedErrors(test, it, operationErrorType)
-                writer.write("")
-            }
-            writer.indent()
-            writer.write("XCTFail(error.localizedDescription)")
-            writer.dedent()
-            writer.write("}")
-        }
+        renderBuildHttpResponse(test)
+        writer.write("")
+        renderActualOutput()
+        writer.write("")
+        renderCompareActualAndExpectedErrors(test, error)
     }
 
-    private fun renderInitOperationError(operationErrorType: String) {
-        val operationErrorVariableName = operationErrorType.replaceFirstChar { it.lowercase() }
-        val responseErrorClosure = ResponseErrorClosureUtils(ctx, writer, operation).render()
-        writer.addImport(SwiftDependency.SMITHY_READ_WRITE.target)
-        writer.write(
-            "let \$L = try await \$L(httpResponse)",
-            operationErrorVariableName,
-            responseErrorClosure,
-        )
+    override fun captureResponse() {
+        writer.write("var operationError: \$N?", SwiftTypes.Error)
+        writer.write("do {")
+        writer.indent {
+            writer.write("_ = try await client.\$L(input: input)", operation.toLowerCamelCase())
+            writer.write("XCTFail(\"Request should have failed\")")
+        }
+        writer.openBlock("} catch {", "}") {
+            writer.write("operationError = error")
+        }
     }
 
     private fun renderCompareActualAndExpectedErrors(
         test: HttpResponseTestCase,
         errorShape: Shape,
-        operationErrorType: String,
     ) {
-        val operationErrorVariableName = operationErrorType.replaceFirstChar { it.lowercase() }
         val errorType = symbolProvider.toSymbol(errorShape).name
 
-        writer.openBlock("if let actual = \$L as? \$L {", "} else {", operationErrorVariableName, errorType) {
+        writer.openBlock("if let actual = operationError as? \$L {", "} else {", errorType) {
             renderExpectedOutput(test, errorShape)
             renderAssertions(test, errorShape)
         }

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/integration/HttpProtocolUnitTestResponseGenerator.kt

@@ -4,26 +4,31 @@
  */
 package software.amazon.smithy.swift.codegen.integration
 
-import software.amazon.smithy.codegen.core.Symbol
 import software.amazon.smithy.model.shapes.Shape
+import software.amazon.smithy.model.shapes.ShapeType
 import software.amazon.smithy.model.shapes.StructureShape
 import software.amazon.smithy.model.traits.DefaultTrait
 import software.amazon.smithy.model.traits.HttpHeaderTrait
+import software.amazon.smithy.model.traits.HttpLabelTrait
 import software.amazon.smithy.model.traits.HttpPayloadTrait
 import software.amazon.smithy.model.traits.HttpPrefixHeadersTrait
 import software.amazon.smithy.protocol.traits.Rpcv2CborTrait
 import software.amazon.smithy.protocoltests.traits.HttpResponseTestCase
+import software.amazon.smithy.rulesengine.traits.EndpointRuleSetTrait
 import software.amazon.smithy.swift.codegen.ShapeValueGenerator
 import software.amazon.smithy.swift.codegen.hasStreamingMember
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.AWSProtocol
-import software.amazon.smithy.swift.codegen.integration.serde.readwrite.ResponseClosureUtils
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.WireProtocol
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.awsProtocol
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.requestWireProtocol
 import software.amazon.smithy.swift.codegen.integration.serde.readwrite.responseWireProtocol
 import software.amazon.smithy.swift.codegen.model.RecursiveShapeBoxer
 import software.amazon.smithy.swift.codegen.model.hasTrait
+import software.amazon.smithy.swift.codegen.model.toLowerCamelCase
+import software.amazon.smithy.swift.codegen.swiftmodules.FoundationTypes
+import software.amazon.smithy.swift.codegen.swiftmodules.SmithyHTTPAPITypes
 import software.amazon.smithy.swift.codegen.swiftmodules.SmithyStreamsTypes
+import software.amazon.smithy.swift.codegen.swiftmodules.SmithyTestUtilTypes
 import java.util.Base64
 
 /**
@@ -34,6 +39,14 @@ open class HttpProtocolUnitTestResponseGenerator protected constructor(
 ) : HttpProtocolUnitTestGenerator<HttpResponseTestCase>(builder) {
     override val baseTestClassName = "HttpResponseTestBase"
 
+    protected open val inputShape: Shape?
+        get() {
+            return operation.input
+                .map {
+                    model.expectShape(it)
+                }.orElse(null)
+        }
+
     protected open val outputShape: Shape?
         get() {
             return operation.output
@@ -44,10 +57,9 @@ open class HttpProtocolUnitTestResponseGenerator protected constructor(
 
     override fun renderTestBody(test: HttpResponseTestCase) {
         outputShape?.let {
-            val symbol = symbolProvider.toSymbol(it)
             renderBuildHttpResponse(test)
             writer.write("")
-            renderActualOutput(symbol)
+            renderActualOutput()
             writer.write("")
             renderExpectedOutput(test, it)
             writer.write("")
@@ -163,9 +175,69 @@ open class HttpProtocolUnitTestResponseGenerator protected constructor(
         }
     }
 
-    private fun renderActualOutput(outputStruct: Symbol) {
-        val responseClosure = ResponseClosureUtils(ctx, writer, operation).render()
-        writer.write("let actual: \$N = try await \$L(httpResponse)", outputStruct, responseClosure)
+    fun renderActualOutput() {
+        val clientName = "${ctx.settings.sdkId}Client"
+        val region = "us-west-2"
+
+        // Create a client config.  Use a dummy for:
+        // - credential resolver
+        // - endpoint resolver (unless the test has endpoint rules)
+        // - HTTP client engine; a mock that returns the test's HTTPResponse is used
+        writer.openBlock("let config = try await \$L.Config(", ")", clientName) {
+            writer.write("awsCredentialIdentityResolver: try \$N(),", SmithyTestUtilTypes.dummyIdentityResolver)
+            writer.write("region: \$S,", region)
+            writer.write("signingRegion: \$S,", region)
+            if (!ctx.service.hasTrait<EndpointRuleSetTrait>()) {
+                writer.openBlock(
+                    "endpointResolver: StaticEndpointResolver(endpoint: try \$N(",
+                    ")),",
+                    SmithyHTTPAPITypes.Endpoint,
+                ) {
+                    writer.write("urlString: \"https://example.com\"")
+                }
+            }
+            writer.write("httpClientEngine: ProtocolResponseTestClient(httpResponse: httpResponse)")
+        }
+        writer.write("")
+
+        // Create a client with the config
+        writer.write("let client = \$L(config: config)", clientName)
+        writer.write("")
+
+        // If input has any httpLabel-bound members, these must be filled so the request can succeed
+        val inputArgs = mutableListOf<String>()
+        for (member in inputShape?.members() ?: listOf()) {
+            if (member.hasTrait<HttpLabelTrait>()) {
+                val memberName = ctx.symbolProvider.toMemberName(member)
+                val target = model.expectShape(member.target)
+                val defaultArg =
+                    when (target.type) {
+                        ShapeType.STRING -> "\"test\""
+                        ShapeType.BOOLEAN -> "false"
+                        ShapeType.TIMESTAMP -> writer.format("\$N()", FoundationTypes.Date)
+                        else -> "0" // only other allowed types are numbers
+                    }
+                val arg = writer.format("\$L: \$L", memberName, defaultArg)
+                inputArgs.add(arg)
+            }
+        }
+
+        // Create the input, adding params if any
+        writer.write(
+            "let input = \$L(\$L)",
+            ctx.symbolProvider.toSymbol(inputShape),
+            inputArgs.joinToString(", "),
+        )
+        writer.write("")
+        captureResponse()
+        writer.write("")
+    }
+
+    open fun captureResponse() {
+        writer.write(
+            "let actual = try await client.\$L(input: input)",
+            operation.toLowerCamelCase(),
+        )
     }
 
     protected fun renderExpectedOutput(

smithy-swift-codegen/src/main/kotlin/software/amazon/smithy/swift/codegen/swiftmodules/ClientRuntimeTypes.kt

@@ -90,6 +90,7 @@ object ClientRuntimeTypes {
         val InterceptorProvider = runtimeSymbol("InterceptorProvider", SwiftDeclaration.PROTOCOL)
         val HttpInterceptorProvider = runtimeSymbol("HttpInterceptorProvider", SwiftDeclaration.PROTOCOL)
         val SDKLoggingSystem = runtimeSymbol("SDKLoggingSystem", SwiftDeclaration.CLASS)
+        val initialize = runtimeSymbol("initialize", SwiftDeclaration.FUNC)
     }
 
     object Composite {

smithy-swift-codegen/src/test/kotlin/software/amazon/smithy/swift/codegen/HttpProtocolClientGeneratorTests.kt

@@ -25,6 +25,7 @@ public class RestJsonProtocolClient: ClientRuntime.Client {
     let serviceName = "Rest Json Protocol"
 
     public required init(config: RestJsonProtocolClient.RestJsonProtocolClientConfiguration) {
+        ClientRuntime.initialize()
         client = ClientRuntime.SdkHttpClient(engine: config.httpClientEngine, config: config.httpClientConfiguration)
         self.config = config
     }