AWS SDK

                        // Run the tests with the classpath containing the compile dependencies (including 'main'),

                        // runtime dependencies, and the outputs of this compilation:

                        classpath = compileDependencyFiles + runtimeDependencyFiles + output.allOutputs

                        // Run only the tests from this compilation's outputs:

                        testClassesDirs = output.classesDirs

                        useJUnitPlatform()

                        testLogging {

                            events("passed", "skipped", "failed")

                            showStandardStreams = true

                            showStackTraces = true

                            showExceptions = true

                            exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL

                        }

                        // model a random input to enable re-running e2e tests back to back without

                        // up-to-date checks or cache getting in the way

                        inputs.property("integration.datetime", LocalDateTime.now())

                        systemProperty("org.slf4j.simpleLogger.defaultLogLevel", System.getProperty("org.slf4j.simpleLogger.defaultLogLevel", "WARN"))

            }

        }

    }

}

// Configure Dokka for subprojects

dependencies {

    subprojects.forEach {

        it.plugins.apply("dokka-convention") // Apply the Dokka conventions plugin to the subproject

        dokka(project(it.path)) // Aggregate the subproject's generated documentation

    }

    // Preserve Dokka v1 module paths

    // https://kotlinlang.org/docs/dokka-migration.html#revert-to-the-dgp-v1-directory-behavior

    subprojects {

        dokka {

            modulePath = this@subprojects.name

        }

    }

}

                    description = "Creates smoke tests jar"

                    group = "application"

                    dependsOn(build)

                    mustRunAfter(build)

                    manifest {

                        attributes["Main-Class"] = "aws.sdk.kotlin.services.codebuild.smoketests.SmokeTestsKt"

                    }

                    val runtimePath = configurations.getByName("jvmRuntimeClasspath").map { if (it.isDirectory) it else zipTree(it) }

                    duplicatesStrategy = DuplicatesStrategy.EXCLUDE

                    from(runtimePath, mainPath, testPath)

                    archiveBaseName.set("${project.name}-smoketests")

                }

            }

        }

    }

    tasks.register<JavaExec>("smokeTest") {

        description = "Runs smoke tests jar"

        group = "verification"

        dependsOn(tasks.getByName("smokeTestJar"))

                    description = "Creates smoke tests jar"

                    group = "application"

                    dependsOn(build)

                    mustRunAfter(build)

                    manifest {

                        attributes["Main-Class"] = "aws.sdk.kotlin.services.dynamodb.smoketests.SmokeTestsKt"

                    }

                    val runtimePath = configurations.getByName("jvmRuntimeClasspath").map { if (it.isDirectory) it else zipTree(it) }

                    duplicatesStrategy = DuplicatesStrategy.EXCLUDE

                    from(runtimePath, mainPath, testPath)

                    archiveBaseName.set("${project.name}-smoketests")

                }

            }

        }

    }

    tasks.register<JavaExec>("smokeTest") {

        description = "Runs smoke tests jar"

        group = "verification"

        dependsOn(tasks.getByName("smokeTestJar"))

    }

}

public class SmokeTestRunner(private val platform: PlatformProvider = PlatformProvider.System, private val printer: Appendable = DefaultPrinter) {

    private val skipTags = platform.getenv("AWS_SMOKE_TEST_SKIP_TAGS")?.let { it.split(",").map { it.trim() }.toSet() } ?: emptySet()

    private val serviceFilter = platform.getenv("AWS_SMOKE_TEST_SERVICE_IDS")?.let { it.split(",").map { it.trim() }.toSet() } ?: emptySet()

    private val regionOverride = PlatformProvider.System.getenv("AWS_SMOKE_TEST_REGION")

    public suspend fun runAllTests(): Boolean =

        listOf<suspend () -> Boolean>(

            ::listTablesSuccess,

        )

            .map { it() }

            .all { it }

    private suspend fun listTablesSuccess(): Boolean {

        val tags = setOf<String>()

        if ((serviceFilter.isNotEmpty() && "DynamoDB" !in serviceFilter) || tags.any { it in skipTags }) {

            printer.appendLine("ok DynamoDB ListTablesSuccess - no error expected from service # skip")

            if (!success) {

                printer.appendLine(exception.stackTraceToString().prependIndent("# "))

            }

            success

        }

    }

}

                    description = "Creates smoke tests jar"

                    group = "application"

                    dependsOn(build)

                    mustRunAfter(build)

                    manifest {

                        attributes["Main-Class"] = "aws.sdk.kotlin.services.ec2.smoketests.SmokeTestsKt"

                    }

                    val runtimePath = configurations.getByName("jvmRuntimeClasspath").map { if (it.isDirectory) it else zipTree(it) }

                    duplicatesStrategy = DuplicatesStrategy.EXCLUDE

                    from(runtimePath, mainPath, testPath)

                    archiveBaseName.set("${project.name}-smoketests")

                }

            }

        }

    }

    tasks.register<JavaExec>("smokeTest") {

        description = "Runs smoke tests jar"

        group = "verification"

        dependsOn(tasks.getByName("smokeTestJar"))

}

public class SmokeTestRunner(private val platform: PlatformProvider = PlatformProvider.System, private val printer: Appendable = DefaultPrinter) {

    private val skipTags = platform.getenv("AWS_SMOKE_TEST_SKIP_TAGS")?.let { it.split(",").map { it.trim() }.toSet() } ?: emptySet()

    private val serviceFilter = platform.getenv("AWS_SMOKE_TEST_SERVICE_IDS")?.let { it.split(",").map { it.trim() }.toSet() } ?: emptySet()

    private val regionOverride = PlatformProvider.System.getenv("AWS_SMOKE_TEST_REGION")

    public suspend fun runAllTests(): Boolean =

        listOf<suspend () -> Boolean>(

            ::describeInstancesFailure,

            ::describeRegionsSuccess,

        )

            .map { it() }

            .all { it }

    private suspend fun describeInstancesFailure(): Boolean {

        val tags = setOf<String>()

        if ((serviceFilter.isNotEmpty() && "EC2" !in serviceFilter) || tags.any { it in skipTags }) {

            printer.appendLine("ok EC2 DescribeInstancesFailure - error expected from service # skip")

            val status: String = if (success) "ok" else "not ok"

            printer.appendLine("$status EC2 DescribeInstancesFailure - error expected from service ")

            if (!success) {

                printer.appendLine(exception.stackTraceToString().prependIndent("# "))

            }

            success

        }

    }

    private suspend fun describeRegionsSuccess(): Boolean {

        val tags = setOf<String>()

        if ((serviceFilter.isNotEmpty() && "EC2" !in serviceFilter) || tags.any { it in skipTags }) {

            printer.appendLine("ok EC2 DescribeRegionsSuccess - no error expected from service # skip")

            return true

        }

        return try {

            Ec2Client {

                interceptors.add(SmokeTestsInterceptor())

        compilations {

            val mainPath = getByName("main").output.classesDirs

            val testPath = getByName("test").output.classesDirs

            tasks {

                register<Jar>("smokeTestJar") {

                    description = "Creates smoke tests jar"

                    group = "application"

                    dependsOn(build)

                    mustRunAfter(build)

                    manifest {

                        attributes["Main-Class"] = "aws.sdk.kotlin.services.polly.smoketests.SmokeTestsKt"

                    }

                    val runtimePath = configurations.getByName("jvmRuntimeClasspath").map { if (it.isDirectory) it else zipTree(it) }

                    duplicatesStrategy = DuplicatesStrategy.EXCLUDE

                    from(runtimePath, mainPath, testPath)

                    archiveBaseName.set("${project.name}-smoketests")

                }

            }

        }

    }

import aws.sdk.kotlin.services.s3.model.*

import aws.sdk.kotlin.services.s3.model.BucketLocationConstraint

import aws.sdk.kotlin.services.s3.model.CreateBucketConfiguration

import aws.sdk.kotlin.services.s3.model.CreateBucketRequest

import aws.smithy.kotlin.runtime.auth.awscredentials.Credentials

import aws.smithy.kotlin.runtime.auth.awscredentials.CredentialsProvider

import aws.smithy.kotlin.runtime.collections.Attributes

import aws.smithy.kotlin.runtime.http.HttpMethod

import aws.smithy.kotlin.runtime.smithy.test.*

import kotlin.test.*

import kotlin.test.Test

class CreateBucketRequestTest {

    /**

     * Validates https://github.com/awslabs/aws-sdk-kotlin/issues/567 (empty body)

     */

    @Test

    fun `CreateBucketNoBody`() = httpRequestTest {

        expected {

            service.createBucket(input)

        }

    }

}

import aws.smithy.kotlin.runtime.auth.awscredentials.CredentialsProvider

import aws.smithy.kotlin.runtime.collections.Attributes

import aws.smithy.kotlin.runtime.content.ByteStream

import aws.smithy.kotlin.runtime.http.HttpMethod

import aws.smithy.kotlin.runtime.smithy.test.*

import kotlin.test.*

import kotlin.test.Test

class PutObjectRequestTest {

    /**

     * This test case validates default content-type behavior when not specified in the request

     */

    @Test

    fun `PutObjectDefaultContentType`() = httpRequestTest {

        expected {

            method = HttpMethod.PUT

            uri = "/mykey"

            headers = mapOf(

                "Content-Type" to "application/octet-stream"

        }

    }

}