feat: aws smoke tests support

.gitignore

@@ -12,8 +12,11 @@ build/
 .idea/
 __pycache__/
 local.properties
+
 # ignore generated files
 services/*/generated-src
 services/*/build.gradle.kts
 .kotest/
-*.klib
+*.klib
+tests/codegen/smoke-tests/services/*/generated-src
+tests/codegen/smoke-tests/services/*/build.gradle.kts

codegen/aws-sdk-codegen/build.gradle.kts

@@ -29,6 +29,7 @@ dependencies {
     api(libs.smithy.aws.cloudformation.traits)
     api(libs.smithy.protocol.test.traits)
     implementation(libs.smithy.aws.endpoints)
+    implementation(libs.smithy.smoke.test.traits)
 
     testImplementation(libs.junit.jupiter)
     testImplementation(libs.junit.jupiter.params)

codegen/aws-sdk-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/GradleGenerator.kt

@@ -4,9 +4,17 @@
  */
 package aws.sdk.kotlin.codegen
 
+import aws.sdk.kotlin.codegen.model.traits.testing.TestFailedResponseTrait
+import aws.sdk.kotlin.codegen.model.traits.testing.TestSuccessResponseTrait
+import aws.sdk.kotlin.codegen.smoketests.smokeTestDenyList
 import software.amazon.smithy.kotlin.codegen.core.*
 import software.amazon.smithy.kotlin.codegen.integration.KotlinIntegration
+import software.amazon.smithy.kotlin.codegen.model.expectShape
+import software.amazon.smithy.kotlin.codegen.model.hasTrait
 import software.amazon.smithy.kotlin.codegen.rendering.GradleWriter
+import software.amazon.smithy.kotlin.codegen.utils.topDownOperations
+import software.amazon.smithy.model.shapes.ServiceShape
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
 
 // TODO - would be nice to allow integrations to define custom settings in the plugin
 // e.g. we could then more consistently apply this integration if we could define a property like: `build.isAwsSdk: true`
@@ -64,9 +72,72 @@ class GradleGenerator : KotlinIntegration {
                             }
                         }
                 }
+                if (ctx.model.topDownOperations(ctx.settings.service).any { it.hasTrait<SmokeTestsTrait>() } && ctx.settings.sdkId !in smokeTestDenyList) {
+                    write("")
+                    generateSmokeTestConfig(writer, ctx)
+                }
             }
 
         val contents = writer.toString()
         delegator.fileManifest.writeFile("build.gradle.kts", contents)
     }
+
+    private fun generateSmokeTestConfig(writer: GradleWriter, ctx: CodegenContext) {
+        generateSmokeTestJarTask(writer, ctx)
+        writer.write("")
+        generateSmokeTestTask(writer, ctx)
+    }
+
+    /**
+     * Generates a gradle task to create smoke test runner JARs
+     */
+    private fun generateSmokeTestJarTask(writer: GradleWriter, ctx: CodegenContext) {
+        writer.withBlock("jvm {", "}") {
+            withBlock("compilations {", "}") {
+                write("val mainPath = getByName(#S).output.classesDirs", "main")
+                write("val testPath = getByName(#S).output.classesDirs", "test")
+                withBlock("tasks {", "}") {
+                    withBlock("register<Jar>(#S) {", "}", "smokeTestJar") {
+                        write("description = #S", "Creates smoke tests jar")
+                        write("group = #S", "application")
+                        write("dependsOn(build)")
+                        write("mustRunAfter(build)")
+                        withBlock("manifest {", "}") {
+                            write("attributes[#S] = #S", "Main-Class", "${ctx.settings.pkg.name}.smoketests.SmokeTestsKt")
+                        }
+                        write("val runtimePath = configurations.getByName(#S).map { if (it.isDirectory) it else zipTree(it) }", "jvmRuntimeClasspath")
+                        write("duplicatesStrategy = DuplicatesStrategy.EXCLUDE")
+                        write("from(runtimePath, mainPath, testPath)")
+                        write("archiveBaseName.set(#S)", "\${project.name}-smoketests")
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Generates a gradle task to run smoke tests
+     */
+    private fun generateSmokeTestTask(writer: GradleWriter, ctx: CodegenContext) {
+        val hasSuccessResponseTrait = ctx.model.expectShape<ServiceShape>(ctx.settings.service).hasTrait(TestSuccessResponseTrait.ID)
+        val hasFailedResponseTrait = ctx.model.expectShape<ServiceShape>(ctx.settings.service).hasTrait(TestFailedResponseTrait.ID)
+        val inTestingEnvironment = hasFailedResponseTrait || hasSuccessResponseTrait
+
+        /**
+         * E2E tests don't have sdkVersion in jar names. They're added later for publishing.
+         * @see SmokeTestE2ETest
+         */
+        val jarName = if (inTestingEnvironment) "\${project.name}-smoketests.jar" else "\${project.name}-smoketests-\$sdkVersion.jar"
+
+        writer.withBlock("tasks.register<JavaExec>(#S) {", "}", "smokeTest") {
+            write("description = #S", "Runs smoke tests jar")
+            write("group = #S", "verification")
+            write("dependsOn(tasks.getByName(#S))", "smokeTestJar")
+            write("mustRunAfter(tasks.getByName(#S))", "smokeTestJar")
+            write("")
+            write("val sdkVersion: String by project")
+            write("val jarFile = file(#S)", "build/libs/$jarName")
+            write("classpath = files(jarFile)")
+        }
+    }
 }

codegen/aws-sdk-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/model/traits/testing/SmokeTestTraits.kt

@@ -0,0 +1,27 @@
+package aws.sdk.kotlin.codegen.model.traits.testing
+
+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.
+ * IMPORTANT: This trait is intended for use in integration or E2E tests only, not in real-life smoke tests that run
+ * against a service endpoint.
+ */
+class TestFailedResponseTrait(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.
+ * IMPORTANT: This trait is intended for use in integration or E2E tests only, not in real-life smoke tests that run
+ * against a service endpoint.
+ */
+class TestSuccessResponseTrait(node: ObjectNode) : AnnotationTrait(ID, node) {
+    companion object {
+        val ID: ShapeId = ShapeId.from("smithy.kotlin.traits#successResponseTrait")
+    }
+}

codegen/aws-sdk-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/smoketests/SmokeTestAwsVendorParamsIntegration.kt

@@ -0,0 +1,150 @@
+package aws.sdk.kotlin.codegen.smoketests
+
+import aws.sdk.kotlin.codegen.AwsRuntimeTypes
+import software.amazon.smithy.kotlin.codegen.KotlinSettings
+import software.amazon.smithy.kotlin.codegen.core.RuntimeTypes
+import software.amazon.smithy.kotlin.codegen.core.getContextValue
+import software.amazon.smithy.kotlin.codegen.core.withBlock
+import software.amazon.smithy.kotlin.codegen.integration.KotlinIntegration
+import software.amazon.smithy.kotlin.codegen.integration.SectionWriterBinding
+import software.amazon.smithy.kotlin.codegen.model.hasTrait
+import software.amazon.smithy.kotlin.codegen.rendering.smoketests.*
+import software.amazon.smithy.kotlin.codegen.utils.topDownOperations
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
+
+/**
+ * Adds support for AWS specific client config during smoke tests code generation.
+ */
+class SmokeTestAwsVendorParamsIntegration : KotlinIntegration {
+    override fun enabledForService(model: Model, settings: KotlinSettings): Boolean =
+        model.topDownOperations(settings.service).any { it.hasTrait<SmokeTestsTrait>() }
+
+    override val sectionWriters: List<SectionWriterBinding>
+        get() =
+            dualStackSectionWriters +
+                sigv4aRegionSetSectionWriters +
+                uriSectionWriters +
+                accountIdEndpointSectionWriters +
+                regionSectionWriters +
+                useAccelerateSectionWriters +
+                useMultiRegionAccessPointsSectionWriters +
+                useGlobalEndpointSectionWriters
+}
+
+/**
+ * Uses the AWS Kotlin SDK specific name for the dual stack config option i.e. `useDualstack` -> `useDualStack`
+ */
+private val dualStackSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestUseDualStackKey) { writer, _ -> writer.writeInline("useDualStack") },
+)
+
+/**
+ * Uses the AWS Kotlin SDK specific name for the sigV4a signing region set option i.e.
+ * `sigv4aRegionSet` -> `sigV4aSigningRegionSet`.
+ *
+ * Converts the modeled sigV4a signing region set from a list to a set.
+ *
+ * Adds additional config needed for the SDK to make sigV4a calls
+ */
+private val sigv4aRegionSetSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestSigv4aRegionSetKey) { writer, _ -> writer.writeInline("sigV4aSigningRegionSet") },
+    SectionWriterBinding(SmokeTestSigv4aRegionSetValue) { writer, value ->
+        writer.write("#L.toSet()", value)
+        // TODO: Remove once sigV4a is supported for default signer.
+        writer.write(
+            "authSchemes = listOf(#T(#T))",
+            RuntimeTypes.Auth.HttpAuthAws.SigV4AsymmetricAuthScheme,
+            RuntimeTypes.Auth.AwsSigningCrt.CrtAwsSigner,
+        )
+    },
+)
+
+/**
+ * Ensures we use the provided URI
+ */
+private val uriSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestUriKey) { writer, _ -> writer.writeInline("endpointProvider") },
+    SectionWriterBinding(SmokeTestUriValue) { writer, value ->
+        val endpointProvider = writer.getContextValue(SmokeTestUriValue.EndpointProvider)
+        val endpointParameters = writer.getContextValue(SmokeTestUriValue.EndpointParameters)
+        writer.withBlock("object : #T {", "}", endpointProvider) {
+            write(
+                "override suspend fun resolveEndpoint(params: #T): #T = #T(#L)",
+                endpointParameters,
+                RuntimeTypes.SmithyClient.Endpoints.Endpoint,
+                RuntimeTypes.SmithyClient.Endpoints.Endpoint,
+                value,
+            )
+        }
+    },
+)
+
+/**
+ * Uses the AWS Kotlin SDK specific way of configuring `accountIdEndpointMode`
+ */
+private val accountIdEndpointSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestAccountIdBasedRoutingKey) { writer, _ -> writer.writeInline("accountIdEndpointMode") },
+    SectionWriterBinding(SmokeTestAccountIdBasedRoutingValue) { writer, value ->
+        when (value) {
+            "true" -> writer.write("#T.REQUIRED", AwsRuntimeTypes.Config.Endpoints.AccountIdEndpointMode)
+            "false" -> writer.write("#T.DISABLED", AwsRuntimeTypes.Config.Endpoints.AccountIdEndpointMode)
+        }
+    },
+)
+
+/**
+ * Gets region override environment variable.
+ *
+ * Sets region override as default.
+ *
+ * Sets region override as default client config if no other client config is modelled.
+ */
+private val regionSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestAdditionalEnvVars) { writer, _ ->
+        writer.write(
+            "private val regionOverride = #T.System.getenv(#S)",
+            RuntimeTypes.Core.Utils.PlatformProvider,
+            "AWS_SMOKE_TEST_REGION",
+        )
+    },
+    SectionWriterBinding(SmokeTestRegionDefault) { writer, _ ->
+        writer.writeInline("regionOverride ?: ")
+    },
+    SectionWriterBinding(SmokeTestDefaultConfig) { writer, _ -> writer.write("region = regionOverride") },
+)
+
+/**
+ * Uses the AWS Kotlin SDK specific name for the S3 accelerate config option i.e. `useAccelerate` -> `enableAccelerate`
+ */
+private val useAccelerateSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestUseAccelerateKey) { writer, _ -> writer.writeInline("enableAccelerate") },
+)
+
+/**
+ * Uses the AWS Kotlin SDK specific name for the S3 multi region access points (MRAP) config option i.e.
+ * `useMultiRegionAccessPoints` -> `disableMrap`.
+ *
+ * Our config option is opt out while the modeled config is opt in so we invert the boolean values.
+ */
+private val useMultiRegionAccessPointsSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestUseMultiRegionAccessPointsKey) { writer, _ -> writer.writeInline("disableMrap") },
+    SectionWriterBinding(SmokeTestUseMultiRegionAccessPointsValue) { writer, value ->
+        when (value) {
+            "true" -> writer.write("false")
+            "false" -> writer.write("true")
+        }
+    },
+)
+
+/**
+ * Leaves a comment in the client config whenever the use of the `useGlobalEndpoint` S3 config option is modeled.
+ *
+ * The SDK does not support this config option.
+ * See `BindAwsEndpointBuiltins` & `S3_USE_GLOBAL_ENDPOINT`
+ */
+private val useGlobalEndpointSectionWriters = listOf(
+    SectionWriterBinding(SmokeTestUseGlobalEndpoint) { writer, _ ->
+        writer.write("// Smoke tests modeled the use of `useGlobalEndpoint` config, but it's not supported by the SDK")
+    },
+)

codegen/aws-sdk-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/smoketests/SmokeTestsDenyListIntegration.kt

@@ -22,7 +22,7 @@ class SmokeTestsDenyListIntegration : KotlinIntegration {
         )
 
     private val smokeTestDenyListSectionWriter = SectionWriter { writer, _ ->
-        writer.write("// Smoke tests for service deny listed until model is fixed")
+        writer.write("// Smoke tests for service deny listed")
     }
 }
 
@@ -33,5 +33,4 @@ val smokeTestDenyList = setOf(
     "Application Auto Scaling",
     "SWF",
     "WAFV2",
-    "IoT Data Plane",
 )

codegen/aws-sdk-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/smoketests/testing/SmokeTestFailHttpEngineIntegration.kt

@@ -0,0 +1,50 @@
+package aws.sdk.kotlin.codegen.smoketests.testing
+
+import aws.sdk.kotlin.codegen.model.traits.testing.TestFailedResponseTrait
+import aws.sdk.kotlin.codegen.model.traits.testing.TestSuccessResponseTrait
+import software.amazon.smithy.kotlin.codegen.KotlinSettings
+import software.amazon.smithy.kotlin.codegen.core.RuntimeTypes
+import software.amazon.smithy.kotlin.codegen.core.withBlock
+import software.amazon.smithy.kotlin.codegen.integration.KotlinIntegration
+import software.amazon.smithy.kotlin.codegen.integration.SectionWriter
+import software.amazon.smithy.kotlin.codegen.integration.SectionWriterBinding
+import software.amazon.smithy.kotlin.codegen.model.expectShape
+import software.amazon.smithy.kotlin.codegen.model.hasTrait
+import software.amazon.smithy.kotlin.codegen.rendering.smoketests.SmokeTestHttpEngineOverride
+import software.amazon.smithy.kotlin.codegen.utils.topDownOperations
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.model.shapes.ServiceShape
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
+
+/**
+ * Adds [TestFailedResponseTrait] support to smoke tests
+ * IMPORTANT: This integration is intended for use in integration or E2E tests only, not in real-life smoke tests that run
+ * against a service endpoint.
+ */
+class SmokeTestFailHttpEngineIntegration : KotlinIntegration {
+    override fun enabledForService(model: Model, settings: KotlinSettings): Boolean =
+        model.topDownOperations(settings.service).any { it.hasTrait<SmokeTestsTrait>() } &&
+            !model.expectShape<ServiceShape>(settings.service).hasTrait(TestSuccessResponseTrait.ID) &&
+            model.expectShape<ServiceShape>(settings.service).hasTrait(TestFailedResponseTrait.ID)
+
+    override val sectionWriters: List<SectionWriterBinding>
+        get() = listOf(
+            SectionWriterBinding(SmokeTestHttpEngineOverride, httpClientOverride),
+        )
+
+    private val httpClientOverride = SectionWriter { writer, _ ->
+        writer.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)
+            }
+        }
+    }
+}

codegen/aws-sdk-codegen/src/main/kotlin/aws/sdk/kotlin/codegen/smoketests/testing/SmokeTestSuccessHttpEngineIntegration.kt

@@ -0,0 +1,37 @@
+package aws.sdk.kotlin.codegen.smoketests.testing
+
+import aws.sdk.kotlin.codegen.model.traits.testing.TestFailedResponseTrait
+import aws.sdk.kotlin.codegen.model.traits.testing.TestSuccessResponseTrait
+import software.amazon.smithy.kotlin.codegen.KotlinSettings
+import software.amazon.smithy.kotlin.codegen.core.RuntimeTypes
+import software.amazon.smithy.kotlin.codegen.integration.KotlinIntegration
+import software.amazon.smithy.kotlin.codegen.integration.SectionWriter
+import software.amazon.smithy.kotlin.codegen.integration.SectionWriterBinding
+import software.amazon.smithy.kotlin.codegen.model.expectShape
+import software.amazon.smithy.kotlin.codegen.model.hasTrait
+import software.amazon.smithy.kotlin.codegen.rendering.smoketests.SmokeTestHttpEngineOverride
+import software.amazon.smithy.kotlin.codegen.utils.topDownOperations
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.model.shapes.ServiceShape
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
+
+/**
+ * Adds [TestSuccessResponseTrait] support to smoke tests
+ * IMPORTANT: This integration is intended for use in integration or E2E tests only, not in real-life smoke tests that run
+ * against a service endpoint.
+ */
+class SmokeTestSuccessHttpEngineIntegration : KotlinIntegration {
+    override fun enabledForService(model: Model, settings: KotlinSettings): Boolean =
+        model.topDownOperations(settings.service).any { it.hasTrait<SmokeTestsTrait>() } &&
+            model.expectShape<ServiceShape>(settings.service).hasTrait(TestSuccessResponseTrait.ID) &&
+            !model.expectShape<ServiceShape>(settings.service).hasTrait(TestFailedResponseTrait.ID)
+
+    override val sectionWriters: List<SectionWriterBinding>
+        get() = listOf(
+            SectionWriterBinding(SmokeTestHttpEngineOverride, httpClientOverride),
+        )
+
+    private val httpClientOverride = SectionWriter { writer, _ ->
+        writer.write("httpClient = #T()", RuntimeTypes.HttpTest.TestEngine)
+    }
+}