test: Auth integration test for signUp, signIn, fetchSession (#479)

* Added basic integration test for signIn, signUp and session apis
* Fixed operation that does not cancel when cancel is called
* Changed the integration test target from UITest to UnitTest so that keychain access works correctly.

Author: royjit

AmplifyPlugins/Auth/AWSCognitoAuthPlugin.xcodeproj/project.pbxproj

@@ -10,7 +10,18 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES">
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      codeCoverageEnabled = "YES"
+      onlyGenerateCoverageForSpecifiedTargets = "YES">
+      <CodeCoverageTargets>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "B43DC7442410572400D40275"
+            BuildableName = "AWSCognitoAuthPlugin.framework"
+            BlueprintName = "AWSCognitoAuthPlugin"
+            ReferencedContainer = "container:AWSCognitoAuthPlugin.xcodeproj">
+         </BuildableReference>
+      </CodeCoverageTargets>
       <Testables>
          <TestableReference
             skipped = "NO">

AmplifyPlugins/Auth/AWSCognitoAuthPlugin.xcodeproj/xcshareddata/xcschemes/AWSCognitoAuthPluginIntegrationTests.xcscheme

@@ -46,6 +46,11 @@ public class AWSAuthConfirmSignUpOperation: AmplifyOperation<
             defer {
                 self.finish()
             }
+
+            if self.isCancelled {
+                return
+            }
+
             switch result {
             case .failure(let error):
                 self.dispatch(error)

AmplifyPlugins/Auth/AWSCognitoAuthPlugin/Operations/AWSAuthConfirmSignUpOperation.swift

@@ -46,6 +46,11 @@ public class AWSAuthResendSignUpCodeOperation: AmplifyOperation<
             defer {
                 self.finish()
             }
+
+            if self.isCancelled {
+                return
+            }
+
             switch result {
             case .failure(let error):
                 self.dispatch(error)

AmplifyPlugins/Auth/AWSCognitoAuthPlugin/Operations/AWSAuthResendSignUpCodeOperation.swift

@@ -45,6 +45,11 @@ public class AWSAuthSignInOperation: AmplifyOperation<
             defer {
                 self.finish()
             }
+
+            if self.isCancelled {
+                return
+            }
+
             switch result {
             case .failure(let error):
                 self.dispatch(error)

AmplifyPlugins/Auth/AWSCognitoAuthPlugin/Operations/AWSAuthSignInOperation.swift

@@ -11,7 +11,7 @@ import AWSCognitoAuthPlugin
 
 class AWSAuthBaseTest: XCTestCase {
 
-    let networkTimeout = TimeInterval(180) // 180 seconds to wait before network timeouts
+    let networkTimeout = TimeInterval(10)
 
      func initializeAmplify() {
 

AmplifyPlugins/Auth/AWSCognitoAuthPluginIntegrationTests/AWSAuthBaseTest.swift

@@ -23,10 +23,27 @@ class SignedInAuthSessionTests: AWSAuthBaseTest {
     }
 
     func testSuccessfulSessionFetch() {
+        let username = "integTest\(UUID().uuidString)"
+        let password = "P123@\(UUID().uuidString)"
+        let signInExpectation = expectation(description: "SignIn operation should complete")
+        AuthSignInHelper.registerAndSignInUser(username: username, password: password) { didSucceed, error in
+            signInExpectation.fulfill()
+            XCTAssertTrue(didSucceed, "SignIn operation failed - \(String(describing: error))")
+        }
+        wait(for: [signInExpectation], timeout: networkTimeout)
+
         let authSessionExpectation = expectation(description: "Received event result from fetchAuth")
-        _ = Amplify.Auth.fetchAuthSession { _ in
-            authSessionExpectation.fulfill()
+        _ = Amplify.Auth.fetchAuthSession { result in
+            defer {
+                authSessionExpectation.fulfill()
+            }
+            switch result {
+            case .success(let session):
+                XCTAssertTrue(session.isSignedIn, "Session state should be signed In")
+            case .failure(let error):
+                XCTFail("Should not receive error \(error)")
+            }
         }
-        wait(for: [authSessionExpectation], timeout: 500)
+        wait(for: [authSessionExpectation], timeout: networkTimeout)
     }
 }

AmplifyPlugins/Auth/AWSCognitoAuthPluginIntegrationTests/AuthSessionTests/SignedInAuthSessionTests.swift

@@ -0,0 +1,174 @@
+//
+// Copyright 2018-2020 Amazon.com,
+// Inc. or its affiliates. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import XCTest
+@testable import Amplify
+import AWSCognitoAuthPlugin
+
+class AuthUsernamePasswordSignInTests: AWSAuthBaseTest {
+
+    override func setUp() {
+        super.setUp()
+        initializeAmplify()
+    }
+
+    override func tearDown() {
+        super.tearDown()
+        Amplify.reset()
+        sleep(2)
+    }
+
+    /// Test successful signIn of a valid user
+    ///
+    /// - Given: A user registered in Cognito user pool
+    /// - When:
+    ///    - I invoke Amplify.Auth.signIn with the username password
+    /// - Then:
+    ///    - I should get a completed signIn flow.
+    ///
+    func testSuccessfulSignIn() {
+
+        let username = "integTest\(UUID().uuidString)"
+        let password = "P123@\(UUID().uuidString)"
+
+        let signUpExpectation = expectation(description: "SignUp operation should complete")
+        AuthSignInHelper.signUpUser(username: username, password: password) { didSucceed, error in
+            signUpExpectation.fulfill()
+            XCTAssertTrue(didSucceed, "Signup operation failed - \(String(describing: error))")
+        }
+        wait(for: [signUpExpectation], timeout: networkTimeout)
+
+        let operationExpectation = expectation(description: "Operation should complete")
+        let operation = Amplify.Auth.signIn(username: username, password: password) { result in
+            defer {
+                operationExpectation.fulfill()
+            }
+            switch result {
+            case .success(let signInResult):
+                XCTAssertTrue(signInResult.isSignedIn, "SignIn should be complete")
+            case .failure(let error):
+                XCTFail("SignIn with a valid username/password should not fail \(error)")
+            }
+        }
+        XCTAssertNotNil(operation, "SignIn operation should not be nil")
+        wait(for: [operationExpectation], timeout: networkTimeout)
+    }
+
+    /// Test if user not found error is returned for signIn with unknown user
+    ///
+    /// - Given: Amplify Auth plugin in signedout state
+    /// - When:
+    ///    - I try to signIn with an unknown user
+    /// - Then:
+    ///    - I should get a user not found error
+    ///
+    func testSignInWithInvalidUser() {
+        let operationExpectation = expectation(description: "Operation should complete")
+        let operation = Amplify.Auth.signIn(username: "username-doesnot-exist", password: "password") { result in
+            defer {
+                operationExpectation.fulfill()
+            }
+            switch result {
+            case .success:
+                XCTFail("SignIn with unknown user should not succeed")
+            case .failure(let error):
+                guard let cognitoError = error.underlyingError as? AWSCognitoAuthError,
+                    case .userNotFound = cognitoError else {
+                        XCTFail("Should return userNotFound error")
+                        return
+                }
+            }
+        }
+        XCTAssertNotNil(operation, "SignIn operation should not be nil")
+        wait(for: [operationExpectation], timeout: networkTimeout)
+    }
+
+    /// Test if signIn to an already signedIn session returns error
+    ///
+    /// - Given: Amplify Auth plugin in signedIn state
+    /// - When:
+    ///    - I try to signIn again
+    /// - Then:
+    ///    - I should get a invalid state error
+    ///
+    func testSignInWhenAlreadySignedIn() {
+        let username = "integTest\(UUID().uuidString)"
+        let password = "P123@\(UUID().uuidString)"
+
+        let firstSignInExpectation = expectation(description: "SignIn operation should complete")
+        AuthSignInHelper.registerAndSignInUser(username: username, password: password) { didSucceed, error in
+            firstSignInExpectation.fulfill()
+            XCTAssertTrue(didSucceed, "SignIn operation failed - \(String(describing: error))")
+        }
+        wait(for: [firstSignInExpectation], timeout: networkTimeout)
+
+        let secondSignInExpectation = expectation(description: "SignIn operation should complete")
+        AuthSignInHelper.signInUser(username: username, password: password) { didSucceed, error in
+            defer {
+                secondSignInExpectation.fulfill()
+            }
+            XCTAssertFalse(didSucceed, "Second signIn should fail")
+            guard case .invalidState(_, _, _) = error else {
+                XCTFail("Should return invalid state \(String(describing: error))")
+                return
+            }
+
+        }
+        wait(for: [secondSignInExpectation], timeout: networkTimeout)
+    }
+
+    /// Test if signIn return validation error
+    ///
+    /// - Given: An invalid input to signIn like empty username
+    /// - When:
+    ///    - I invoke signIn with empty username
+    /// - Then:
+    ///    - I should get validation error.
+    ///
+    func testSignInValidation() {
+        let operationExpectation = expectation(description: "Operation should complete")
+        let operation = Amplify.Auth.signIn(username: "", password: "password") { result in
+            defer {
+                operationExpectation.fulfill()
+            }
+            switch result {
+            case .success:
+                XCTFail("SignIn with empty user should not succeed")
+            case .failure(let error):
+                guard case .validation(_, _, _, _) = error else {
+                    XCTFail("Should return validation error")
+                    return
+                }
+            }
+        }
+        XCTAssertNotNil(operation, "SignIn operation should not be nil")
+        wait(for: [operationExpectation], timeout: networkTimeout)
+    }
+
+    /// Calling cancel in signIn operation should cancel
+    ///
+    /// - Given: A valid username and password
+    /// - When:
+    ///    - I invoke signIn with the username password and then call cancel
+    /// - Then:
+    ///    - I should not get any result back
+    ///
+    func testCancelSignInOperation() {
+        let username = "integTest\(UUID().uuidString)"
+        let password = "P123@\(UUID().uuidString)"
+        let operationExpectation = expectation(description: "Operation should not complete")
+        operationExpectation.isInverted = true
+        let operation = Amplify.Auth.signIn(username: username, password: password) { result in
+            XCTFail("Received result \(result)")
+            operationExpectation.fulfill()
+        }
+        XCTAssertNotNil(operation, "signIn operations should not be nil")
+        operation.cancel()
+        wait(for: [operationExpectation], timeout: networkTimeout)
+    }
+
+}

AmplifyPlugins/Auth/AWSCognitoAuthPluginIntegrationTests/AuthSignInTests/AuthUsernamePasswordSignInTests.swift

@@ -0,0 +1,105 @@
+//
+// Copyright 2018-2020 Amazon.com,
+// Inc. or its affiliates. All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import XCTest
+@testable import Amplify
+import AWSCognitoAuthPlugin
+
+class AuthConfirmSignUpTests: AWSAuthBaseTest {
+
+    override func setUp() {
+        super.setUp()
+        initializeAmplify()
+    }
+
+    override func tearDown() {
+        super.tearDown()
+        Amplify.reset()
+        sleep(2)
+    }
+
+    /// Test if confirmSignUp returns userNotFound error for a non existing user
+    ///
+    /// - Given: A user which is not registered to the configured user pool
+    /// - When:
+    ///    - I invoke confirmSignUp with the user
+    /// - Then:
+    ///    - I should get a userNotFound error.
+    ///
+    func testUserNotFoundConfirmSignUp() {
+        let confirmSignUpExpectation = expectation(description: "Received event result from confirmSignUp")
+        _ = Amplify.Auth.confirmSignUp(for: "user-non-exists", confirmationCode: "232") { result in
+            switch result {
+            case .success:
+                XCTFail("Confirm signUp with non existing user should not return result")
+            case .failure(let error):
+                guard let cognitoError = error.underlyingError as? AWSCognitoAuthError,
+                    case .userNotFound = cognitoError else {
+                        XCTFail("Should return userNotFound")
+                        return
+                }
+
+            }
+            confirmSignUpExpectation.fulfill()
+        }
+        wait(for: [confirmSignUpExpectation], timeout: networkTimeout)
+    }
+
+    /// Test confirmSignUp return validation error
+    ///
+    /// - Given: An invalid input to confirmSignUp like empty code
+    /// - When:
+    ///    - I invoke confirmSignUp with empty code
+    /// - Then:
+    ///    - I should get validation error.
+    ///
+    func testConfirmSignUpValidation() {
+        let username = "integTest\(UUID().uuidString)"
+
+        let operationExpectation = expectation(description: "Operation should complete")
+        let operation = Amplify.Auth.confirmSignUp(for: username,
+                                                   confirmationCode: "") { result in
+                                                    defer {
+                                                        operationExpectation.fulfill()
+                                                    }
+                                                    switch result {
+                                                    case .success:
+                                                        XCTFail("confirmSignUp with validation error should not succeed")
+                                                    case .failure(let error):
+                                                        guard case .validation(_, _, _, _) = error else {
+                                                            XCTFail("Should return validation error")
+                                                            return
+                                                        }
+                                                    }
+        }
+        XCTAssertNotNil(operation, "confirmSignUp operations should not be nil")
+        wait(for: [operationExpectation], timeout: networkTimeout)
+    }
+
+    /// Calling cancel in confirmSignUp operation should cancel
+    ///
+    /// - Given: A valid username and code
+    /// - When:
+    ///    - I invoke confirmSignUp with the username and confirmatioCode and then call cancel
+    /// - Then:
+    ///    - I should not get any result back
+    ///
+    func testCancelConfirmSignUpOperation() {
+        let username = "integTest\(UUID().uuidString)"
+
+        let operationExpectation = expectation(description: "Operation should not complete")
+        operationExpectation.isInverted = true
+        let operation = Amplify.Auth.confirmSignUp(for: username,
+                                                   confirmationCode: "123") { result in
+                                                    operationExpectation.fulfill()
+                                                    XCTFail("Received result \(result)")
+        }
+        XCTAssertNotNil(operation, "confirmSignUp operations should not be nil")
+        operation.cancel()
+        wait(for: [operationExpectation], timeout: networkTimeout)
+    }
+}