func testGetTasksWithRemovingCompletedTasksEnabled()

in AWSS3Tests/AWSS3TransferUtilityTests.swift [2717:2855]
115 lines of code
8 McCabe index (conditional complexity)

    func testGetTasksWithRemovingCompletedTasksEnabled() {
        var uploadCount = 0;
        var mpUploadCount = 0;
        var downloadCount = 0;
        let key = UUID().uuidString
        let uploadsCompleted = self.expectation(description: "Uploads completed")
        let multiPartUploadsCompleted = self.expectation(description: "Multipart uploads completed")
        let downloadsCompleted = self.expectation(description: "Downloads completed")

        let serviceConfiguration = AWSServiceConfiguration(
            region: AWSS3TransferUtilityTests.region,
            credentialsProvider: AWSServiceManager.default().defaultServiceConfiguration.credentialsProvider
        )

        let transferUtilityConfiguration = AWSS3TransferUtilityConfiguration()

        AWSS3TransferUtility.register(
            with: serviceConfiguration!,
            transferUtilityConfiguration: transferUtilityConfiguration,
            forKey: key
        )

        let transferUtility = AWSS3TransferUtility.s3TransferUtility(forKey: key)
        XCTAssertNotNil(transferUtility)
        transferUtility?.shouldRemoveCompletedTasks = true
        let uploadExpression = AWSS3TransferUtilityUploadExpression()

        uploadExpression.progressBlock = { _, _ in }

        let uploadCompletionHandler = { (task: AWSS3TransferUtilityUploadTask, error: Error?) -> Void in
            XCTAssertNil(error)
            uploadCount = uploadCount + 1
            if ( uploadCount >= 3 ) {
                DispatchQueue.global().asyncAfter(deadline: .now() + 0.1) {
                    uploadsCompleted.fulfill()
                }
            }
            return
        }

        let multiPartUploadExpression = AWSS3TransferUtilityMultiPartUploadExpression()
        multiPartUploadExpression.progressBlock = { _, _ in }

        let multiPartUploadCompletionHandler = { (task: AWSS3TransferUtilityMultiPartUploadTask, error: Error?) -> Void in
            XCTAssertNil(error)
            mpUploadCount = mpUploadCount + 1
            if ( mpUploadCount >= 3 ) {
                DispatchQueue.global().asyncAfter(deadline: .now() + 0.1) {
                    multiPartUploadsCompleted.fulfill()
                }
            }
            return
        }

        let downloadExpression = AWSS3TransferUtilityDownloadExpression()
        downloadExpression.progressBlock = { _, _ in }

        let downloadCompletionHandler = { (task: AWSS3TransferUtilityDownloadTask, URL: Foundation.URL?, data: Data?, error: Error?) in
            XCTAssertNil(error)
            downloadCount = downloadCount + 1
            if ( downloadCount >= 6 ) {
                DispatchQueue.global().asyncAfter(deadline: .now() + 0.1) {
                    downloadsCompleted.fulfill()
                }
            }
            return
        }

        var testData = "Test123456789"
        for _ in 1...15 {
            testData = testData + testData;
        }

        //Upload 3 files
        for i in 1...3 {
            transferUtility?.uploadData(
                testData.data(using: String.Encoding.utf8)!,
                bucket: generalTestBucket,
                key: "testFileForGetTasks\(i).txt",
                contentType: "text/plain",
                expression: uploadExpression,
                completionHandler: uploadCompletionHandler
                ).continueWith (block: { (task) -> AnyObject? in
                    XCTAssertNil(task.error)
                    return nil
                })
        }

        wait(for:[uploadsCompleted],  timeout: 60)

        XCTAssertEqual(transferUtility?.getUploadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getDownloadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getMultiPartUploadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getAllTasks().result!.count, 0)

        //upload 3 more files using multipart
        for i in 4...6 {
            transferUtility?.uploadUsingMultiPart(
                data: testData.data(using: String.Encoding.utf8)!,
                bucket: generalTestBucket,
                key: "testFileForGetTasks\(i).txt",
                contentType: "text/plain",
                expression: multiPartUploadExpression,
                completionHandler: multiPartUploadCompletionHandler
                ).continueWith (block: { (task) -> AnyObject? in
                XCTAssertNil(task.error)
                return nil
                })
        }

        wait(for:[multiPartUploadsCompleted],  timeout: 60)

        XCTAssertEqual(transferUtility?.getUploadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getDownloadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getMultiPartUploadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getAllTasks().result!.count, 0)

        //Download 6 files
        for i in 1...6 {
            let url = NSURL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("file\(i)")
            transferUtility?.download(to: url!,
                                 bucket: generalTestBucket,
                                    key: "testFileForGetTasks\(i).txt",
                expression: downloadExpression,
                completionHandler: downloadCompletionHandler).continueWith(block: { (task) -> Any? in
                    XCTAssertNil(task.error)
                    return nil
                })
        }

        wait(for:[downloadsCompleted],  timeout: 120)

        XCTAssertEqual(transferUtility?.getUploadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getDownloadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getMultiPartUploadTasks().result!.count, 0)
        XCTAssertEqual(transferUtility?.getAllTasks().result!.count, 0)

        AWSS3TransferUtility.remove(forKey: key)
    }