Keep a record of the last fetched flags and only emit a new value if it's changed (#77)

* Keep a record of the last fetched flags and only emit a new value if it's changed

* Improve testability and add a unit test for the new equality checks

* Update FlagsmithClient/Classes/Flagsmith.swift

Co-authored-by: Matthew Elwell <mjelwell89@gmail.com>

* Used an actor for the yield count to make it more thread safe on Swift 5. Hopefully this fixes the build issues.

* And also the updated tests

* Reduced the iterations on the concurrent request test as it wasn't completing within the 10 second time limit and also removed a warning.

---------

Co-authored-by: Matthew Elwell <mjelwell89@gmail.com>

Author: gazreese

FlagsmithClient/Classes/Flag.swift

@@ -10,7 +10,7 @@ import Foundation
 /**
  A Flag represents a feature flag on the server.
  */
-public struct Flag: Codable, Sendable {
+public struct Flag: Codable, Sendable, Equatable {
     enum CodingKeys: String, CodingKey {
         case feature
         case value = "feature_state_value"
@@ -70,4 +70,10 @@ public struct Flag: Codable, Sendable {
         try container.encode(value, forKey: .value)
         try container.encode(enabled, forKey: .enabled)
     }
+    
+    public static func == (lhs: Flag, rhs: Flag) -> Bool {
+        return lhs.feature.name == rhs.feature.name &&
+            lhs.value == rhs.value &&
+            lhs.enabled == rhs.enabled
+    }
 }

FlagsmithClient/Classes/Flagsmith.swift

@@ -26,6 +26,8 @@ public final class Flagsmith: @unchecked Sendable {
 
     // The last identity used for fetching flags
     private var lastUsedIdentity: String?
+    // The last result from fetching flags
+    internal var lastFlags: [Flag]?
 
     var anyFlagStreamContinuation: Any? // AsyncStream<[Flag]>.Continuation? for iOS 13+
 
@@ -364,10 +366,8 @@ public final class Flagsmith: @unchecked Sendable {
                     switch result {
                     case let .failure(error):
                         print("Flagsmith - Error getting flags in SSE stream: \(error.localizedDescription)")
-
-                    case .success:
-                        // On success the flastream is updated automatically in the API call
-                        print("Flagsmith - Flags updated from SSE stream.")
+                    case .success(_):
+                        break
                     }
                 }
             }
@@ -380,13 +380,18 @@ public final class Flagsmith: @unchecked Sendable {
     func updateFlagStreamAndLastUpdatedAt(_ flags: [Flag]) {
         // Update the flag stream
         if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 7.0, *) {
-            flagStreamContinuation?.yield(flags)
+            if (flags != lastFlags) {
+                flagStreamContinuation?.yield(flags)
+            }
         }
 
         // Update the last updated time if the API is giving us newer data
         if let apiManagerUpdatedAt = apiManager.lastUpdatedAt, apiManagerUpdatedAt > lastUpdatedAt {
             lastUpdatedAt = apiManagerUpdatedAt
         }
+        
+        // Save the last set of flags we got so that we have something to compare against and only publish changes
+        lastFlags = flags
     }
 }
 

FlagsmithClient/Tests/APIManagerTests.swift

@@ -63,7 +63,7 @@ final class APIManagerTests: FlagsmithClientTestCase {
         let concurrentQueue = DispatchQueue(label: "concurrentQueue", attributes: .concurrent)
 
         var expectations: [XCTestExpectation] = []
-        let iterations = 500
+        let iterations = 100
 
         for concurrentIteration in 1 ... iterations {
             let expectation = XCTestExpectation(description: "Multiple threads can access the APIManager \(concurrentIteration)")

FlagsmithClient/Tests/SSEManagerTests.swift

@@ -115,4 +115,86 @@ class SSEManagerTests: FlagsmithClientTestCase {
 
         wait(for: [requestFinished], timeout: 1.0)
     }
+
+    func testFlagStreamYieldsOnlyOnDifferentFlags() {
+        guard #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 7.0, *) else {
+            XCTFail("AsyncStream is not available on this platform.")
+            return
+        }
+
+        let flagsmith = Flagsmith.shared
+        var continuation: AsyncStream<[Flag]>.Continuation?
+        let stream = AsyncStream<[Flag]> { cont in
+            continuation = cont
+        }
+        flagsmith.anyFlagStreamContinuation = continuation
+
+        // Reset lastFlags to ensure a clean state for the test
+        flagsmith.lastFlags = nil
+
+        let flag1 = Flag(featureName: "test_feature_1", value: .string("value1"), enabled: true, featureType: "STANDARD")
+        let flag2 = Flag(featureName: "test_feature_2", value: .int(123), enabled: false, featureType: "STANDARD")
+        let flags1 = [flag1, flag2]
+
+        let flag3 = Flag(featureName: "test_feature_3", value: .bool(true), enabled: true, featureType: "STANDARD")
+        let flags2 = [flag1, flag3] // Different set of flags
+
+        let firstYieldExpectation = expectation(description: "First flags yielded")
+        let noYieldExpectation = expectation(description: "No yield on same flags")
+        noYieldExpectation.isInverted = true
+        let secondYieldExpectation = expectation(description: "Second flags yielded")
+
+        // Use an actor to make the counter thread-safe for Swift 5 compatibility
+        actor YieldCounter {
+            private var count = 0
+            
+            func increment() -> Int {
+                count += 1
+                return count
+            }
+        }
+        
+        let yieldCounter = YieldCounter()
+        let taskCompletionExpectation = expectation(description: "Task completed")
+        
+        let _ = Task {
+            for await flags in stream {
+                let currentCount = await yieldCounter.increment()
+                switch currentCount {
+                case 1:
+                    XCTAssertEqual(flags, flags1)
+                    firstYieldExpectation.fulfill()
+                case 2:
+                    XCTAssertEqual(flags, flags2)
+                    secondYieldExpectation.fulfill()
+                default:
+                    XCTFail("Unexpected yield from stream")
+                }
+            }
+            // Signal that the task has finished processing all stream items
+            taskCompletionExpectation.fulfill()
+        }
+
+        // 1. Call with new flags (should yield)
+        flagsmith.updateFlagStreamAndLastUpdatedAt(flags1)
+        wait(for: [firstYieldExpectation], timeout: 1.0)
+
+        // 2. Call with same flags (should NOT yield)
+        flagsmith.updateFlagStreamAndLastUpdatedAt(flags1)
+        wait(for: [noYieldExpectation], timeout: 0.1) // Short timeout to ensure no yield
+
+        // 3. Call with different flags (should yield)
+        flagsmith.updateFlagStreamAndLastUpdatedAt(flags2)
+        wait(for: [secondYieldExpectation], timeout: 1.0)
+
+        // Clean up: stop the stream and wait for task to complete
+        continuation?.finish()
+        
+        // Wait for the async task to finish processing all items before continuing
+        wait(for: [taskCompletionExpectation], timeout: 1.0)
+        
+        // Reset Flagsmith state to avoid interference with other tests
+        flagsmith.anyFlagStreamContinuation = nil
+        flagsmith.lastFlags = nil
+    }
 }