Add internal queue wrappers for the event store

Sources/Core/Emitter/EmitterControllerImpl.swift

@@ -132,7 +132,7 @@ class EmitterControllerImpl: Controller, EmitterController {
         }
     }
 
-    var eventStore: EventStore? {
+    var eventStore: EventStore {
         return emitter.eventStore
     }
 

Sources/Core/InternalQueue/EmitterControllerIQWrapper.swift

@@ -85,6 +85,10 @@ class EmitterControllerIQWrapper: EmitterController {
         get { return InternalQueue.sync { controller.maxEventStoreAge } }
         set { InternalQueue.sync { controller.maxEventStoreAge = newValue } }
     }
+
+    var eventStore: EventStore {
+        get { return InternalQueue.sync { EventStoreIQWrapper(eventStore: controller.eventStore) } }
+    }
 
     // MARK: - Methods
 

Sources/Core/InternalQueue/EventStoreIQWrapper.swift

@@ -0,0 +1,52 @@
+//  Copyright (c) 2013-present Snowplow Analytics Ltd. All rights reserved.
+//
+//  This program is licensed to you under the Apache License Version 2.0,
+//  and you may not use this file except in compliance with the Apache License
+//  Version 2.0. You may obtain a copy of the Apache License Version 2.0 at
+//  http://www.apache.org/licenses/LICENSE-2.0.
+//
+//  Unless required by applicable law or agreed to in writing,
+//  software distributed under the Apache License Version 2.0 is distributed on
+//  an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+//  express or implied. See the Apache License Version 2.0 for the specific
+//  language governing permissions and limitations there under.
+
+import Foundation
+
+class EventStoreIQWrapper: NSObject, EventStore {
+
+    private let eventStore: EventStore
+
+    public init(eventStore: EventStore) {
+        self.eventStore = eventStore
+    }
+
+    func addEvent(_ payload: Payload) {
+        InternalQueue.sync { eventStore.addEvent(payload) }
+    }
+
+    func removeEvent(withId storeId: Int64) -> Bool {
+        return InternalQueue.sync { eventStore.removeEvent(withId: storeId) }
+    }
+
+    func removeEvents(withIds storeIds: [Int64]) -> Bool {
+        return InternalQueue.sync { eventStore.removeEvents(withIds: storeIds) }
+    }
+
+    func removeAllEvents() -> Bool {
+        return InternalQueue.sync { eventStore.removeAllEvents() }
+    }
+
+    func count() -> UInt {
+        return InternalQueue.sync { eventStore.count() }
+    }
+
+    func emittableEvents(withQueryLimit queryLimit: UInt) -> [EmitterEvent] {
+        return InternalQueue.sync { eventStore.emittableEvents(withQueryLimit: queryLimit) }
+    }
+
+    func removeOldEvents(maxSize: Int64, maxAge: TimeInterval) {
+        return InternalQueue.sync { eventStore.removeOldEvents(maxSize: maxSize, maxAge: maxAge) }
+    }
+
+}

Sources/Snowplow/Controllers/EmitterController.swift

@@ -23,7 +23,7 @@ public protocol EmitterController: EmitterConfigurationProtocol {
     var isSending: Bool { get }
     /// The EventStore being used by the emitter.
     @objc
-    var eventStore: EventStore? { get }
+    var eventStore: EventStore { get }
     @objc
     func flush()
     /// Pause emitting events.

Tests/Configurations/TestEmitterConfiguration.swift

@@ -80,6 +80,27 @@ class TestEmitterConfiguration: XCTestCase {
         XCTAssertEqual(0, tracker.emitter?.dbCount)
     }
 
+    func testAllowsAccessToTheEventStore() {
+        let networkConnection = MockNetworkConnection(requestOption: .post, statusCode: 200)
+        let networkConfig = NetworkConfiguration(networkConnection: networkConnection)
+
+        let tracker = createTracker(networkConfig: networkConfig, emitterConfig: EmitterConfiguration())
+
+        tracker.emitter?.pause()
+        for i in 0..<10 {
+            _ = tracker.track(Structured(category: "cat", action: "act").value(NSNumber(value: i)))
+        }
+        Thread.sleep(forTimeInterval: 0.5)
+
+        XCTAssertEqual(10, tracker.emitter?.dbCount)
+        XCTAssertEqual(10, tracker.emitter?.eventStore.count())
+
+        XCTAssertTrue(tracker.emitter?.eventStore.removeAllEvents() ?? false)
+
+        XCTAssertEqual(0, tracker.emitter?.dbCount)
+        XCTAssertEqual(0, tracker.emitter?.eventStore.count())
+    }
+
     private func createTracker(networkConfig: NetworkConfiguration, emitterConfig: EmitterConfiguration) -> TrackerController {
         let trackerConfig = TrackerConfiguration()
         trackerConfig.installAutotracking = false