test: Add ErrorTypeHandlerVs tests and amend docs

Author: BiancaMihaila

app/src/main/java/uk/gov/android/securestore/SecureStoreAsyncV2.kt

@@ -26,7 +26,7 @@ interface SecureStoreAsyncV2 {
      * @param [key] The unique key to save the data against
      * @param [value] The data to save as a [String]
      *
-     * @throws [uk.gov.android.securestore.error.SecureStorageError] if unable to save
+     * @throws [uk.gov.android.securestore.error.SecureStorageErrorV2] if unable to save
      */
     suspend fun upsert(key: String, value: String): String
 
@@ -41,15 +41,15 @@ interface SecureStoreAsyncV2 {
     /**
      * Delete everything in the SecureStore
      *
-     * @throws [uk.gov.android.securestore.error.SecureStorageError] if unable to delete
+     * @throws [uk.gov.android.securestore.error.SecureStorageErrorV2] if unable to delete
      */
     suspend fun deleteAll()
 
     /**
      * Access the data for a given key when authentication is not required; access control level is set to OPEN
      *
      * @param [key] The unique key to identify data to retrieve
-     * @return [RetrievalEvent] to cover success or failure
+     * @return [RetrievalEventV2] to cover success or failure
      *
      */
     suspend fun retrieve(
@@ -62,7 +62,7 @@ interface SecureStoreAsyncV2 {
      * @param [key] The unique key to identify data to retrieve
      * @param [authPromptConfig] Configuration for the Biometric prompt
      * @param [context] The [FragmentActivity] where the method is called, used for auth prompt
-     * @return A [Flow] of [RetrievalEvent]s, allowing for multiple failed attempts for auth
+     * @return A [Flow] of [RetrievalEventV2], allowing for multiple failed attempts for auth
      *
      */
     suspend fun retrieveWithAuthentication(
@@ -77,7 +77,7 @@ interface SecureStoreAsyncV2 {
      * @param [key] Key to select
      * @return True or false if the key exists in the store
      *
-     * @throws [uk.gov.android.securestore.error.SecureStorageError] if unable to check for existence
+     * @throws [uk.gov.android.securestore.error.SecureStorageErrorV2] if unable to check for existence
      */
     fun exists(key: String): Boolean
 }

app/src/main/java/uk/gov/android/securestore/error/ErrorTypeHandlerV2.kt

@@ -33,6 +33,7 @@ object ErrorTypeHandlerV2 {
             is IndexOutOfBoundsException,
             is GeneralSecurityException,
             -> SecureStoreErrorTypeV2.UNRECOVERABLE
+            // This will always be RECOVERABLE because the SecureStorageErrorV2 type default to RECOVERABLE
             else -> error.type
         }
     }

app/src/test/java/uk/gov/android/securestore/error/ErrorTypeHandlerV2Test.kt

@@ -4,32 +4,91 @@ import android.security.keystore.UserNotAuthenticatedException
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.Arguments
 import org.junit.jupiter.params.provider.MethodSource
-import kotlin.UnsupportedOperationException
+import java.lang.IllegalStateException
+import java.lang.IndexOutOfBoundsException
+import java.security.GeneralSecurityException
+import java.security.InvalidAlgorithmParameterException
+import java.security.InvalidKeyException
+import java.security.KeyStoreException
+import java.security.NoSuchAlgorithmException
+import java.security.UnrecoverableKeyException
+import javax.crypto.AEADBadTagException
+import javax.crypto.BadPaddingException
+import javax.crypto.NoSuchPaddingException
 import kotlin.test.assertEquals
 
 class ErrorTypeHandlerV2Test {
     @ParameterizedTest
     @MethodSource("getData")
-    fun testHandler(error: SecureStorageError, expectedType: SecureStoreErrorType) {
-        val actualType = ErrorTypeHandler.getErrorType(error)
+    fun testHandler(error: SecureStorageErrorV2, expectedType: SecureStoreErrorTypeV2) {
+        val actualType = ErrorTypeHandlerV2.getErrorType(error)
         assertEquals(expectedType, actualType)
     }
 
     companion object {
+        @Suppress("LongMethod")
         @JvmStatic
         fun getData(): List<Arguments> {
             return listOf(
                 Arguments.of(
-                    SecureStorageError(UserNotAuthenticatedException()),
-                    SecureStoreErrorType.USER_CANCELED_BIO_PROMPT,
+                    SecureStorageErrorV2(AEADBadTagException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
                 ),
                 Arguments.of(
-                    SecureStorageError(UnsupportedOperationException()),
-                    SecureStoreErrorType.USER_CANCELED_BIO_PROMPT,
+                    SecureStorageErrorV2(UnrecoverableKeyException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
                 ),
                 Arguments.of(
-                    SecureStorageError(Exception()),
-                    SecureStoreErrorType.GENERAL,
+                    SecureStorageErrorV2(BadPaddingException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(UserNotAuthenticatedException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(NoSuchAlgorithmException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(NoSuchPaddingException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(java.lang.UnsupportedOperationException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(InvalidKeyException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(UnrecoverableKeyException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(KeyStoreException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(IllegalStateException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(InvalidAlgorithmParameterException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(IndexOutOfBoundsException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(GeneralSecurityException()),
+                    SecureStoreErrorTypeV2.UNRECOVERABLE,
+                ),
+                Arguments.of(
+                    SecureStorageErrorV2(Exception()),
+                    SecureStoreErrorTypeV2.RECOVERABLE,
                 ),
             )
         }