update tests

Author: typotter

features/dd-sdk-android-flags/src/main/kotlin/com/datadog/android/flags/internal/FlagsStateManager.kt

@@ -74,10 +74,7 @@ internal class FlagsStateManager(
         synchronized(currentState) {
             subscription.addListener(listener)
 
-            // Capture current state before submitting to executor to avoid race condition
             val stateToEmit = currentState
-
-            // Emit current state to new listener
             executorService.executeSafe(
                 operationName = NOTIFY_NEW_LISTENER_OPERATION_NAME,
                 internalLogger = internalLogger

features/dd-sdk-android-flags/src/test/kotlin/com/datadog/android/flags/internal/FlagsStateManagerTest.kt

@@ -170,56 +170,42 @@ internal class FlagsStateManagerTest {
 
         val executionOrder = mutableListOf<String>()
 
-        val listener1 = object : FlagsStateListener {
-            override fun onStateChanged(newState: FlagsClientState) {
-                if (newState is FlagsClientState.Ready) {
-                    synchronized(executionOrder) {
-                        executionOrder.add("listener1")
-                    }
-                }
+        // Creates a listener that adds start/end markers to the execution order and calls the additional block.
+        fun createListener(
+            name: String,
+            additionalBlock: () -> Unit = {
             }
-        }
-
-        val listener2 = object : FlagsStateListener {
+        ): FlagsStateListener = object : FlagsStateListener {
             override fun onStateChanged(newState: FlagsClientState) {
                 if (newState is FlagsClientState.Ready) {
                     synchronized(executionOrder) {
-                        executionOrder.add("listener2")
+                        executionOrder.add(name)
+                        additionalBlock()
+                        executionOrder.add("$name ended")
                     }
-                    // Simulate a long-running listener
-                    Thread.sleep(5)
                 }
             }
         }
 
-        val listener3 = object : FlagsStateListener {
-            override fun onStateChanged(newState: FlagsClientState) {
-                if (newState is FlagsClientState.Ready) {
-                    synchronized(executionOrder) {
-                        executionOrder.add("listener3")
-                    }
-                    throw RuntimeException("Listener 3 intentionally throws")
-                }
-            }
+        val listener1 = createListener("listener1")
+        val listener2 = createListener("listener2") {
+            Thread.sleep(5)
         }
-
-        val listener4 = object : FlagsStateListener {
-            override fun onStateChanged(newState: FlagsClientState) {
-                if (newState is FlagsClientState.Ready) {
-                    synchronized(executionOrder) {
-                        executionOrder.add("listener4")
-                    }
-                }
-            }
+        val listener3 = createListener("listener3") {
+            throw RuntimeException("Listener 3 intentionally throws")
         }
+        val listener4 = createListener("listener4")
 
         managerWithRealExecutor.addListener(listener1)
         managerWithRealExecutor.addListener(listener2)
         managerWithRealExecutor.addListener(listener3)
         managerWithRealExecutor.addListener(listener4)
 
         // When
-        managerWithRealExecutor.updateState(FlagsClientState.Ready)
+        synchronized(executionOrder) {
+            managerWithRealExecutor.updateState(FlagsClientState.Ready)
+            executionOrder.add("updateState")
+        }
 
         // Then - immediately check that state is correct (even while listeners are running)
         assertThat(managerWithRealExecutor.getCurrentState()).isEqualTo(FlagsClientState.Ready)
@@ -231,10 +217,14 @@ internal class FlagsStateManagerTest {
         // Then - all listeners should have been called in order, despite listener3 throwing
         synchronized(executionOrder) {
             assertThat(executionOrder).containsExactly(
+                "updateState",
                 "listener1",
+                "listener1 ended",
                 "listener2",
+                "listener2 ended",
                 "listener3",
-                "listener4"
+                "listener4",
+                "listener4 ended"
             )
         }
     }

features/dd-sdk-android-flags/src/test/kotlin/com/datadog/android/flags/internal/evaluation/EvaluationsManagerTest.kt

@@ -363,15 +363,14 @@ internal class EvaluationsManagerTest {
 
     @Test
     fun `M have state READY when callback invoked W updateEvaluationsForContext() { success }`() {
-        // Given - use a REAL FlagsStateManager to test actual behavior
+        // Given
         val realExecutor = Executors.newSingleThreadExecutor()
         val realStateManager = FlagsStateManager(
             DDCoreSubscription.create(),
             realExecutor,
             mockInternalLogger
         )
 
-        // Create EvaluationsManager with real state manager
         val evaluationsManagerWithRealState = EvaluationsManager(
             executorService = mockExecutorService,
             internalLogger = mockInternalLogger,
@@ -389,7 +388,6 @@ internal class EvaluationsManagerTest {
 
         val callback = object : EvaluationContextCallback {
             override fun onSuccess() {
-                // Capture the ACTUAL state at the moment the callback is invoked
                 stateWhenCallbackInvoked = realStateManager.getCurrentState()
             }
 
@@ -404,7 +402,7 @@ internal class EvaluationsManagerTest {
         // When
         evaluationsManagerWithRealState.updateEvaluationsForContext(publicContext, callback = callback)
 
-        // Then - verify the ACTUAL state was READY when the callback was invoked
+        // Then
         assertThat(stateWhenCallbackInvoked).isEqualTo(FlagsClientState.Ready)
 
         // Cleanup