[chain-pr 7/10] DatadogFlags: typed-bus migration

Author: maxep

DatadogFlags/Sources/Client/FlagsClient.swift

@@ -189,7 +189,7 @@ public final class FlagsClient {
             ),
             exposureLogger: feature.makeExposureLogger(featureScope),
             evaluationLogger: feature.makeEvaluationLogger(featureScope),
-            rumFlagEvaluationReporter: feature.makeRUMFlagEvaluationReporter(featureScope)
+            rumFlagEvaluationReporter: feature.makeRUMFlagEvaluationReporter()
         )
 
         feature.clientRegistry.register(client, named: name)

DatadogFlags/Sources/Client/RUMFlagEvaluationReporter.swift

@@ -12,19 +12,17 @@ internal protocol RUMFlagEvaluationReporting {
 }
 
 internal final class RUMFlagEvaluationReporter: RUMFlagEvaluationReporting {
-    private let featureScope: any FeatureScope
+    private let messageBus: any MessageBus
 
-    init(featureScope: any FeatureScope) {
-        self.featureScope = featureScope
+    init(messageBus: any MessageBus) {
+        self.messageBus = messageBus
     }
 
     func sendFlagEvaluation<T>(flagKey: String, value: T) where T: FlagValue {
-        featureScope.send(
-            message: .payload(
-                RUMFlagEvaluationMessage(
-                    flagKey: flagKey,
-                    value: value
-                )
+        messageBus.send(
+            message: RUMFlagEvaluationMessage(
+                flagKey: flagKey,
+                value: value
             )
         )
     }

DatadogFlags/Sources/Feature/FlagsFeature.swift

@@ -21,7 +21,7 @@ internal struct FlagsFeature: DatadogRemoteFeature {
     let clientRegistry: FlagsClientRegistry
     let makeExposureLogger: (any FeatureScope) -> any ExposureLogging
     let makeEvaluationLogger: (any FeatureScope) -> any EvaluationLogging
-    let makeRUMFlagEvaluationReporter: (any FeatureScope) -> any RUMFlagEvaluationReporting
+    let makeRUMFlagEvaluationReporter: () -> any RUMFlagEvaluationReporting
     let performanceOverride: PerformancePresetOverride?
     let issueReporter: IssueReporter
     private let evaluationAggregator: EvaluationAggregator?
@@ -76,11 +76,11 @@ internal struct FlagsFeature: DatadogRemoteFeature {
             return EvaluationLogger(aggregator: aggregator)
         }
 
-        makeRUMFlagEvaluationReporter = { featureScope in
+        makeRUMFlagEvaluationReporter = { [messageBus = core.messageBus] in
             guard configuration.rumIntegrationEnabled else {
                 return NOPRUMFlagEvaluationReporter()
             }
-            return RUMFlagEvaluationReporter(featureScope: featureScope)
+            return RUMFlagEvaluationReporter(messageBus: messageBus)
         }
         performanceOverride = PerformancePresetOverride(maxObjectsInFile: 50)
 

DatadogFlags/Tests/Client/FlagsClientTests.swift

@@ -308,15 +308,18 @@ final class FlagsClientTests: XCTestCase {
             date: .mockAny()
         )
         let data = try JSONEncoder().encode(initialState)
-        let messageReceiver = FeatureMessageReceiverMock()
         let core = SingleFeatureCoreMock<FlagsFeature>(
             dataStore: DataStoreMock(
                 storage: [
                     FlagsClient.defaultName: .value(data, dataStoreDefaultKeyVersion)
                 ]
-            ),
-            messageReceiver: messageReceiver
+            )
         )
+        var rumMessages: [RUMFlagEvaluationMessage] = []
+        let subscription = core.messageBus.subscribe { (msg: RUMFlagEvaluationMessage, _) in
+            rumMessages.append(msg)
+        }
+        defer { core.messageBus.unsubscribe(subscription) }
 
         // When
         Flags.enable(with: .init(trackExposures: false), in: core)
@@ -326,7 +329,7 @@ final class FlagsClientTests: XCTestCase {
 
         // Then
         XCTAssertEqual(core.events(ofType: ExposureEvent.self).count, 0, "No exposure events should be written")
-        XCTAssertEqual(messageReceiver.messages.filter(\.isRUMMessage).count, 1, "RUM integration should still work")
+        XCTAssertEqual(rumMessages.count, 1, "RUM integration should still work")
     }
 
     func testRUMIntegrationDisabled() throws {
@@ -337,15 +340,18 @@ final class FlagsClientTests: XCTestCase {
             date: .mockAny()
         )
         let data = try JSONEncoder().encode(initialState)
-        let messageReceiver = FeatureMessageReceiverMock()
         let core = SingleFeatureCoreMock<FlagsFeature>(
             dataStore: DataStoreMock(
                 storage: [
                     FlagsClient.defaultName: .value(data, dataStoreDefaultKeyVersion)
                 ]
-            ),
-            messageReceiver: messageReceiver
+            )
         )
+        var rumMessages: [RUMFlagEvaluationMessage] = []
+        let subscription = core.messageBus.subscribe { (msg: RUMFlagEvaluationMessage, _) in
+            rumMessages.append(msg)
+        }
+        defer { core.messageBus.unsubscribe(subscription) }
 
         // When
         Flags.enable(with: .init(rumIntegrationEnabled: false), in: core)
@@ -355,7 +361,7 @@ final class FlagsClientTests: XCTestCase {
 
         // Then
         XCTAssertEqual(core.events(ofType: ExposureEvent.self).count, 1, "Exposure should still be logged")
-        XCTAssertEqual(messageReceiver.messages.filter(\.isRUMMessage).count, 0, "No RUM messages should be sent")
+        XCTAssertEqual(rumMessages.count, 0, "No RUM messages should be sent")
     }
 
     // MARK: - Internal methods consumed by the React Native SDK

DatadogFlags/Tests/Client/RUMFlagEvaluationReporterTests.swift

@@ -10,12 +10,20 @@ import DatadogInternal
 
 @testable import DatadogFlags
 
-final class RUMFlagEvaluationReporterTests: XCTestCase {
-    private let featureScope = FeatureScopeMock()
+private final class RUMFlagEvaluationRecorder: BusMessageReceiver {
+    private(set) var messages: [RUMFlagEvaluationMessage] = []
+    func receive(message: RUMFlagEvaluationMessage, from core: DatadogCoreProtocol) {
+        messages.append(message)
+    }
+}
 
+final class RUMFlagEvaluationReporterTests: XCTestCase {
     func testSendFlagEvaluation() throws {
         // Given
-        let reporter = RUMFlagEvaluationReporter(featureScope: featureScope)
+        let core = PassthroughCoreMock()
+        let recorder = RUMFlagEvaluationRecorder()
+        core.subscribe(receiver: recorder)
+        let reporter = RUMFlagEvaluationReporter(messageBus: core.messageBus)
 
         // When
         reporter.sendFlagEvaluation(
@@ -24,10 +32,9 @@ final class RUMFlagEvaluationReporterTests: XCTestCase {
         )
 
         // Then
-        let messages = featureScope.messagesSent()
-        XCTAssertEqual(messages.count, 1, "Should send flag evaluation message")
+        XCTAssertEqual(recorder.messages.count, 1, "Should send flag evaluation message")
 
-        let flagEvaluation = try XCTUnwrap(messages.firstPayload as? RUMFlagEvaluationMessage)
+        let flagEvaluation = try XCTUnwrap(recorder.messages.first)
         XCTAssertEqual(flagEvaluation.flagKey, "feature-flag")
         XCTAssertEqual(flagEvaluation.value as? Bool, true)
     }