fix: small fixups on status + added own test class

Signed-off-by: Nicklas Lundin <nicklasl@spotify.com>

Author: nicklasl

android/src/main/java/dev/openfeature/sdk/OpenFeatureAPI.kt

@@ -6,8 +6,9 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.async
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
 import java.util.concurrent.CancellationException
 
 @Suppress("TooManyFunctions")
@@ -27,7 +28,7 @@ object OpenFeatureAPI {
     /**
      * A flow of [OpenFeatureStatus] that emits the current status of the SDK.
      */
-    val statusFlow: SharedFlow<OpenFeatureStatus> get() = _statusFlow
+    val statusFlow: Flow<OpenFeatureStatus> get() = _statusFlow.distinctUntilChanged()
 
     var hooks: List<Hook<*>> = listOf()
         private set
@@ -73,22 +74,21 @@ object OpenFeatureAPI {
         initialContext: EvaluationContext? = null
     ) {
         this@OpenFeatureAPI.provider = provider
-        // TODO consider if stale status should emit? _statusFlow.tryEmit(OpenFeatureStatus.Stale)
+        _statusFlow.emit(OpenFeatureStatus.NotReady)
         if (initialContext != null) context = initialContext
         try {
             getProvider().initialize(context)
-            _statusFlow.tryEmit(OpenFeatureStatus.Ready)
+            _statusFlow.emit(OpenFeatureStatus.Ready)
         } catch (e: OpenFeatureError) {
-            _statusFlow.tryEmit(OpenFeatureStatus.Error(e))
+            _statusFlow.emit(OpenFeatureStatus.Error(e))
         } catch (e: Throwable) {
-            _statusFlow.tryEmit(
+            _statusFlow.emit(
                 OpenFeatureStatus.Error(
                     OpenFeatureError.GeneralError(
                         e.message ?: e.javaClass.name
                     )
                 )
             )
-            // TODO deal with things by setting status to Error or Fatal
         }
     }
 
@@ -104,6 +104,7 @@ object OpenFeatureAPI {
      */
     fun clearProvider() {
         provider = NOOP_PROVIDER
+        _statusFlow.tryEmit(OpenFeatureStatus.NotReady)
     }
 
     /**
@@ -148,15 +149,14 @@ object OpenFeatureAPI {
         val oldContext = context
         context = evaluationContext
         if (oldContext != evaluationContext) {
-            _statusFlow.tryEmit(OpenFeatureStatus.Reconciling)
+            _statusFlow.emit(OpenFeatureStatus.Reconciling)
             try {
                 getProvider().onContextSet(oldContext, evaluationContext)
-                _statusFlow.tryEmit(OpenFeatureStatus.Ready)
+                _statusFlow.emit(OpenFeatureStatus.Ready)
             } catch (e: OpenFeatureError) {
-                _statusFlow.tryEmit(OpenFeatureStatus.Error(e))
-                // TODO how do we handle fatal errors?
+                _statusFlow.emit(OpenFeatureStatus.Error(e))
             } catch (e: Throwable) {
-                _statusFlow.tryEmit(
+                _statusFlow.emit(
                     OpenFeatureStatus.Error(
                         OpenFeatureError.GeneralError(
                             e.message ?: e.javaClass.name
@@ -211,6 +211,7 @@ object OpenFeatureAPI {
     fun shutdown() {
         setEvaluationContextJob?.cancel(CancellationException("Set context job was cancelled"))
         setProviderJob?.cancel(CancellationException("Provider set job was cancelled"))
+        provider = NOOP_PROVIDER
         _statusFlow.tryEmit(OpenFeatureStatus.NotReady)
         getProvider().shutdown()
         clearHooks()
@@ -219,5 +220,5 @@ object OpenFeatureAPI {
     /**
      * Get the current [OpenFeatureStatus] of the SDK.
      */
-    fun getStatus(): OpenFeatureStatus = statusFlow.replayCache.first()
+    fun getStatus(): OpenFeatureStatus = _statusFlow.replayCache.first()
 }

android/src/test/java/dev/openfeature/sdk/StatusTests.kt

@@ -0,0 +1,87 @@
+package dev.openfeature.sdk
+
+import dev.openfeature.sdk.helpers.BrokenInitProvider
+import dev.openfeature.sdk.helpers.DoSomethingProvider
+import junit.framework.Assert.assertEquals
+import junit.framework.Assert.assertTrue
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Test
+
+class StatusTests {
+
+    @After
+    fun tearDown() {
+        // It becomes important to clear the provider after each test since the SDK is a singleton
+        OpenFeatureAPI.shutdown()
+    }
+
+    @Test
+    fun testNoProviderSet() {
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+    }
+
+    @Test
+    fun testProviderTransitionsToReadyAndNotReadyAfterShutdown() = runTest {
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+        OpenFeatureAPI.setProviderAndWait(NoOpProvider())
+        assertEquals(OpenFeatureStatus.Ready, OpenFeatureAPI.getStatus())
+        OpenFeatureAPI.shutdown()
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+    }
+
+    @Test
+    fun testProviderThrowsDuringInit() = runTest {
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+        OpenFeatureAPI.setProviderAndWait(BrokenInitProvider())
+        assertTrue(OpenFeatureAPI.getStatus() is OpenFeatureStatus.Error)
+        OpenFeatureAPI.shutdown()
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+    }
+
+    @Test
+    fun testClearProviderEmitsNotReady() = runTest {
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+        OpenFeatureAPI.setProviderAndWait(NoOpProvider())
+        assertEquals(OpenFeatureStatus.Ready, OpenFeatureAPI.getStatus())
+        OpenFeatureAPI.clearProvider()
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+    }
+
+    @Test
+    fun testProviderTransitionsToReconcilingOnContextSet() = runTest {
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+        val statuses = mutableListOf<OpenFeatureStatus>()
+        val job = launch {
+            OpenFeatureAPI.statusFlow.collect {
+                statuses.add(it)
+            }
+        }
+        OpenFeatureAPI.setProviderAndWait(DoSomethingProvider())
+        OpenFeatureAPI.setEvaluationContextAndWait(ImmutableContext("some value"))
+        testScheduler.advanceUntilIdle()
+        assertEquals(4, statuses.size)
+        OpenFeatureAPI.setEvaluationContextAndWait(ImmutableContext("some other value"))
+        testScheduler.advanceUntilIdle()
+        assertEquals(6, statuses.size)
+        OpenFeatureAPI.shutdown()
+        testScheduler.advanceUntilIdle()
+        assertEquals(OpenFeatureStatus.NotReady, OpenFeatureAPI.getStatus())
+        job.cancelAndJoin()
+        assertEquals(7, statuses.size)
+        assertEquals(
+            listOf(
+                OpenFeatureStatus.NotReady,
+                OpenFeatureStatus.Ready,
+                OpenFeatureStatus.Reconciling,
+                OpenFeatureStatus.Ready,
+                OpenFeatureStatus.Reconciling,
+                OpenFeatureStatus.Ready,
+                OpenFeatureStatus.NotReady
+            ),
+            statuses
+        )
+    }
+}