Add tests

Author: jan-tennert

Auth/src/commonMain/kotlin/io/github/jan/supabase/auth/AuthImpl.kt

@@ -436,7 +436,8 @@ internal class AuthImpl(
             Auth.logger.d { "Session is under the threshold date. Refreshing session..." }
             tryImportingSession(
                 { handleExpiredSession(session, config.alwaysAutoRefresh) },
-                { importSession(session) }
+                { importSession(session) },
+                { updateStatusIfExpired(session, it) }
             )
         } else {
             if (config.autoSaveToStorage) {
@@ -451,7 +452,8 @@ internal class AuthImpl(
                 launch {
                     tryImportingSession(
                         { handleExpiredSession(session) },
-                        { importSession(session, source = source) }
+                        { importSession(session, source = source) },
+                        { updateStatusIfExpired(session, it) }
                     )
                 }
             }
@@ -462,14 +464,15 @@ internal class AuthImpl(
     @Suppress("MagicNumber")
     private suspend fun tryImportingSession(
         importRefreshedSession: suspend () -> Unit,
-        retry: suspend () -> Unit
+        retry: suspend () -> Unit,
+        updateStatus: suspend (RefreshFailureCause) -> Unit
     ) {
         try {
             importRefreshedSession()
         } catch (e: RestException) {
             if (e.statusCode in 500..599) {
                 Auth.logger.e(e) { "Couldn't refresh session due to an internal server error. Retrying in ${config.retryDelay} (Status code ${e.statusCode})..." }
-                updateStatusIfExpired(RefreshFailureCause.InternalServerError(e))
+                updateStatus(RefreshFailureCause.InternalServerError(e))
                 delay(config.retryDelay)
                 retry()
             } else {
@@ -479,15 +482,14 @@ internal class AuthImpl(
         } catch (e: Exception) {
             coroutineContext.ensureActive()
             Auth.logger.e(e) { "Couldn't reach Supabase. Either the address doesn't exist or the network might not be on. Retrying in ${config.retryDelay}..." }
-            updateStatusIfExpired(RefreshFailureCause.NetworkError(e))
+            updateStatus(RefreshFailureCause.NetworkError(e))
             delay(config.retryDelay)
             retry()
         }
     }
 
-    private fun updateStatusIfExpired(reason: RefreshFailureCause) {
-        val currentSession = currentSessionOrNull() ?: error("No session found")
-        if (currentSession.expiresAt <= Clock.System.now()) {
+    private fun updateStatusIfExpired(session: UserSession, reason: RefreshFailureCause) {
+        if (session.expiresAt <= Clock.System.now()) {
             Auth.logger.d { "Session expired while trying to refresh the session. Updating status..." }
             setSessionStatus(SessionStatus.RefreshFailure(reason))
         }

Auth/src/commonMain/kotlin/io/github/jan/supabase/auth/status/RefreshFailureCause.kt

@@ -5,6 +5,7 @@ import io.github.jan.supabase.exceptions.RestException
 /**
  * Represents the cause of a refresh error
  */
+//Note: Move this interface when removing the deprecated property from [SessionStatus.RefreshFailure]
 sealed interface RefreshFailureCause {
 
     /**

Auth/src/commonMain/kotlin/io/github/jan/supabase/auth/status/SessionStatus.kt

@@ -23,6 +23,7 @@ sealed interface SessionStatus {
 
     /**
      * This status means the session expired and [Auth] is trying to refresh it
+     * @param cause The cause of the error. This property will be removed in a future version. Use the new AuthEvent.RefreshFailure(cause) event to diagnose failures.
      */
     data class RefreshFailure(
         @Deprecated("This property will be removed in a future version. Use the new AuthEvent.RefreshFailure(cause) event to diagnose failures.")

Auth/src/commonTest/kotlin/AuthTest.kt

@@ -1,24 +1,33 @@
+import app.cash.turbine.test
 import io.github.jan.supabase.SupabaseClientBuilder
 import io.github.jan.supabase.auth.Auth
 import io.github.jan.supabase.auth.MemorySessionManager
 import io.github.jan.supabase.auth.auth
+import io.github.jan.supabase.auth.event.AuthEvent
 import io.github.jan.supabase.auth.minimalSettings
 import io.github.jan.supabase.auth.providers.Github
+import io.github.jan.supabase.auth.status.RefreshFailureCause
+import io.github.jan.supabase.auth.status.SessionSource
 import io.github.jan.supabase.auth.status.SessionStatus
 import io.github.jan.supabase.auth.user.Identity
 import io.github.jan.supabase.auth.user.UserInfo
 import io.github.jan.supabase.auth.user.UserSession
+import io.github.jan.supabase.logging.LogLevel
 import io.github.jan.supabase.testing.createMockedSupabaseClient
 import io.github.jan.supabase.testing.pathAfterVersion
 import io.github.jan.supabase.testing.respondJson
+import io.ktor.client.engine.mock.respondError
+import io.ktor.http.HttpStatusCode
 import io.ktor.http.Url
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.json.buildJsonObject
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertIs
 import kotlin.test.assertNull
+import kotlin.time.Duration.Companion.seconds
 
 class AuthTest {
 
@@ -105,6 +114,7 @@ class AuthTest {
             val session = userSession(expiresIn = 0)
             client.auth.importSession(session)
             assertIs<SessionStatus.Authenticated>(client.auth.sessionStatus.value)
+            assertIs<SessionSource.Refresh>((client.auth.sessionStatus.value as SessionStatus.Authenticated).source)
             assertEquals(newSession.expiresIn, client.auth.currentSessionOrNull()?.expiresIn)
         }
     }
@@ -131,10 +141,96 @@ class AuthTest {
             assertIs<SessionStatus.Authenticated>(client.auth.sessionStatus.value)
             assertEquals(session.expiresIn, client.auth.currentSessionOrNull()?.expiresIn) //The session shouldn't be refreshed automatically as alwaysAutoRefresh is false
             client.auth.startAutoRefreshForCurrentSession()
+            assertIs<SessionSource.Refresh>((client.auth.sessionStatus.value as SessionStatus.Authenticated).source)
             assertEquals(newSession.expiresIn, client.auth.currentSessionOrNull()?.expiresIn)
         }
     }
 
+    @Test
+    fun testAutoRefreshFailureNetworkValidSession() {
+        runTest {
+            val newSession = userSession()
+            val client = createMockedSupabaseClient(configuration = {
+                install(Auth) {
+                    minimalSettings(
+                        alwaysAutoRefresh = true
+                    )
+                }
+                defaultLogLevel = LogLevel.DEBUG
+            }) {
+                throw IllegalStateException("Some random error") //everything except RestException are handled as network errors
+            }
+            client.auth.awaitInitialization()
+            assertIs<SessionStatus.NotAuthenticated>(client.auth.sessionStatus.value)
+            val session = userSession(expiresIn = 1)
+            client.auth.importSession(session)
+            assertIs<SessionStatus.Authenticated>(client.auth.sessionStatus.value) // since the session is still valid, the status should be authenticated
+            client.auth.events.test(timeout = 2.seconds) { //event should be emitted regardless of the session status
+                val event = awaitItem()
+                assertIs<AuthEvent.RefreshFailure>(event)
+                assertIs<RefreshFailureCause.NetworkError>(event.cause)
+            }
+        }
+    }
+
+    @Test
+    fun testAutoRefreshFailureServerErrorValidSession() {
+        runTest {
+            val newSession = userSession()
+            val client = createMockedSupabaseClient(configuration = {
+                install(Auth) {
+                    minimalSettings(
+                        alwaysAutoRefresh = true
+                    )
+                }
+                defaultLogLevel = LogLevel.DEBUG
+            }) {
+                respondError(HttpStatusCode.InternalServerError, "{}")
+            }
+            assertIs<SessionStatus.NotAuthenticated>(client.auth.sessionStatus.value)
+            val session = userSession(expiresIn = 1)
+            client.auth.importSession(session)
+            assertIs<SessionStatus.Authenticated>(client.auth.sessionStatus.value) // since the session is still valid, the status should be authenticated
+            client.auth.events.test(timeout = 2.seconds) { //event should be emitted regardless of the session status
+                val event = awaitItem()
+                assertIs<AuthEvent.RefreshFailure>(event)
+                assertIs<RefreshFailureCause.InternalServerError>(event.cause)
+            }
+        }
+    }
+
+    @Test
+    fun testAutoRefreshFailureInvalidSession() {
+        runTest {
+            var first = true
+            val newSession = userSession()
+            val client = createMockedSupabaseClient(configuration = {
+                install(Auth) {
+                    minimalSettings(
+                        alwaysAutoRefresh = false
+                    )
+                }
+                defaultLogLevel = LogLevel.DEBUG
+            }) {
+                if(first) {
+                    first = false
+                    respondError(HttpStatusCode.InternalServerError, "{}")
+                } else respondJson(newSession)
+            }
+            client.auth.awaitInitialization()
+            assertIs<SessionStatus.NotAuthenticated>(client.auth.sessionStatus.value)
+            val session = userSession(expiresIn = 0)
+            launch {
+                client.auth.events.test(timeout = 1.seconds) { //event should be emitted regardless of the session status
+                    val event = awaitItem()
+                    assertIs<SessionStatus.RefreshFailure>(client.auth.sessionStatus.value) // session expired and should be in refresh failure state
+                    assertIs<AuthEvent.RefreshFailure>(event)
+                }
+            }
+            client.auth.importSession(session, autoRefresh = true)
+        }
+    }
+
     @Test
     fun testGetOAuthUrl() {
         runTest {