refactor: Add message container to payload (#99)

* refactor: EventSender signatures * Update usage in Demo App * refactor: Add message container in payload * Formatting
spotify · Apr 23, 2024 · f0bf363 · f0bf363
1 parent 85b89ed
commit f0bf363
Show file tree

Hide file tree

Showing 6 changed files with 53 additions and 31 deletions.
diff --git a/ConfidenceDemoApp/ConfidenceDemoApp/ConfidenceDemoApp.swift b/ConfidenceDemoApp/ConfidenceDemoApp/ConfidenceDemoApp.swift
@@ -41,8 +41,8 @@ extension ConfidenceDemoApp {
             await OpenFeatureAPI.shared.setProviderAndWait(provider: provider, initialContext: ctx)
         }
         confidence.send(
-            definition: "all-types",
-            payload: [
+            eventName: "all-types",
+            message: [
                 "my_string": ConfidenceValue(string: "hello_from_world"),
                 "my_timestamp": ConfidenceValue(timestamp: Date()),
                 "my_bool": ConfidenceValue(boolean: true),

diff --git a/Sources/Confidence/Confidence.swift b/Sources/Confidence/Confidence.swift
@@ -28,8 +28,8 @@ public class Confidence: ConfidenceEventSender {
         self.parent = parent
     }
 
-    public func send(definition: String, payload: ConfidenceStruct) {
-        eventSenderEngine.emit(definition: definition, payload: payload, context: getContext())
+    public func send(eventName: String, message: ConfidenceStruct) {
+        eventSenderEngine.emit(eventName: eventName, message: message, context: getContext())
     }
 
 

diff --git a/Sources/Confidence/ConfidenceEventSender.swift b/Sources/Confidence/ConfidenceEventSender.swift
@@ -2,5 +2,5 @@ import Foundation
 
 /// Sends events to Confidence. Contextual data is appended to each event
 public protocol ConfidenceEventSender: Contextual {
-    func send(definition: String, payload: ConfidenceStruct)
+    func send(eventName: String, message: ConfidenceStruct)
 }
diff --git a/Sources/Confidence/EventSenderEngine.swift b/Sources/Confidence/EventSenderEngine.swift
@@ -9,7 +9,7 @@ protocol FlushPolicy {
 }
 
 protocol EventSenderEngine {
-    func emit(definition: String, payload: ConfidenceStruct, context: ConfidenceStruct)
+    func emit(eventName: String, message: ConfidenceStruct, context: ConfidenceStruct)
     func shutdown()
 }
 
@@ -78,12 +78,12 @@ final class EventSenderEngineImpl: EventSenderEngine {
         .store(in: &cancellables)
     }
 
-    func emit(definition: String, payload: ConfidenceStruct, context: ConfidenceStruct) {
+    func emit(eventName: String, message: ConfidenceStruct, context: ConfidenceStruct) {
+        var mutablePayload = context
+        mutablePayload["message"] = ConfidenceValue(structure: message)
         writeReqChannel.send(ConfidenceEvent(
-            name: definition,
-            payload: context.merging(payload) { _, new in
-                new
-            },
+            name: eventName,
+            payload: mutablePayload,
             eventTime: Date.backport.now)
         )
     }

diff --git a/Tests/ConfidenceTests/EventSenderEngineTest.swift b/Tests/ConfidenceTests/EventSenderEngineTest.swift
@@ -5,8 +5,12 @@ import XCTest
 @testable import Confidence
 
 final class MinSizeFlushPolicy: FlushPolicy {
-    private var maxSize = 5
+    private var maxSize: Int
     private var size = 0
+
+    init(maxSize: Int) {
+        self.maxSize = maxSize
+    }
     func reset() {
         size = 0
     }
@@ -37,8 +41,8 @@ final class ImmidiateFlushPolicy: FlushPolicy {
 }
 
 final class EventSenderEngineTest: XCTestCase {
-    func testAddingEventsWithSizeFlushPolicyWorks() throws {
-        let flushPolicies = [MinSizeFlushPolicy()]
+    func testPayloadOnEmit() throws {
+        let flushPolicies = [MinSizeFlushPolicy(maxSize: 1)]
         let uploader = EventUploaderMock()
         let eventSenderEngine = EventSenderEngineImpl(
             clientSecret: "CLIENT_SECRET",
@@ -51,25 +55,43 @@ final class EventSenderEngineTest: XCTestCase {
         let cancellable = uploader.subject.sink { _ in
             expectation.fulfill()
         }
+        eventSenderEngine.emit(
+            eventName: "my_event",
+            message: [
+                "a": .init(integer: 0),
+                "message": .init(integer: 1),
+            ],
+            context: [
+                "a": .init(integer: 2),
+                "message": .init(integer: 3) // the root "message" overrides this
+            ])
 
-        var events: [ConfidenceEvent] = []
-        for i in 0..<5 {
-            events.append(ConfidenceEvent(
-                name: "\(i)",
-                payload: [:],
-                eventTime: Date.backport.now)
-            )
-            eventSenderEngine.emit(definition: "\(i)", payload: [:], context: [:])
-        }
 
         wait(for: [expectation], timeout: 5)
-        let uploadRequest = try XCTUnwrap(uploader.calledRequest)
-        XCTAssertTrue(uploadRequest.map { $0.eventDefinition } == events.map { $0.name })
+        XCTAssertEqual(try XCTUnwrap(uploader.calledRequest)[0].eventDefinition, "my_event")
+        XCTAssertEqual(try XCTUnwrap(uploader.calledRequest)[0].payload, NetworkStruct(fields: [
+            "message": .structure(.init(fields: [
+                "a": .number(0.0),
+                "message": .number(1.0)
+            ])),
+            "a": .number(2.0)
+        ]))
+        cancellable.cancel()
+    }
+
+    func testAddingEventsWithSizeFlushPolicyWorks() throws {
+        let flushPolicies = [MinSizeFlushPolicy(maxSize: 5)]
+        let uploader = EventUploaderMock()
+        let eventSenderEngine = EventSenderEngineImpl(
+            clientSecret: "CLIENT_SECRET",
+            uploader: uploader,
+            storage: EventStorageMock(),
+            flushPolicies: flushPolicies
+        )
 
-        uploader.reset()
-        eventSenderEngine.emit(definition: "Hello", payload: [:], context: [:])
+        eventSenderEngine.emit(eventName: "Hello", message: [:], context: [:])
+        // TODO: We need to wait for writeReqChannel to complete to make this test meaningful
         XCTAssertNil(uploader.calledRequest)
-        cancellable.cancel()
     }
 
     func testRemoveEventsFromStorageOnBadRequest() throws {
@@ -87,7 +109,7 @@ final class EventSenderEngineTest: XCTestCase {
             storage: storage,
             flushPolicies: flushPolicies
         )
-        eventSenderEngine.emit(definition: "testEvent", payload: ConfidenceStruct(), context: ConfidenceStruct())
+        eventSenderEngine.emit(eventName: "testEvent", message: ConfidenceStruct(), context: ConfidenceStruct())
         let expectation = expectation(description: "events batched")
         storage.eventsRemoved{
             expectation.fulfill()
@@ -113,7 +135,7 @@ final class EventSenderEngineTest: XCTestCase {
             flushPolicies: flushPolicies
         )
 
-        eventSenderEngine.emit(definition: "testEvent", payload: ConfidenceStruct(), context: ConfidenceStruct())
+        eventSenderEngine.emit(eventName: "testEvent", message: ConfidenceStruct(), context: ConfidenceStruct())
 
         XCTAssertEqual(storage.isEmpty(), false)
     }

diff --git a/Tests/ConfidenceTests/Helpers/EventSenderEngineMock.swift b/Tests/ConfidenceTests/Helpers/EventSenderEngineMock.swift
@@ -2,7 +2,7 @@ import Foundation
 @testable import Confidence
 
 class EventSenderEngineMock: EventSenderEngine {
-    func emit(definition: String, payload: ConfidenceStruct, context: ConfidenceStruct) {
+    func emit(eventName: String, message: ConfidenceStruct, context: ConfidenceStruct) {
         // NO-OP
     }