chore(IntegrationTests): Fixing Analytics and Auth integration tests.

Author: sebaland

AmplifyPlugins/Analytics/AWSPinpointAnalyticsPluginIntegrationTests/AWSPinpointAnalyticsPluginIntegrationTests.swift

@@ -70,6 +70,40 @@ class AWSPinpointAnalyticsPluginIntergrationTests: XCTestCase {
         Amplify.Analytics.identifyUser(userId, withProfile: userProfile)
 
         wait(for: [identifyUserEvent], timeout: TestCommonConstants.networkTimeout)
+
+        // Remove userId from the current endpoint
+        let targetingClient = escapeHatch().targetingClient
+        let currentProfile = targetingClient.currentEndpointProfile()
+        currentProfile.user?.userId = ""
+        targetingClient.update(currentProfile)
+    }
+
+    /// Run this test when the number of endpoints for the userId exceeds the limit.
+    /// The profile should have permissions to run the "mobiletargeting:DeleteUserEndpoints" action.
+    func skip_testDeleteEndpointsForUser() throws {
+        let userId = "userId"
+        let escapeHatch = escapeHatch()
+        let applicationId = escapeHatch.configuration.appId
+        guard let targetingConfiguration = escapeHatch.configuration.targetingServiceConfiguration else {
+            XCTFail("Targeting configuration is not defined.")
+            return
+        }
+
+        let deleteEndpointsRequest = AWSPinpointTargetingDeleteUserEndpointsRequest()!
+        deleteEndpointsRequest.userId = userId
+        deleteEndpointsRequest.applicationId = applicationId
+
+        let deleteExpectation = expectation(description: "Delete endpoints")
+        let lowLevelClient = lowLevelClient(from: targetingConfiguration)
+        lowLevelClient.deleteUserEndpoints(deleteEndpointsRequest) { response, error in
+            guard error == nil else {
+                XCTFail("Unexpected error when attempting to delete endpoints")
+                deleteExpectation.fulfill()
+                return
+            }
+            deleteExpectation.fulfill()
+        }
+        wait(for: [deleteExpectation], timeout: 1)
     }
 
     func testRecordEventsAreFlushed() {
@@ -79,6 +113,7 @@ class AWSPinpointAnalyticsPluginIntergrationTests: XCTestCase {
                 // TODO: Remove exposing AWSPinpointEvent
                 guard let pinpointEvents = payload.data as? [AWSPinpointEvent] else {
                     XCTFail("Missing data")
+                    flushEventsInvoked.fulfill()
                     return
                 }
                 XCTAssertNotNil(pinpointEvents)
@@ -117,4 +152,17 @@ class AWSPinpointAnalyticsPluginIntergrationTests: XCTestCase {
         XCTAssertNotNil(awsPinpoint.configuration)
         XCTAssertTrue(awsPinpoint.configuration.enableAutoSessionRecording)
     }
+
+    private func escapeHatch() -> AWSPinpoint {
+        guard let plugin = try? Amplify.Analytics.getPlugin(for: "awsPinpointAnalyticsPlugin"),
+              let analyticsPlugin = plugin as? AWSPinpointAnalyticsPlugin else {
+            fatalError("Unable to retrieve configuration")
+        }
+        return analyticsPlugin.getEscapeHatch()
+    }
+
+    private func lowLevelClient(from configuration: AWSServiceConfiguration) -> AWSPinpointTargeting {
+        AWSPinpointTargeting.register(with: configuration, forKey: "integrationTestsTargetingConfiguration")
+        return AWSPinpointTargeting.init(forKey: "integrationTestsTargetingConfiguration")
+    }
 }

AmplifyPlugins/Auth/AWSCognitoAuthPluginIntegrationTests/AuthDeviceTests/AuthDeviceOperationTests.swift

@@ -7,7 +7,13 @@
 
 import XCTest
 @testable import Amplify
+import AmplifyTestCommon
 import AWSCognitoAuthPlugin
+#if COCOAPODS
+import AWSMobileClient
+#else
+import AWSMobileClientXCF
+#endif
 
 class AuthDeviceOperationTests: AWSAuthBaseTest {
 
@@ -22,20 +28,60 @@ class AuthDeviceOperationTests: AWSAuthBaseTest {
         sleep(2)
     }
 
+    /// Test if forgetDevice returns deviceNotTracked error for a signed out user
+    ///
+    /// - Given: A test with the user not signed in
+    /// - When:
+    ///    - I invoke forgetDevice
+    /// - Then:
+    ///    - I should get a notSignedIn error.
+    ///
+    func testForgetDeviceWithSignedOutUser() {
+        let forgetDeviceExpectation = expectation(description: "Received event result from forgetDevice")
+        _ = Amplify.Auth.forgetDevice { result in
+            forgetDeviceExpectation.fulfill()
+            switch result {
+            case .success:
+                XCTFail("Forget device with signed out user should not return success")
+            case .failure(let error):
+                guard let cognitoError = error.underlyingError as? AWSMobileClientError,
+                      case .notSignedIn = cognitoError else {
+                    XCTFail("Should return notSignedIn")
+                    return
+                }
+            }
+        }
+        wait(for: [forgetDeviceExpectation], timeout: networkTimeout)
+    }
+
     /// Test if forgetDevice returns deviceNotTracked error for a unknown device
     ///
-    /// - Given: A test with the device not tracked
+    /// - Given: A test with a device not tracked
     /// - When:
     ///    - I invoke forgetDevice
     /// - Then:
     ///    - I should get a deviceNotTracked error.
     ///
-    func testForgetDeviceWithUnknowdevice() {
+    func testForgetDeviceWithUntrackedDevice() {
+        let username = "integTest\(UUID().uuidString)"
+        let password = "P123@\(UUID().uuidString)"
+        let signInExpectation = expectation(description: "SignIn operation should complete")
+        AuthSignInHelper.registerAndSignInUser(username: username, password: password,
+                                               email: email) { didSucceed, error in
+            signInExpectation.fulfill()
+            XCTAssertTrue(didSucceed, "SignIn operation failed - \(String(describing: error))")
+        }
+        wait(for: [signInExpectation], timeout: networkTimeout)
+
+        let user = Amplify.Auth.getCurrentUser()
+        XCTAssertNotNil(user)
+
         let forgetDeviceExpectation = expectation(description: "Received event result from forgetDevice")
         _ = Amplify.Auth.forgetDevice { result in
+            forgetDeviceExpectation.fulfill()
             switch result {
             case .success:
-                XCTFail("Confirm signUp with non existing user should not return result")
+                XCTFail("Forget device with untracked device should not return result")
             case .failure(let error):
                 guard let cognitoError = error.underlyingError as? AWSCognitoAuthError,
                       case .deviceNotTracked = cognitoError else {
@@ -44,7 +90,6 @@ class AuthDeviceOperationTests: AWSAuthBaseTest {
                 }
 
             }
-            forgetDeviceExpectation.fulfill()
         }
         wait(for: [forgetDeviceExpectation], timeout: networkTimeout)
     }