chore: Add & improve concurrent tests

.gitignore

@@ -40,3 +40,6 @@ SmokeTests/
 # Allow the AWSSDKSwiftCLI Package.resolved
 # while excluding all other Package.resolved files
 !/AWSSDKSwiftCLI/Package.resolved
+
+# Xcode config that is for the installed copy only
+xcuserdata

IntegrationTests/Services/AWSS3IntegrationTests/S3ConcurrentTests.swift

@@ -12,48 +12,69 @@ import XCTest
 import AWSS3
 import AWSIntegrationTestUtils
 
-class S3ConcurrentTests: S3XCTestCase {
-    public var fileData: Data!
-    let MEGABYTE: Double = 1_000_000
-
-    #if !os(macOS) && !os(iOS) && !os(tvOS) && !os(visionOS)
-    // Payload below 1,048,576 bytes; sends as simple data payload
-    func test_20x_1MB_getObject() async throws {
-        fileData = try generateDummyTextData(numMegabytes: MEGABYTE)
-        try await repeatConcurrentlyWithArgs(count: 20, test: getObject, args: fileData!)
+final class S3ConcurrentTests: S3XCTestCase {
+    private var fileData: Data!
+
+    // Payload just below chunked threshold
+    // Tests concurrent upload of simple data payloads
+    func test_10x_1MB_getObject() async throws {
+        fileData = try generateDummyTextData(count: CHUNKED_THRESHOLD - 1)
+        try await repeatConcurrentlyWithArgs(count: 10, test: getObject, args: fileData!)
+    }
+
+    // Payload at chunked threshold, just large enough to chunk
+    // Tests concurrent upload with aws-chunked encoding & flexible checksums
+    func test_10x_1_5MB_getObject() async throws {
+        fileData = try generateDummyTextData(count: CHUNKED_THRESHOLD)
+        try await repeatConcurrentlyWithArgs(count: 10, test: getObject, args: fileData!)
     }
 
-    // Payload over 1,048,576 bytes; uses aws chunked encoding & flexible checksum
-    func test_20x_1_5MB_getObject() async throws {
-        fileData = try generateDummyTextData(numMegabytes: MEGABYTE * 1.5)
-        try await repeatConcurrentlyWithArgs(count: 20, test: getObject, args: fileData!)
+    // Payload 256 bytes with 200 concurrent requests, sends as simple data
+    // Tests very high concurrency with small data payloads
+    func test_200x_256B_getObject() async throws {
+        fileData = try generateDummyTextData(count: 256)
+        try await repeatConcurrentlyWithArgs(count: 200, test: getObject, args: fileData!)
     }
-    #endif
 
-    /* Helper functions */
+    // MARK: - Private methods
 
-    // Generates text data in increments of 10 bytes
-    func generateDummyTextData(numMegabytes: Double) throws -> Data {
-        let segmentData = Data("1234567890".utf8)
+    // Generates text data of the exact length requested
+    private func generateDummyTextData(count: Int) throws -> Data {
+        let segment = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
+        let segmentData = Data(segment.utf8)
         var wholeData = Data()
-        for _ in 0..<(Int(numMegabytes)/10) {
-            wholeData.append(segmentData)
+        for _ in 0..<(count / segmentData.count + 1) {
+            wholeData.append(contentsOf: segmentData.shuffled())
         }
-        return wholeData
+        // Truncate data to exactly the required length
+        return wholeData.subdata(in: 0..<count)
     }
 
-    // Puts data to S3, gets the uploaded file, then asserts retrieved data equals original data
-    func getObject(args: Any...) async throws {
+    // Puts data to S3, gets the uploaded file, asserts retrieved data == original data, deletes S3 object
+    private func getObject(args: Any...) async throws {
+
+        // Take the test data and crate a PutObject request to send it
         guard let data = args[0] as? Data else {
             throw ClientError.dataNotFound("Failed to retrieve dummy data.")
         }
         let file = ByteStream.data(data)
         let objectKey = UUID().uuidString.split(separator: "-").first!.lowercased()
         let putObjectInput = PutObjectInput(body: file, bucket: bucketName, key: objectKey)
+
+        // Put the test data to S3
         _ = try await client.putObject(input: putObjectInput)
+
+        // Read the response's data stream into memory
         let retrievedData = try await client.getObject(input: GetObjectInput(
             bucket: bucketName, key: objectKey
         )).body?.readData()
+
+        // Compare the retrieved data to the uploaded data to show they are equal
         XCTAssertEqual(data, retrievedData)
+
+        // Delete the S3 object once the test has been verified
+        // Calling DeleteObject here allows for concurrent deletion, accelerating test teardown
+        let deleteObjectInput = DeleteObjectInput(bucket: bucketName, key: objectKey)
+        _ = try await client.deleteObject(input: deleteObjectInput)
     }
 }

IntegrationTests/Services/AWSTranscribeStreamingIntegrationTests/TranscribeStreamingTests.swift

@@ -6,14 +6,39 @@
 //
 
 import XCTest
+import AWSIntegrationTestUtils
 import Foundation
 import AWSTranscribeStreaming
+import protocol AWSClientRuntime.AWSServiceError
 
 final class TranscribeStreamingTests: XCTestCase {
 
-    func testStartStreamTranscription() async throws {
+    // MARK: - Test transcription
 
-        // The heelo-swift.wav resource is an audio file that contains an automated voice
+    func test_single_streamTranscription() async throws {
+        try await attempt()
+    }
+
+    // Concurrent stream transcription frequently fails on the CRT HTTP client with errors
+    // such as:
+    // code: 2058, message: "The connection has closed or is closing."
+    // code: 2087, message: "Stream acquisition failed because stream manager failed to acquire a connection"
+    //
+    // Disable this test on the CRT client until these failures can be investigated & corrected.
+    #if !os(Linux) && !os(Windows)
+    func test_25xConcurrent_streamTranscription() async throws {
+        // By default the TranscribeStreaming service allows 25 concurrent transcriptions.
+        // More than that (which can happen when multiple test runs are being performed) will result
+        // in throttling / resource exceeded errors, which may be retried (see retry logic below.)
+        try await repeatConcurrently(count: 25, test: attempt)
+    }
+    #endif
+
+    // MARK: - Private / implementation methods
+
+    private func performStreamTranscription() async throws {
+
+        // The hello-swift.wav resource is an audio file that contains an automated voice
         // saying the words "Hello transcribed streaming from Swift S. D. K.".
         // It is 2.976 seconds in duration.
         let audioURL = Bundle.module.url(forResource: "hello-swift", withExtension: "wav")!
@@ -82,4 +107,25 @@ final class TranscribeStreamingTests: XCTestCase {
         ]
         XCTAssertTrue(candidates.contains(where: { $0.lowercased() == fullMessage.lowercased() }))
     }
+
+    // Performs the stream transcription, with retry for selected errors associated with
+    // rate limiting & throttling.
+    //
+    // Normal retry is not applied to transcribe streaming because the request body is a
+    // non-rewindable stream.
+    private func attempt() async throws {
+        // These throttling / resource limit errors may be returned based on the number of
+        // recent requests made to AWSTranscribeStreaming.
+        let retryableCodes: [String?] = ["ThrottlingException", "LimitExceededException"]
+
+        // Perform the transcribe operation, with special handling for the two retryable errors.
+        do {
+            try await self.performStreamTranscription()
+        } catch let error as AWSServiceError where retryableCodes.contains(error.errorCode) {
+            // Wait randomly between 1-3 sec, then attempt again.
+            try await Task.sleep(nanoseconds: UInt64.random(in: 1_000_000_000...3_000_000_000))
+            try await self.attempt()
+        }
+        // Any other error thrown is not caught and will fail the test.
+    }
 }