v2 Smoketest codegen

aws/sdk-codegen/build.gradle.kts

@@ -27,6 +27,8 @@ dependencies {
     implementation("software.amazon.smithy:smithy-protocol-test-traits:$smithyVersion")
     implementation("software.amazon.smithy:smithy-rules-engine:$smithyVersion")
     implementation("software.amazon.smithy:smithy-aws-endpoints:$smithyVersion")
+    implementation("software.amazon.smithy:smithy-smoke-test-traits:$smithyVersion")
+    implementation("software.amazon.smithy:smithy-aws-smoke-test-model:$smithyVersion")
 }
 
 java {

aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/AwsCodegenDecorator.kt

@@ -63,6 +63,7 @@ val DECORATORS: List<ClientCodegenDecorator> =
             TokenProvidersDecorator(),
             ServiceEnvConfigDecorator(),
             HttpRequestCompressionDecorator(),
+            SmokeTestsDecorator(),
         ),
         // S3 needs `AwsErrorCodeClassifier` to handle an `InternalError` as a transient error. We need to customize
         // that behavior for S3 in a way that does not conflict with the globally applied `RetryClassifierDecorator`.

aws/sdk-codegen/src/main/kotlin/software/amazon/smithy/rustsdk/SmokeTestsDecorator.kt

@@ -0,0 +1,217 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rustsdk
+
+import software.amazon.smithy.aws.smoketests.model.AwsSmokeTestModel
+import software.amazon.smithy.model.Model
+import software.amazon.smithy.model.node.ObjectNode
+import software.amazon.smithy.model.shapes.MemberShape
+import software.amazon.smithy.model.shapes.OperationShape
+import software.amazon.smithy.model.shapes.StructureShape
+import software.amazon.smithy.rust.codegen.client.smithy.ClientCodegenContext
+import software.amazon.smithy.rust.codegen.client.smithy.customize.ClientCodegenDecorator
+import software.amazon.smithy.rust.codegen.client.smithy.generators.client.FluentClientGenerator
+import software.amazon.smithy.rust.codegen.core.rustlang.Attribute
+import software.amazon.smithy.rust.codegen.core.rustlang.Attribute.Companion.cfg
+import software.amazon.smithy.rust.codegen.core.rustlang.AttributeKind
+import software.amazon.smithy.rust.codegen.core.rustlang.RustWriter
+import software.amazon.smithy.rust.codegen.core.rustlang.containerDocs
+import software.amazon.smithy.rust.codegen.core.rustlang.docs
+import software.amazon.smithy.rust.codegen.core.rustlang.rust
+import software.amazon.smithy.rust.codegen.core.rustlang.rustBlock
+import software.amazon.smithy.rust.codegen.core.smithy.CodegenContext
+import software.amazon.smithy.rust.codegen.core.smithy.RustCrate
+import software.amazon.smithy.rust.codegen.core.smithy.generators.BuilderGenerator
+import software.amazon.smithy.rust.codegen.core.smithy.generators.Instantiator
+import software.amazon.smithy.rust.codegen.core.smithy.generators.setterName
+import software.amazon.smithy.rust.codegen.core.testutil.integrationTest
+import software.amazon.smithy.rust.codegen.core.util.dq
+import software.amazon.smithy.rust.codegen.core.util.expectTrait
+import software.amazon.smithy.rust.codegen.core.util.inputShape
+import software.amazon.smithy.rust.codegen.core.util.orNull
+import software.amazon.smithy.rust.codegen.core.util.toSnakeCase
+import software.amazon.smithy.smoketests.traits.Expectation
+import software.amazon.smithy.smoketests.traits.SmokeTestCase
+import software.amazon.smithy.smoketests.traits.SmokeTestsTrait
+import java.util.Optional
+import java.util.logging.Logger
+
+class SmokeTestsDecorator : ClientCodegenDecorator {
+    override val name: String = "SmokeTests"
+    override val order: Byte = 0
+    private val logger: Logger = Logger.getLogger(javaClass.name)
+
+    private fun isSmokeTestSupported(smokeTestCase: SmokeTestCase): Boolean {
+        AwsSmokeTestModel.getAwsVendorParams(smokeTestCase)?.orNull()?.let { vendorParams ->
+            if (vendorParams.sigv4aRegionSet.isPresent) {
+                logger.warning("skipping smoketest `${smokeTestCase.id}` with unsupported vendorParam `sigv4aRegionSet`")
+                return false
+            }
+            if (vendorParams.useAccountIdRouting()) {
+                logger.warning("skipping smoketest `${smokeTestCase.id}` with unsupported vendorParam `useAccountIdRouting`")
+                return false
+            }
+        }
+        AwsSmokeTestModel.getS3VendorParams(smokeTestCase)?.orNull()?.let { s3VendorParams ->
+            if (s3VendorParams.useGlobalEndpoint()) {
+                logger.warning("skipping smoketest `${smokeTestCase.id}` with unsupported vendorParam `useGlobalEndpoint`")
+                return false
+            }
+        }
+
+        return true
+    }
+
+    override fun extras(
+        codegenContext: ClientCodegenContext,
+        rustCrate: RustCrate,
+    ) {
+        // Get all operations with smoke tests
+        val smokeTestedOperations =
+            codegenContext.model.getOperationShapesWithTrait(SmokeTestsTrait::class.java).toList()
+        val supportedTests =
+            smokeTestedOperations.map { operationShape ->
+                // filter out unsupported smoke tests, logging a warning for each one.
+                val testCases =
+                    operationShape.expectTrait<SmokeTestsTrait>().testCases.filter { smokeTestCase ->
+                        isSmokeTestSupported(smokeTestCase)
+                    }
+
+                operationShape to testCases
+            }
+                // filter out operations with no supported smoke tests
+                .filter { (_, testCases) -> testCases.isNotEmpty() }
+        // Return if there are no supported smoke tests across all operations
+        if (supportedTests.isEmpty()) return
+
+        rustCrate.integrationTest("smoketests") {
+            // Don't run the tests in this module unless `RUSTFLAGS="--cfg smoketests"` is passed.
+            Attribute(cfg("smoketests")).render(this, AttributeKind.Inner)
+
+            containerDocs(
+                """
+                The tests in this module run against live AWS services. As such,
+                they are disabled by default. To enable them, run the tests with
+
+                ```sh
+                RUSTFLAGS="--cfg smoketests" cargo test.
+                ```""",
+            )
+
+            val model = codegenContext.model
+            val moduleUseName = codegenContext.moduleUseName()
+            rust("use $moduleUseName::{ Client, config };")
+
+            for ((operationShape, testCases) in supportedTests) {
+                val operationName = operationShape.id.name.toSnakeCase()
+                val operationInput = operationShape.inputShape(model)
+
+                docs("Smoke tests for the `$operationName` operation")
+
+                for (testCase in testCases) {
+                    Attribute.TokioTest.render(this)
+                    this.rustBlock("async fn test_${testCase.id.toSnakeCase()}()") {
+                        val instantiator = SmokeTestsInstantiator(codegenContext)
+                        instantiator.renderConf(this, testCase)
+                        rust("let client = Client::from_conf(conf);")
+                        instantiator.renderInput(this, operationShape, operationInput, testCase.params)
+                        instantiator.renderExpectation(this, model, testCase.expectation)
+                    }
+                }
+            }
+        }
+    }
+}
+
+class SmokeTestsBuilderKindBehavior(val codegenContext: CodegenContext) : Instantiator.BuilderKindBehavior {
+    override fun hasFallibleBuilder(shape: StructureShape): Boolean =
+        BuilderGenerator.hasFallibleBuilder(shape, codegenContext.symbolProvider)
+
+    override fun setterName(memberShape: MemberShape): String = memberShape.setterName()
+
+    override fun doesSetterTakeInOption(memberShape: MemberShape): Boolean = true
+}
+
+class SmokeTestsInstantiator(private val codegenContext: ClientCodegenContext) : Instantiator(
+    codegenContext.symbolProvider,
+    codegenContext.model,
+    codegenContext.runtimeConfig,
+    SmokeTestsBuilderKindBehavior(codegenContext),
+) {
+    fun renderConf(
+        writer: RustWriter,
+        testCase: SmokeTestCase,
+    ) {
+        writer.rust("let conf = config::Builder::new()")
+        writer.indent()
+        writer.rust(".behavior_version(config::BehaviorVersion::latest())")
+
+        val vendorParams = AwsSmokeTestModel.getAwsVendorParams(testCase)
+        vendorParams.orNull()?.let { params ->
+            writer.rust(".region(config::Region::new(${params.region.dq()}))")
+            writer.rust(".use_dual_stack(${params.useDualstack()})")
+            writer.rust(".use_fips(${params.useFips()})")
+            params.uri.orNull()?.let { writer.rust(".endpoint_url($it)") }
+        }
+
+        val s3VendorParams = AwsSmokeTestModel.getS3VendorParams(testCase)
+        s3VendorParams.orNull()?.let { params ->
+            writer.rust(".accelerate_(${params.useAccelerate()})")
+            writer.rust(".force_path_style_(${params.forcePathStyle()})")
+            writer.rust(".use_arn_region(${params.useArnRegion()})")
+            writer.rust(".disable_multi_region_access_points(${params.useMultiRegionAccessPoints().not()})")
+        }
+
+        writer.rust(".build();")
+        writer.dedent()
+    }
+
+    fun renderInput(
+        writer: RustWriter,
+        operationShape: OperationShape,
+        inputShape: StructureShape,
+        data: Optional<ObjectNode>,
+        headers: Map<String, String> = mapOf(),
+        ctx: Ctx = Ctx(),
+    ) {
+        val operationBuilderName =
+            FluentClientGenerator.clientOperationFnName(operationShape, codegenContext.symbolProvider)
+
+        writer.rust("let res = client.$operationBuilderName()")
+        writer.indent()
+        data.orNull()?.let {
+            renderStructureMembers(writer, inputShape, it, headers, ctx)
+        }
+        writer.rust(".send().await;")
+        writer.dedent()
+    }
+
+    fun renderExpectation(
+        writer: RustWriter,
+        model: Model,
+        expectation: Expectation,
+    ) {
+        if (expectation.isSuccess) {
+            writer.rust("""res.expect("request should succeed");""")
+        } else if (expectation.isFailure) {
+            val expectedErrShape = expectation.failure.orNull()?.errorId?.orNull()
+            println(expectedErrShape)
+            if (expectedErrShape != null) {
+                val failureShape = model.expectShape(expectedErrShape)
+                val errName = codegenContext.symbolProvider.toSymbol(failureShape).name.toSnakeCase()
+                writer.rust(
+                    """
+                    let err = res.expect_err("request should fail");
+                    let err = err.into_service_error();
+                    assert!(err.is_$errName())
+                    """,
+                )
+            } else {
+                writer.rust("""res.expect_err("request should fail");""")
+            }
+        }
+    }
+}

aws/sdk-codegen/src/test/kotlin/software/amazon/smithy/rustsdk/SmokeTestsDecoratorTest.kt

@@ -0,0 +1,96 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package software.amazon.smithy.rustsdk
+
+import org.junit.jupiter.api.Test
+import software.amazon.smithy.rust.codegen.core.testutil.asSmithyModel
+
+class SmokeTestsDecoratorTest {
+    companion object {
+        // Can't use the dollar sign in a multiline string with doing it like this.
+        private const val PREFIX = "\$version: \"2\""
+        val model =
+            """
+            $PREFIX
+            namespace test
+
+            use aws.api#service
+            use smithy.test#smokeTests
+            use aws.auth#sigv4
+            use aws.protocols#restJson1
+            use smithy.rules#endpointRuleSet
+
+            @service(sdkId: "dontcare")
+            @restJson1
+            @sigv4(name: "dontcare")
+            @auth([sigv4])
+            @endpointRuleSet({
+                "version": "1.0",
+                "rules": [{ "type": "endpoint", "conditions": [], "endpoint": { "url": "https://example.com" } }],
+                "parameters": {
+                    "Region": { "required": false, "type": "String", "builtIn": "AWS::Region" },
+                }
+            })
+            service TestService {
+                version: "2023-01-01",
+                operations: [SomeOperation]
+            }
+
+            @smokeTests([
+                {
+                    id: "SomeOperationSuccess",
+                    params: {}
+                    vendorParams: {
+                        region: "us-west-2"
+                    }
+                    expect: { success: {} }
+                }
+                {
+                    id: "SomeOperationFailure",
+                    params: {}
+                    vendorParams: {
+                        region: "us-west-2"
+                    }
+                    expect: { failure: {} }
+                }
+                {
+                    id: "SomeOperationFailureExplicitShape",
+                    params: {}
+                    vendorParams: {
+                        region: "us-west-2"
+                    }
+                    expect: {
+                        failure: { errorId: FooException }
+                    }
+                }
+            ])
+            @http(uri: "/SomeOperation", method: "POST")
+            @optionalAuth
+            operation SomeOperation {
+                input: SomeInput,
+                output: SomeOutput,
+                errors: [FooException]
+            }
+
+            @input
+            structure SomeInput {}
+
+            @output
+            structure SomeOutput {}
+
+            @error("server")
+            structure FooException { }
+            """.asSmithyModel()
+    }
+
+    @Test
+    fun smokeTestSdkCodegen() {
+        awsSdkIntegrationTest(model) { _, _ ->
+            // It should compile. We can't run the tests
+            // because they don't target a real service.
+        }
+    }
+}

tools/ci-scripts/check-aws-sdk-services

@@ -7,9 +7,14 @@
 set -eux
 cd aws-sdk
 
-# Invoking `cargo test` at the root directory implicitly checks for the validity
-# of the top-level `Cargo.toml`
-cargo test --all-features
+# Check if the $ENABLE_SMOKETESTS environment variable is set
+if [ -n "$ENABLE_SMOKETESTS" ]; then
+    # Invoking `cargo test` at the root directory implicitly checks for the validity
+    # of the top-level `Cargo.toml`
+    RUSTFLAGS="--cfg smoketests" cargo test --all-features
+else
+    cargo test --all-features
+fi
 
 for test_dir in tests/*; do
     if [ -f "${test_dir}/Cargo.toml" ]; then