refactor: lint

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

Author: fabriziodemaria

Sources/OpenFeature/OpenFeatureAPI.swift

@@ -5,8 +5,10 @@ import Foundation
 /// Configuration here will be shared across all ``Client``s.
 public class OpenFeatureAPI {
     private let eventHandler = EventHandler()
-    private let stateQueue = DispatchQueue(label: "com.openfeature.state.queue") // Sync queue to change state atomically
-    private let unifiedQueue = AsyncProviderOperationsQueue()  // Queue for provider's initialize and onContextSet operations
+    // Sync queue to change state atomically
+    private let stateQueue = DispatchQueue(label: "com.openfeature.state.queue")
+    // Queue for provider's initialize and onContextSet operations
+    private let unifiedQueue = AsyncProviderOperationsQueue()
 
     private(set) var providerSubject = CurrentValueSubject<FeatureProvider?, Never>(nil)
     private(set) var evaluationContext: EvaluationContext?

Tests/OpenFeatureTests/ProviderOperationsQueueTests.swift

@@ -144,53 +144,39 @@ class ProviderOperationsQueueTests: XCTestCase {
             }
         }
 
-        let endTime = Date()
-        let duration = endTime.timeIntervalSince(startTime)
-
-        // Verify operations completed in reasonable time (no deadlocks)
+        let duration = Date().timeIntervalSince(startTime)
         XCTAssertLessThan(duration, 10.0, "Operations took too long, possible deadlock")
 
+        verifyFinalStateConsistency()
+    }
+
+    private func verifyFinalStateConsistency() {
         let finalState = OpenFeatureAPI.shared.getState()
-        // Note: With concurrent TaskGroup execution, the last operation to be enqueued (and thus execute last)
-        // is non-deterministic. The final state could be from any of the operation types.
-        // We verify the final state is consistent and valid, regardless of which operation completed last.
+        // With concurrent execution, the final state is non-deterministic
         XCTAssertTrue(
             [ProviderStatus.notReady, ProviderStatus.ready].contains(finalState.providerStatus),
-            "Provider status '\(finalState.providerStatus)' should be in a valid state after high-frequency operations"
+            "Provider status '\(finalState.providerStatus)' should be valid after high-frequency operations"
         )
 
-        // Verify state consistency: if provider is nil, status should be notReady
+        // Verify state consistency
         if finalState.provider == nil {
-            XCTAssertEqual(
-                finalState.providerStatus,
-                .notReady,
-                "When provider is nil, status should be notReady"
-            )
+            XCTAssertEqual(finalState.providerStatus, .notReady, "When provider is nil, status should be notReady")
         }
-
-        // Verify state consistency: if provider exists, status should be ready
         if finalState.provider != nil {
-            XCTAssertEqual(
-                finalState.providerStatus,
-                .ready,
-                "When provider exists, status should be ready"
-            )
+            XCTAssertEqual(finalState.providerStatus, .ready, "When provider exists, status should be ready")
         }
 
-        let context = finalState.evaluationContext
-        let targetingKey = context?.getTargetingKey() ?? ""
-        if !targetingKey.isEmpty {
+        // Verify context if present
+        if let context = finalState.evaluationContext {
+            let targetingKey = context.getTargetingKey()
             XCTAssertTrue(
                 targetingKey.hasPrefix("rapid-user"),
-                "Final targeting key '\(targetingKey)' should be from the rapid operations if context exists"
+                "Final targeting key '\(targetingKey)' should be from rapid operations"
             )
 
-            let contextMap = context?.asObjectMap() ?? [:]
+            let contextMap = context.asObjectMap()
             if contextMap.keys.contains("iteration") {
-                XCTAssertTrue(
-                    contextMap.keys.contains("timestamp"),
-                    "Context with iteration should also have timestamp"
-                )
+                XCTAssertTrue(contextMap.keys.contains("timestamp"), "Context should have timestamp")
             }
         }
     }