func testSuspendResumeUploadAndDownloadLargeDataLongDelay()

in AWSS3Tests/AWSS3TransferUtilityTests.swift [441:538]
81 lines of code
4 McCabe index (conditional complexity)

    func testSuspendResumeUploadAndDownloadLargeDataLongDelay() {
        let expectation = self.expectation(description: "The completion handler called.")
        var dataString = "Test12"
        for _ in 1...22 {
            dataString = dataString + dataString;
        }
        
        // the test key is 1234567890123456
        let password = "MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTI="
        let passwordMD5 = "dnF5x6K/8ZZRzpfSlMMM+w=="
        
        let transferUtility = AWSS3TransferUtility.s3TransferUtility(forKey: "with-retry")
        XCTAssertNotNil(transferUtility)
        let uploadExpression = AWSS3TransferUtilityUploadExpression()
        uploadExpression.setValue("AES256", forRequestHeader: "x-amz-server-side-encryption-customer-algorithm")
        uploadExpression.setValue(password, forRequestHeader: "x-amz-server-side-encryption-customer-key")
        uploadExpression.setValue(passwordMD5, forRequestHeader: "x-amz-server-side-encryption-customer-key-MD5")
        uploadExpression.progressBlock = { _, _ in }
        
        let uploadCompletionHandler = { (task: AWSS3TransferUtilityUploadTask, error: Error?) -> Void in
            XCTAssertNil(error)
            if let HTTPResponse = task.response {
                XCTAssertEqual(HTTPResponse.statusCode, 200)
                
                let downloadExpression = AWSS3TransferUtilityDownloadExpression()
                downloadExpression.setValue("AES256", forRequestHeader: "x-amz-server-side-encryption-customer-algorithm")
                downloadExpression.setValue(password, forRequestHeader: "x-amz-server-side-encryption-customer-key")
                downloadExpression.setValue(passwordMD5, forRequestHeader: "x-amz-server-side-encryption-customer-key-MD5")
                downloadExpression.progressBlock = {(task, progress) in
                    print("Download progress: ", progress.fractionCompleted)
                }
                let downloadCompletionHandler = { (task: AWSS3TransferUtilityDownloadTask, URL: Foundation.URL?, data: Data?, error: Error?) in
                    if let HTTPResponse = task.response {
                        XCTAssertEqual(HTTPResponse.statusCode, 200)
                        XCTAssertEqual(data, dataString.data(using: String.Encoding.utf8)!)
                        XCTAssertEqual(HTTPResponse.allHeaderFields["Content-Type"] as? String, "text/plain")
                    } else {
                        XCTFail()
                    }
                    
                    expectation.fulfill()
                }
                
                var refDownloadTask:AWSS3TransferUtilityDownloadTask?
                
                transferUtility?.downloadData(
                    fromBucket: generalTestBucket,
                    key: "testSuspendResumeUploadAndDownloadLargeDataLongDelay.txt",
                    expression: downloadExpression,
                    completionHandler: downloadCompletionHandler).continueWith(block: { (task) -> Any? in
                        XCTAssertNil(task.error)
                        refDownloadTask = task.result
                        return nil
                    })
                
                sleep(2)
                refDownloadTask?.suspend()
                XCTAssertEqual(refDownloadTask?.status, AWSS3TransferUtilityTransferStatusType.paused)

                print("Sleeping for 30 seconds to allow server to Timeout on the download")
                sleep(30)
                refDownloadTask?.resume()
                XCTAssertEqual(refDownloadTask?.status, AWSS3TransferUtilityTransferStatusType.inProgress)

                
            } else {
                XCTFail()
            }
        }
        
        var refUploadTask: AWSS3TransferUtilityUploadTask?
        
        transferUtility?.uploadData(
            dataString.data(using: String.Encoding.utf8)!,
            bucket: generalTestBucket,
            key: "testSuspendResumeUploadAndDownloadLargeDataLongDelay.txt",
            contentType: "text/plain",
            expression: uploadExpression,
            completionHandler: uploadCompletionHandler
            ).continueWith (block: { (task) -> AnyObject? in
                XCTAssertNil(task.error)
                refUploadTask = task.result
                return nil
            })
        
        sleep(2)
        refUploadTask?.suspend()
        XCTAssertEqual(refUploadTask?.status, AWSS3TransferUtilityTransferStatusType.paused)

        print("Sleeping for 30 seconds to allow server to Timeout on the upload")
        sleep(30)
        refUploadTask?.resume()
        XCTAssertEqual(refUploadTask?.status, AWSS3TransferUtilityTransferStatusType.inProgress)

        waitForExpectations(timeout: 300) { (error) in
            XCTAssertNil(error)
        }
    }