Merge branch 'main' into mattcreaser/remove-version

Author: mattcreaser

CHANGELOG.md

@@ -3,6 +3,7 @@
 ### Features
 - feat(Geo): Add Kotlin Geo Facade (#2155)
 - Add a network status listener to restart DataStore after the network comes back online. (#2148)
+- feat(auth): Overriding sign in when the State machine is already in the signing in state (#2187)
 
 ### Miscellaneous
 - chore: Remove deprecated maven plugin (#2137)
@@ -17,6 +18,8 @@
 - chore: Upgrade Gradle, AGP, and KtLint (#2172)
 - Add a buildspec file for nightly tests (#2180)
 - Chore(Auth): Implementation of the custom auth with SRP parity testing use case (#2167)
+- chore: Add PR checker workflow (#2188)
+- fix(auth): Fix for when loading credentials the success/error is fired twice (#2184)
 
 ### Bug fixes
 - fix(core): remove unused dynamic nav dependency (#2132)

aws-analytics-pinpoint/src/androidTest/java/com/amplifyframework/analytics/pinpoint/PinpointAnalyticsInstrumentationTest.kt

@@ -90,7 +90,7 @@ class PinpointAnalyticsInstrumentationTest {
 
         // Act: Record the event
         Amplify.Analytics.recordEvent(event)
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         Amplify.Analytics.flushEvents()
         val hubEvents = hubAccumulator.await(10, TimeUnit.SECONDS)
         val submittedEvents = combineAndFilterEvents(hubEvents)
@@ -118,15 +118,15 @@ class PinpointAnalyticsInstrumentationTest {
             .addProperty("DemoDoubleProperty2", 2.0)
             .build()
         Amplify.Analytics.recordEvent(event1)
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         val eventName2 = "Amplify-event" + UUID.randomUUID().toString()
         val event2 = AnalyticsEvent.builder()
             .name(eventName2)
             .addProperty("DemoProperty1", "DemoValue1")
             .addProperty("DemoProperty2", 2.0)
             .build()
         Amplify.Analytics.recordEvent(event2)
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         Amplify.Analytics.flushEvents()
         val hubEvents = analyticsHubEventAccumulator.await(10, TimeUnit.SECONDS)
         val hubEvent = analyticsHubEventAccumulator.awaitFirst()
@@ -189,9 +189,9 @@ class PinpointAnalyticsInstrumentationTest {
 
         // Act: Record two events: the one created above and another just with a key
         Amplify.Analytics.recordEvent(event)
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         Amplify.Analytics.recordEvent("amplify-test-event")
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         Amplify.Analytics.flushEvents()
         val hubEvents = analyticsHubEventAccumulator.await(10, TimeUnit.SECONDS)
         val submittedEvents = combineAndFilterEvents(hubEvents)
@@ -226,10 +226,10 @@ class PinpointAnalyticsInstrumentationTest {
 
         // Act: Record an event, unregister the global property, and record another event
         Amplify.Analytics.recordEvent("amplify-test-event-with-property")
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         Amplify.Analytics.unregisterGlobalProperties("GlobalProperty")
         Amplify.Analytics.recordEvent("amplify-test-event-without-property")
-        Sleep.milliseconds(RECORD_INSERTION_TIMEOUT)
+        Sleep.milliseconds(DEFAULT_TIMEOUT)
         Amplify.Analytics.flushEvents()
         val hubEvents = analyticsHubEventAccumulator.await(10, TimeUnit.SECONDS)
         val submittedEvents = combineAndFilterEvents(hubEvents)
@@ -282,9 +282,16 @@ class PinpointAnalyticsInstrumentationTest {
             .customProperties(properties)
             .userAttributes(userAttributes)
             .build()
-        Amplify.Analytics.identifyUser(UUID.randomUUID().toString(), pinpointUserProfile)
+        val uuid = UUID.randomUUID().toString()
+        Amplify.Analytics.identifyUser(uuid, pinpointUserProfile)
         Sleep.milliseconds(PINPOINT_ROUNDTRIP_TIMEOUT)
-        val endpointResponse = fetchEndpointResponse()
+        var endpointResponse = fetchEndpointResponse()
+        var retry_count = 0
+        while (retry_count < MAX_RETRIES && endpointResponse.attributes.isNullOrEmpty()) {
+            Sleep.milliseconds(DEFAULT_TIMEOUT)
+            endpointResponse = fetchEndpointResponse()
+            retry_count++
+        }
         assertCommonEndpointResponseProperties(endpointResponse)
         Assert.assertEquals(
             "User attribute value",
@@ -310,7 +317,7 @@ class PinpointAnalyticsInstrumentationTest {
     }
 
     private fun assertCommonEndpointResponseProperties(endpointResponse: EndpointResponse) {
-        Log.i("DEBUG", endpointResponse.toString())
+        Log.d("PinpointAnalyticsInstrumentationTest", endpointResponse.toString())
         val attributes = endpointResponse.attributes!!
         Assert.assertEquals("[email protected]", attributes["email"]!![0])
         Assert.assertEquals("test-user", attributes["name"]!![0])
@@ -369,7 +376,8 @@ class PinpointAnalyticsInstrumentationTest {
         private const val CONFIGURATION_NAME = "amplifyconfiguration"
         private const val COGNITO_CONFIGURATION_TIMEOUT = 10 * 1000L
         private const val PINPOINT_ROUNDTRIP_TIMEOUT = 10 * 1000L
-        private const val RECORD_INSERTION_TIMEOUT = 5 * 1000L
+        private const val DEFAULT_TIMEOUT = 5 * 1000L
+        private const val MAX_RETRIES = 10
         private const val UNIQUE_ID_KEY = "UniqueId"
         private const val PREFERENCES_AND_FILE_MANAGER_SUFFIX = "515d6767-01b7-49e5-8273-c8d11b0f331d"
         private lateinit var synchronousAuth: SynchronousAuth

aws-auth-cognito/src/main/java/com/amplifyframework/auth/cognito/RealAWSCognitoAuthPlugin.kt

@@ -464,19 +464,37 @@ internal class RealAWSCognitoAuthPlugin(
         onError: Consumer<AuthException>
     ) {
         authStateMachine.getCurrentState { authState ->
+            val signInOptions = options as? AWSCognitoAuthSignInOptions ?: AWSCognitoAuthSignInOptions.builder()
+                .authFlowType(configuration.authFlowType)
+                .build()
             when (authState.authNState) {
                 is AuthenticationState.NotConfigured -> onError.accept(
                     InvalidUserPoolConfigurationException()
                 )
                 // Continue sign in
-                is AuthenticationState.SignedOut, is AuthenticationState.Configured -> {
-                    val signInOptions = options as? AWSCognitoAuthSignInOptions ?: AWSCognitoAuthSignInOptions.builder()
-                        .authFlowType(configuration.authFlowType)
-                        .build()
-
+                is AuthenticationState.SignedOut,
+                is AuthenticationState.Configured -> {
                     _signIn(username, password, signInOptions, onSuccess, onError)
                 }
                 is AuthenticationState.SignedIn -> onError.accept(SignedInException())
+                is AuthenticationState.SigningIn -> {
+                    val token = StateChangeListenerToken()
+                    authStateMachine.listen(
+                        token,
+                        { authState ->
+                            when (authState.authNState) {
+                                is AuthenticationState.SignedOut -> {
+                                    authStateMachine.cancel(token)
+                                    _signIn(username, password, signInOptions, onSuccess, onError)
+                                }
+                                else -> Unit
+                            }
+                        },
+                        {
+                            authStateMachine.send(AuthenticationEvent(AuthenticationEvent.EventType.CancelSignIn()))
+                        }
+                    )
+                }
                 else -> onError.accept(InvalidStateException())
             }
         }
@@ -706,6 +724,30 @@ internal class RealAWSCognitoAuthPlugin(
                     )
                 }
                 is AuthenticationState.SignedIn -> onError.accept(SignedInException())
+                is AuthenticationState.SigningIn -> {
+                    val token = StateChangeListenerToken()
+                    authStateMachine.listen(
+                        token,
+                        { authState ->
+                            when (authState.authNState) {
+                                is AuthenticationState.SignedOut -> {
+                                    authStateMachine.cancel(token)
+                                    _signInWithHostedUI(
+                                        callingActivity = callingActivity,
+                                        options = options,
+                                        onSuccess = onSuccess,
+                                        onError = onError,
+                                        provider = provider
+                                    )
+                                }
+                                else -> Unit
+                            }
+                        },
+                        {
+                            authStateMachine.send(AuthenticationEvent(AuthenticationEvent.EventType.CancelSignIn()))
+                        }
+                    )
+                }
                 else -> onError.accept(InvalidStateException())
             }
         }

aws-auth-cognito/src/test/java/com/amplifyframework/auth/cognito/RealAWSCognitoAuthPluginTest.kt

@@ -18,7 +18,6 @@ package com.amplifyframework.auth.cognito
 import aws.sdk.kotlin.services.cognitoidentityprovider.CognitoIdentityProviderClient
 import aws.sdk.kotlin.services.cognitoidentityprovider.model.AnalyticsMetadataType
 import aws.sdk.kotlin.services.cognitoidentityprovider.model.AttributeType
-import aws.sdk.kotlin.services.cognitoidentityprovider.model.ChangePasswordRequest
 import aws.sdk.kotlin.services.cognitoidentityprovider.model.ChangePasswordResponse
 import aws.sdk.kotlin.services.cognitoidentityprovider.model.CodeDeliveryDetailsType
 import aws.sdk.kotlin.services.cognitoidentityprovider.model.CognitoIdentityProviderException
@@ -44,7 +43,6 @@ import com.amplifyframework.auth.AuthException
 import com.amplifyframework.auth.AuthUserAttribute
 import com.amplifyframework.auth.AuthUserAttributeKey
 import com.amplifyframework.auth.cognito.exceptions.configuration.InvalidUserPoolConfigurationException
-import com.amplifyframework.auth.cognito.exceptions.invalidstate.SignedInException
 import com.amplifyframework.auth.cognito.helpers.AuthHelper
 import com.amplifyframework.auth.cognito.helpers.SRPHelper
 import com.amplifyframework.auth.cognito.options.AWSCognitoAuthResendUserAttributeConfirmationCodeOptions
@@ -223,6 +221,7 @@ class RealAWSCognitoAuthPluginTest {
         val expectedAuthError = InvalidUserPoolConfigurationException()
         currentState = AuthenticationState.NotConfigured()
 
+        coEvery { authConfiguration.authFlowType } returns AuthFlowType.USER_SRP_AUTH
         // WHEN
         plugin.signIn("user", "password", AuthSignInOptions.defaults(), onSuccess, onError)
 
@@ -236,7 +235,7 @@ class RealAWSCognitoAuthPluginTest {
         // GIVEN
         val onSuccess = mockk<Consumer<AuthSignInResult>>()
         val onError = mockk<Consumer<AuthException>>(relaxed = true)
-        val expectedAuthError = SignedInException()
+        coEvery { authConfiguration.authFlowType } returns AuthFlowType.USER_SRP_AUTH
         currentState = AuthenticationState.SignedIn(
             SignedInData(
                 "userId",
@@ -253,7 +252,7 @@ class RealAWSCognitoAuthPluginTest {
 
         // THEN
         verify(exactly = 0) { onSuccess.accept(any()) }
-        verify { onError.accept(expectedAuthError) }
+        verify { onError.accept(any()) }
     }
 
     @Test
@@ -290,7 +289,7 @@ class RealAWSCognitoAuthPluginTest {
         }
 
         coEvery {
-            authService.cognitoIdentityProviderClient?.changePassword(any<ChangePasswordRequest>())
+            authService.cognitoIdentityProviderClient?.changePassword(any())
         } returns ChangePasswordResponse.invoke { }
 
         // WHEN

aws-auth-cognito/src/test/java/com/amplifyframework/auth/cognito/featuretest/generators/testcasegenerators/SignInTestCaseGenerator.kt

@@ -271,6 +271,30 @@ object SignInTestCaseGenerator : SerializableProvider {
         )
     )
 
+    private val signInWhenAlreadySigningInAuthCase = FeatureTestCase(
+        description = "Test that overriding signIn when already signing in returns success",
+        preConditions = PreConditions(
+            "authconfiguration.json",
+            "SigningIn_SigningIn.json",
+            mockedResponses = listOf(
+                mockedInitiateAuthResponse,
+                mockedSMSChallengeResponse,
+            )
+        ),
+        api = API(
+            AuthAPI.signIn,
+            params = mapOf(
+                "username" to username,
+                "password" to password
+            ).toJsonElement(),
+            options = JsonObject(emptyMap())
+        ),
+        validations = listOf(
+            mockedSignInSMSChallengeExpectation,
+            ExpectationShapes.State("SigningIn_SigningIn.json")
+        )
+    )
+
     private val customAuthCase = FeatureTestCase(
         description = "Test that Custom Auth signIn invokes proper cognito request and returns custom challenge",
         preConditions = PreConditions(
@@ -325,6 +349,11 @@ object SignInTestCaseGenerator : SerializableProvider {
     )
 
     override val serializables: List<Any> = listOf(
-        baseCase, challengeCase, deviceSRPTestCase, customAuthCase, customAuthWithSRPCase
+        baseCase,
+        challengeCase,
+        deviceSRPTestCase,
+        customAuthCase,
+        customAuthWithSRPCase,
+        signInWhenAlreadySigningInAuthCase
     )
 }

aws-auth-cognito/src/test/resources/feature-test/testsuites/signIn/Test_that_overriding_signIn_when_already_signing_in_returns_success.json

@@ -0,0 +1,69 @@
+{
+    "description": "Test that overriding signIn when already signing in returns success",
+    "preConditions": {
+        "amplify-configuration": "authconfiguration.json",
+        "state": "SigningIn_SigningIn.json",
+        "mockedResponses": [
+            {
+                "type": "cognitoIdentityProvider",
+                "apiName": "initiateAuth",
+                "responseType": "success",
+                "response": {
+                    "challengeName": "PASSWORD_VERIFIER",
+                    "challengeParameters": {
+                        "SALT": "abc",
+                        "SECRET_BLOCK": "secretBlock",
+                        "SRP_B": "def",
+                        "USERNAME": "username",
+                        "USER_ID_FOR_SRP": "userId"
+                    }
+                }
+            },
+            {
+                "type": "cognitoIdentityProvider",
+                "apiName": "respondToAuthChallenge",
+                "responseType": "success",
+                "response": {
+                    "session": "someSession",
+                    "challengeName": "SMS_MFA",
+                    "challengeParameters": {
+                        "CODE_DELIVERY_DELIVERY_MEDIUM": "SMS",
+                        "CODE_DELIVERY_DESTINATION": "+12345678900"
+                    }
+                }
+            }
+        ]
+    },
+    "api": {
+        "name": "signIn",
+        "params": {
+            "username": "username",
+            "password": "password"
+        },
+        "options": {
+        }
+    },
+    "validations": [
+        {
+            "type": "amplify",
+            "apiName": "signIn",
+            "responseType": "success",
+            "response": {
+                "isSignedIn": false,
+                "nextStep": {
+                    "signInStep": "CONFIRM_SIGN_IN_WITH_SMS_MFA_CODE",
+                    "additionalInfo": {
+                    },
+                    "codeDeliveryDetails": {
+                        "destination": "+12345678900",
+                        "deliveryMedium": "SMS"
+                    }
+                }
+            }
+        },
+        {
+            "type": "state",
+            "expectedState": "SigningIn_SigningIn.json"
+        }
+    ]
+}

testutils/src/main/java/com/amplifyframework/testutils/FileAssert.java

@@ -73,8 +73,8 @@ private static void assertStreamEqualStream(
         final byte[] expectedDigest;
         final byte[] actualDigest;
         try {
-            expectedDigest = calculateMD5Digest(expectedInputStream);
-            actualDigest = calculateMD5Digest(actualInputStream);
+            expectedDigest = calculateDigest(expectedInputStream);
+            actualDigest = calculateDigest(actualInputStream);
             Assert.assertArrayEquals(expectedDigest, actualDigest);
         } finally {
             expectedInputStream.close();
@@ -83,24 +83,24 @@ private static void assertStreamEqualStream(
     }
 
     @SuppressWarnings("MagicNumber") // Buffer size
-    private static byte[] calculateMD5Digest(InputStream stream) {
+    private static byte[] calculateDigest(InputStream stream) {
         final byte[] buffer = new byte[2_048];
-        final MessageDigest md5;
+        final MessageDigest digest;
         try {
-            md5 = MessageDigest.getInstance("MD5");
+            digest = MessageDigest.getInstance("SHA-256");
         } catch (NoSuchAlgorithmException noMd5AvailableError) {
             throw new RuntimeException("No MD5 algorithm available to use for hashing.", noMd5AvailableError);
         }
 
         int bytesRead;
         try {
             while ((bytesRead = stream.read(buffer)) != -1) {
-                md5.update(buffer, 0, bytesRead);
+                digest.update(buffer, 0, bytesRead);
             }
         } catch (IOException readError) {
             throw new RuntimeException("Failed to read input stream.", readError);
         }
 
-        return md5.digest();
+        return digest.digest();
     }
 }