feat: smoke tests trait

.changes/756754c3-f6e1-4ff2-ae31-08b3b67b6750.json

@@ -0,0 +1,5 @@
+{
+    "id": "756754c3-f6e1-4ff2-ae31-08b3b67b6750",
+    "type": "feature",
+    "description": "Add support for [smoke tests](https://smithy.io/2.0/additional-specs/smoke-tests.html)"
+}

.github/workflows/continuous-integration.yml

@@ -131,5 +131,6 @@ jobs:
         sed -i "s/smithy-kotlin-runtime-version = .*$/smithy-kotlin-runtime-version = \"$SMITHY_KOTLIN_RUNTIME_VERSION\"/" gradle/libs.versions.toml
         sed -i "s/smithy-kotlin-codegen-version = .*$/smithy-kotlin-codegen-version = \"$SMITHY_KOTLIN_CODEGEN_VERSION\"/" gradle/libs.versions.toml
         ./gradlew --parallel publishToMavenLocal
+        ./gradlew build
         ./gradlew test jvmTest
         ./gradlew testAllProtocols

codegen/smithy-kotlin-codegen/build.gradle.kts

@@ -31,6 +31,7 @@ dependencies {
     implementation(libs.smithy.aws.traits)
     implementation(libs.smithy.protocol.traits)
     implementation(libs.smithy.protocol.test.traits)
+    implementation(libs.smithy.smoke.test.traits)
     implementation(libs.jsoup)
 
     // Test dependencies

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/KotlinDelegator.kt

@@ -121,9 +121,10 @@ class KotlinDelegator(
      *
      * @param filename Name of the file to create.
      * @param block Lambda that accepts and works with the file.
+     * @param sourceSetRoot Root directory for source set
      */
-    fun useFileWriter(filename: String, namespace: String, block: (KotlinWriter) -> Unit) {
-        val writer: KotlinWriter = checkoutWriter(filename, namespace)
+    fun useFileWriter(filename: String, namespace: String, sourceSetRoot: String = DEFAULT_SOURCE_SET_ROOT, block: (KotlinWriter) -> Unit) {
+        val writer: KotlinWriter = checkoutWriter(filename, namespace, sourceSetRoot)
         block(writer)
     }
 
@@ -205,6 +206,6 @@ internal data class GeneratedDependency(
 }
 
 fun KotlinDelegator.useFileWriter(symbol: Symbol, block: (KotlinWriter) -> Unit) =
-    useFileWriter("${symbol.name}.kt", symbol.namespace, block)
+    useFileWriter("${symbol.name}.kt", symbol.namespace, DEFAULT_SOURCE_SET_ROOT, block)
 
 fun KotlinDelegator.applyFileWriter(symbol: Symbol, block: KotlinWriter.() -> Unit) = useFileWriter(symbol, block)

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/KotlinDependency.kt

@@ -104,6 +104,7 @@ data class KotlinDependency(
         val CORE = KotlinDependency(GradleConfiguration.Api, RUNTIME_ROOT_NS, RUNTIME_GROUP, "runtime-core", RUNTIME_VERSION)
         val HTTP = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.http", RUNTIME_GROUP, "http", RUNTIME_VERSION)
         val HTTP_CLIENT = KotlinDependency(GradleConfiguration.Api, "$RUNTIME_ROOT_NS.http", RUNTIME_GROUP, "http-client", RUNTIME_VERSION)
+        val HTTP_TEST = KotlinDependency(GradleConfiguration.Api, "$RUNTIME_ROOT_NS.httptest", RUNTIME_GROUP, "http-test", RUNTIME_VERSION)
         val SERDE = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.serde", RUNTIME_GROUP, "serde", RUNTIME_VERSION)
         val SERDE_JSON = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.serde.json", RUNTIME_GROUP, "serde-json", RUNTIME_VERSION)
         val SERDE_XML = KotlinDependency(GradleConfiguration.Implementation, "$RUNTIME_ROOT_NS.serde.xml", RUNTIME_GROUP, "serde-xml", RUNTIME_VERSION)

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/KotlinWriter.kt

@@ -198,6 +198,8 @@ class KotlinWriter(
             )
         }
 
+    fun emptyLine(): KotlinWriter = this.write("")
+
     /**
      * Clean/escape any content from the doc that would invalidate the Kotlin output.
      */

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/core/RuntimeTypes.kt

@@ -86,9 +86,16 @@ object RuntimeTypes {
             val FlexibleChecksumsResponseInterceptor = symbol("FlexibleChecksumsResponseInterceptor")
             val ResponseLengthValidationInterceptor = symbol("ResponseLengthValidationInterceptor")
             val RequestCompressionInterceptor = symbol("RequestCompressionInterceptor")
+            val SmokeTestsInterceptor = symbol("SmokeTestsInterceptor")
+            val SmokeTestsFailureException = symbol("SmokeTestsFailureException")
+            val SmokeTestsSuccessException = symbol("SmokeTestsSuccessException")
         }
     }
 
+    object HttpTest : RuntimeTypePackage(KotlinDependency.HTTP_TEST) {
+        val TestEngine = symbol("TestEngine")
+    }
+
     object Core : RuntimeTypePackage(KotlinDependency.CORE) {
         val Clock = symbol("Clock", "time")
         val ExecutionContext = symbol("ExecutionContext", "operation")

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/model/traits/SmokeTestTraits.kt

@@ -0,0 +1,23 @@
+package software.amazon.smithy.kotlin.codegen.model.traits
+
+import software.amazon.smithy.model.node.ObjectNode
+import software.amazon.smithy.model.shapes.ShapeId
+import software.amazon.smithy.model.traits.AnnotationTrait
+
+/**
+ * Indicates the annotated service should always return a failed response.
+ */
+class FailedResponseTrait(node: ObjectNode) : AnnotationTrait(ID, node) {
+    companion object {
+        val ID: ShapeId = ShapeId.from("smithy.kotlin.traits#failedResponseTrait")
+    }
+}
+
+/**
+ * Indicates the annotated service should always return a success response.
+ */
+class SuccessResponseTrait(node: ObjectNode) : AnnotationTrait(ID, node) {
+    companion object {
+        val ID: ShapeId = ShapeId.from("smithy.kotlin.traits#successResponseTrait")
+    }
+}

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/GradleGenerator.kt

@@ -250,4 +250,6 @@ class GradleWriter(parent: GradleWriter? = null) : AbstractCodeWriter<GradleWrit
         expressionStart = parent?.expressionStart ?: '#'
         putFormatter('W', InlineCodeWriterFormatter(::GradleWriter))
     }
+
+    fun emptyLine(): GradleWriter = this.write("")
 }

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/smoketests/SmokeTestsIntegration.kt

@@ -0,0 +1,30 @@
+package software.amazon.smithy.kotlin.codegen.rendering.smoketests
+
+import software.amazon.smithy.kotlin.codegen.KotlinSettings
+import software.amazon.smithy.kotlin.codegen.core.CodegenContext
+import software.amazon.smithy.kotlin.codegen.core.KotlinDelegator
+import software.amazon.smithy.kotlin.codegen.integration.KotlinIntegration
+import software.amazon.smithy.kotlin.codegen.model.hasTrait
+import software.amazon.smithy.kotlin.codegen.utils.operations
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
+
+/**
+ * Renders smoke test runner for a service if any of the operations have the [SmokeTestsTrait].
+ */
+class SmokeTestsIntegration : KotlinIntegration {
+    override fun enabledForService(model: Model, settings: KotlinSettings): Boolean =
+        model.operations(settings.service).any { it.hasTrait<SmokeTestsTrait>() }
+
+    override fun writeAdditionalFiles(ctx: CodegenContext, delegator: KotlinDelegator) =
+        delegator.useFileWriter(
+            "SmokeTests.kt",
+            "${ctx.settings.pkg.name}.smoketests",
+            "./jvm-src/test/java/",
+        ) { writer ->
+            SmokeTestsRunnerGenerator(
+                writer,
+                ctx,
+            ).render()
+        }
+}

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/smoketests/SmokeTestsRunnerGenerator.kt

@@ -0,0 +1,216 @@
+package software.amazon.smithy.kotlin.codegen.rendering.smoketests
+
+import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.kotlin.codegen.core.*
+import software.amazon.smithy.kotlin.codegen.integration.SectionId
+import software.amazon.smithy.kotlin.codegen.model.expectShape
+import software.amazon.smithy.kotlin.codegen.model.getTrait
+import software.amazon.smithy.kotlin.codegen.model.hasTrait
+import software.amazon.smithy.kotlin.codegen.model.traits.FailedResponseTrait
+import software.amazon.smithy.kotlin.codegen.model.traits.SuccessResponseTrait
+import software.amazon.smithy.kotlin.codegen.rendering.util.format
+import software.amazon.smithy.kotlin.codegen.utils.dq
+import software.amazon.smithy.kotlin.codegen.utils.operations
+import software.amazon.smithy.kotlin.codegen.utils.toCamelCase
+import software.amazon.smithy.model.shapes.OperationShape
+import software.amazon.smithy.model.shapes.ServiceShape
+import software.amazon.smithy.smoketests.traits.SmokeTestCase
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
+import kotlin.jvm.optionals.getOrNull
+
+object SmokeTestsRunner : SectionId
+
+// Env var constants
+const val SKIP_TAGS = "AWS_SMOKE_TEST_SKIP_TAGS"
+const val SERVICE_FILTER = "AWS_SMOKE_TEST_SERVICE_IDS"
+
+/**
+ * Renders smoke tests runner for a service
+ */
+class SmokeTestsRunnerGenerator(
+    private val writer: KotlinWriter,
+    ctx: CodegenContext,
+) {
+    // Generator config
+    private val model = ctx.model
+    private val sdkId = ctx.settings.sdkId
+    private val symbolProvider = ctx.symbolProvider
+    private val service = symbolProvider.toSymbol(model.expectShape(ctx.settings.service))
+    private val operations = ctx.model.operations(ctx.settings.service).filter { it.hasTrait<SmokeTestsTrait>() }
+
+    // Test config
+    private val hasSuccessResponseTrait = model.expectShape<ServiceShape>(ctx.settings.service).hasTrait(SuccessResponseTrait.ID)
+    private val hasFailedResponseTrait = model.expectShape<ServiceShape>(ctx.settings.service).hasTrait(FailedResponseTrait.ID)
+    init {
+        check(!(hasSuccessResponseTrait && hasFailedResponseTrait)) {
+            "A service can't have both the success response trait and the failed response trait."
+        }
+    }
+
+    internal fun render() {
+        writer.declareSection(SmokeTestsRunner) {
+            writer.write("import kotlin.system.exitProcess")
+            writer.emptyLine()
+            writer.write("private var exitCode = 0")
+            writer.write("private val regionOverride = System.getenv(#S)", "AWS_SMOKE_TEST_REGION")
+            writer.write("private val skipTags = System.getenv(#S)?.let { it.split(\",\").map { it.trim() }.toSet() } ?: emptySet()", SKIP_TAGS)
+            writer.write("private val serviceFilter = System.getenv(#S)?.let { it.split(\",\").map { it.trim() }.toSet() }", SERVICE_FILTER)
+            writer.emptyLine()
+            writer.withBlock("public suspend fun main() {", "}") {
+                renderFunctionCalls()
+                write("exitProcess(exitCode)")
+            }
+            writer.emptyLine()
+            renderFunctions()
+        }
+    }
+
+    private fun renderFunctionCalls() {
+        operations.forEach { operation ->
+            operation.getTrait<SmokeTestsTrait>()?.testCases?.forEach { testCase ->
+                writer.write("${testCase.functionName}()")
+            }
+        }
+    }
+
+    private fun renderFunctions() {
+        operations.forEach { operation ->
+            operation.getTrait<SmokeTestsTrait>()?.testCases?.forEach { testCase ->
+                renderFunction(operation, testCase)
+                writer.emptyLine()
+            }
+        }
+    }
+
+    private fun renderFunction(operation: OperationShape, testCase: SmokeTestCase) {
+        writer.withBlock("private suspend fun ${testCase.functionName}() {", "}") {
+            write("val tags = setOf<String>(${testCase.tags.joinToString(",") { it.dq()} })")
+            writer.withBlock("if ((serviceFilter != null && #S !in serviceFilter) || tags.any { it in skipTags }) {", "}", sdkId) {
+                printTestResult(
+                    sdkId.filter { !it.isWhitespace() },
+                    testCase.id,
+                    testCase.expectation.isFailure,
+                    writer,
+                    "ok",
+                    "# skip",
+                )
+                writer.write("return")
+            }
+            emptyLine()
+            withInlineBlock("try {", "} ") {
+                renderClient(testCase)
+                renderOperation(operation, testCase)
+            }
+            withBlock("catch (e: Exception) {", "}") {
+                renderCatchBlock(testCase)
+            }
+        }
+    }
+
+    private fun renderClient(testCase: SmokeTestCase) {
+        writer.withInlineBlock("#L {", "}", service) {
+            // Client config
+            if (testCase.vendorParams.isPresent) {
+                testCase.vendorParams.get().members.forEach { vendorParam ->
+                    if (vendorParam.key.value == "region") {
+                        write("region = regionOverride ?: #L", vendorParam.value.format())
+                    } else {
+                        write("#L = #L", vendorParam.key.value.toCamelCase(), vendorParam.value.format())
+                    }
+                }
+            } else {
+                write("region = regionOverride")
+            }
+            val expectingSpecificError = testCase.expectation.failure.getOrNull()?.errorId?.getOrNull() != null
+            if (!expectingSpecificError) {
+                write("interceptors.add(#T())", RuntimeTypes.HttpClient.Interceptors.SmokeTestsInterceptor)
+            }
+
+            // Test config
+            if (hasSuccessResponseTrait) {
+                write("httpClient = #T()", RuntimeTypes.HttpTest.TestEngine)
+            }
+            if (hasFailedResponseTrait) {
+                withBlock("httpClient = #T(", ")", RuntimeTypes.HttpTest.TestEngine) {
+                    withBlock("roundTripImpl = { _, request ->", "}") {
+                        write(
+                            "val resp = #T(#T.BadRequest, #T.Empty, #T.Empty)",
+                            RuntimeTypes.Http.Response.HttpResponse,
+                            RuntimeTypes.Http.StatusCode,
+                            RuntimeTypes.Http.Headers,
+                            RuntimeTypes.Http.HttpBody,
+                        )
+                        write("val now = #T.now()", RuntimeTypes.Core.Instant)
+                        write("#T(request, resp, now, now)", RuntimeTypes.Http.HttpCall)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun renderOperation(operation: OperationShape, testCase: SmokeTestCase) {
+        val operationSymbol = symbolProvider.toSymbol(model.getShape(operation.input.get()).get())
+
+        writer.withBlock(".use { client ->", "}") {
+            withBlock("client.#L(", ")", operation.defaultName()) {
+                withBlock("#L {", "}", operationSymbol) {
+                    testCase.params.get().members.forEach { member ->
+                        write("#L = #L", member.key.value.toCamelCase(), member.value.format())
+                    }
+                }
+            }
+        }
+    }
+
+    private fun renderCatchBlock(testCase: SmokeTestCase) {
+        val successCriterion = RuntimeTypes.HttpClient.Interceptors.SmokeTestsSuccessException
+        val failureCriterion = getFailureCriterion(testCase)
+        val expected = if (testCase.expectation.isFailure) {
+            failureCriterion
+        } else {
+            successCriterion
+        }
+
+        writer.write("val success = e is #L", expected)
+        writer.write("val status = if (success) \"ok\" else \"not ok\"")
+        printTestResult(
+            sdkId.filter { !it.isWhitespace() },
+            testCase.id,
+            testCase.expectation.isFailure,
+            writer,
+        )
+        writer.write("if (!success) exitCode = 1")
+    }
+
+    /**
+     * Tries to get the specific exception required in the failure criterion of a test.
+     * If no specific exception is required we default to the generic smoke tests failure exception.
+     */
+    private fun getFailureCriterion(testCase: SmokeTestCase): Symbol =
+        testCase.expectation.failure.getOrNull()?.errorId?.getOrNull()?.let {
+            symbolProvider.toSymbol(model.getShape(it).get())
+        } ?: RuntimeTypes.HttpClient.Interceptors.SmokeTestsFailureException
+
+    /**
+     * Renders print statement for smoke test result in accordance to design doc & test anything protocol (TAP)
+     */
+    private fun printTestResult(
+        service: String,
+        testCase: String,
+        errorExpected: Boolean,
+        writer: KotlinWriter,
+        statusOverride: String? = null,
+        directive: String? = "",
+    ) {
+        val expectation = if (errorExpected) "error expected from service" else "no error expected from service"
+        val status = statusOverride ?: "\$status"
+        val testResult = "$status $service $testCase - $expectation $directive"
+        writer.write("println(#S)", testResult)
+    }
+}
+
+/**
+ * Derives a function name for a [SmokeTestCase]
+ */
+private val SmokeTestCase.functionName: String
+    get() = this.id.toCamelCase()

codegen/smithy-kotlin-codegen/src/main/kotlin/software/amazon/smithy/kotlin/codegen/rendering/util/Node.kt

@@ -0,0 +1,31 @@
+package software.amazon.smithy.kotlin.codegen.rendering.util
+
+import software.amazon.smithy.kotlin.codegen.utils.dq
+import software.amazon.smithy.model.node.ArrayNode
+import software.amazon.smithy.model.node.BooleanNode
+import software.amazon.smithy.model.node.Node
+import software.amazon.smithy.model.node.NullNode
+import software.amazon.smithy.model.node.NumberNode
+import software.amazon.smithy.model.node.ObjectNode
+import software.amazon.smithy.model.node.StringNode
+
+/**
+ * Formats a [Node] into a String for codegen.
+ */
+fun Node.format(): String = when (this) {
+    is NullNode -> "null"
+    is StringNode -> value.dq()
+    is BooleanNode -> value.toString()
+    is NumberNode -> value.toString()
+    is ArrayNode -> elements.joinToString(",", "listOf(", ")") { element ->
+        element.format()
+    }
+    is ObjectNode -> buildString {
+        append("mapOf(")
+        stringMap.forEach { (key, value) ->
+            append("\t${key.dq()} to ${value.format()}")
+        }
+        append(")")
+    }
+    else -> throw Exception("Unexpected node type: $this")
+}