test: Polish concurrency tests

Signed-off-by: Fabrizio Demaria <fabrizio.f.demaria@gmail.com>

Author: fabriziodemaria

Tests/OpenFeatureTests/ConcurrencyRaceConditionTests.swift

@@ -1,4 +1,3 @@
-
 import XCTest
 import Combine
 @testable import OpenFeature
@@ -23,7 +22,7 @@ class ConcurrencyRaceConditionTests: XCTestCase {
 
         let concurrentOperations = 100
         let expectedTargetingKeys = Set((0..<concurrentOperations).map { "user\($0)" })
-        
+
         await withTaskGroup(of: Void.self) { group in
             for i in 0..<concurrentOperations {
                 group.addTask {
@@ -34,26 +33,24 @@ class ConcurrencyRaceConditionTests: XCTestCase {
                             "timestamp": .string("\(Date().timeIntervalSince1970)")
                         ])
                     )
-                    
-                    // This should trigger the race condition in updateContext
+
                     await OpenFeatureAPI.shared.setEvaluationContextAndWait(evaluationContext: ctx)
                 }
             }
         }
-        
+
         cancellable.cancel()
-        
-        // Verify final state is consistent and correct
+
         let finalContext = OpenFeatureAPI.shared.getEvaluationContext()
         XCTAssertNotNil(finalContext, "Final evaluation context should not be nil after concurrent operations")
-        
+
         if let context = finalContext {
             let targetingKey = context.getTargetingKey()
             XCTAssertTrue(
                 expectedTargetingKeys.contains(targetingKey),
                 "Final targeting key '\(targetingKey)' should be one of the expected keys from concurrent operations"
             )
-            
+
             let contextMap = context.asObjectMap()
             XCTAssertTrue(contextMap.keys.contains("id"), "Context should contain 'id' attribute")
             XCTAssertTrue(contextMap.keys.contains("timestamp"), "Context should contain 'timestamp' attribute")
@@ -67,15 +64,11 @@ class ConcurrencyRaceConditionTests: XCTestCase {
         }
     }
 
-    /// Test the specific race condition between setProvider and setEvaluationContext
-    /// This was the main issue identified by the external reviewer
     func testSetProviderVsSetEvaluationContextRaceCondition() async throws {
         let concurrentOperations = 50
 
         await withTaskGroup(of: Void.self) { group in
-            // Concurrently set providers and evaluation contexts
             for i in 0..<concurrentOperations {
-                // Set provider operations
                 group.addTask {
                     let provider = MockProvider()
                     let ctx = ImmutableContext(
@@ -85,7 +78,6 @@ class ConcurrencyRaceConditionTests: XCTestCase {
                     await OpenFeatureAPI.shared.setProviderAndWait(provider: provider, initialContext: ctx)
                 }
 
-                // Set evaluation context operations
                 group.addTask {
                     let ctx = ImmutableContext(
                         targetingKey: "context-user\(i)",
@@ -96,13 +88,11 @@ class ConcurrencyRaceConditionTests: XCTestCase {
             }
         }
 
-        // Verify the API is in a consistent state
         let finalState = OpenFeatureAPI.shared.getState()
         XCTAssertNotNil(finalState.provider, "Provider should not be nil after concurrent operations")
         XCTAssertNotNil(finalState.evaluationContext, "Evaluation context should not be nil after concurrent operations")
-        XCTAssertTrue([.ready, .error, .fatal].contains(finalState.providerStatus), "Provider status should be in a valid final state")
+        XCTAssertTrue([.ready].contains(finalState.providerStatus), "Provider status should be in a valid final state")
 
-        // Verify the final context has expected structure from one of the operations
         if let context = finalState.evaluationContext {
             let targetingKey = context.getTargetingKey()
             XCTAssertTrue(
@@ -120,52 +110,13 @@ class ConcurrencyRaceConditionTests: XCTestCase {
         }
     }
 
-    /// Test the race condition between provider initialization and context updates
-    func testProviderInitializationVsContextUpdateRaceCondition() async throws {
-        let concurrentOperations = 30
-
-        await withTaskGroup(of: Void.self) { group in
-            for i in 0..<concurrentOperations {
-                // Provider initialization with context
-                group.addTask {
-                    let provider = MockProvider()
-                    let initialCtx = ImmutableContext(
-                        targetingKey: "init-user\(i)",
-                        structure: ImmutableStructure(attributes: ["init": .integer(Int64(i))])
-                    )
-                    await OpenFeatureAPI.shared.setProviderAndWait(provider: provider, initialContext: initialCtx)
-                }
-
-                // Immediate context updates
-                group.addTask {
-                    let updateCtx = ImmutableContext(
-                        targetingKey: "update-user\(i)",
-                        structure: ImmutableStructure(attributes: ["update": .integer(Int64(i))])
-                    )
-                    await OpenFeatureAPI.shared.setEvaluationContextAndWait(evaluationContext: updateCtx)
-                }
-
-                // Clear provider operations
-                group.addTask {
-                    OpenFeatureAPI.shared.clearProvider()
-                }
-            }
-        }
-
-        // Verify the API ends in a consistent state
-        let finalState = OpenFeatureAPI.shared.getState()
-        XCTAssertTrue([.notReady, .ready, .error, .fatal].contains(finalState.providerStatus))
-    }
-
-    /// Test high-frequency state changes to stress test synchronization
     func testHighFrequencyStateChangesRaceCondition() async throws {
         let highFrequencyOperations = 200
         let startTime = Date()
 
         await withTaskGroup(of: Void.self) { group in
             for i in 0..<highFrequencyOperations {
                 group.addTask {
-                    // Rapid fire operations
                     let provider = MockProvider()
                     let ctx = ImmutableContext(
                         targetingKey: "rapid-user\(i)",
@@ -174,8 +125,6 @@ class ConcurrencyRaceConditionTests: XCTestCase {
                             "timestamp": .string("\(Date().timeIntervalSince1970)")
                         ])
                     )
-
-                    // Alternate between different operations
                     switch i % 4 {
                     case 0:
                         await OpenFeatureAPI.shared.setProviderAndWait(provider: provider)
@@ -198,14 +147,11 @@ class ConcurrencyRaceConditionTests: XCTestCase {
         // Verify operations completed in reasonable time (no deadlocks)
         XCTAssertLessThan(duration, 10.0, "Operations took too long, possible deadlock")
 
-        // Verify final state is consistent
         let finalState = OpenFeatureAPI.shared.getState()
         XCTAssertTrue(
-            [ProviderStatus.notReady, .ready, .error, .fatal].contains(finalState.providerStatus),
+            [ProviderStatus.ready].contains(finalState.providerStatus),
             "Provider status '\(finalState.providerStatus)' should be in a valid state after high-frequency operations"
         )
-        
-        // If we have a provider and context, verify they're consistent
         if finalState.provider != nil && finalState.evaluationContext != nil {
             let context = finalState.evaluationContext!
             let targetingKey = context.getTargetingKey()
@@ -218,6 +164,8 @@ class ConcurrencyRaceConditionTests: XCTestCase {
             if contextMap.keys.contains("iteration") {
                 XCTAssertTrue(contextMap.keys.contains("timestamp"), "Context with iteration should also have timestamp")
             }
+        } else {
+            XCTFail()
         }
     }
 }