Add ability to override implementation of publish

Will be needed by some upcoming integration tests that I'm porting from
JS.

There might be a better way to do this (injecting a special CoreSDK and
thus not having to add this hook to the RealtimeObjects itself) but
it'll do.

Author: lawrence-forooghian

Sources/AblyLiveObjects/Internal/CoreSDK.swift

@@ -8,16 +8,31 @@ internal protocol CoreSDK: AnyObject, Sendable {
     /// Implements the internal `#publish` method of RTO15.
     func publish(objectMessages: [OutboundObjectMessage]) async throws(InternalError)
 
+    /// Replaces the implementation of ``publish(objectMessages:)``.
+    ///
+    /// Used by integration tests, for example to disable `ObjectMessage` publishing so that a test can verify that a behaviour is not a side effect of an `ObjectMessage` sent by the SDK.
+    func testsOnly_overridePublish(with newImplementation: @escaping ([OutboundObjectMessage]) async throws(InternalError) -> Void)
+
     /// Returns the current state of the Realtime channel that this wraps.
     var channelState: ARTRealtimeChannelState { get }
 }
 
 internal final class DefaultCoreSDK: CoreSDK {
+    /// Used to synchronize access to internal mutable state.
+    private let mutex = NSLock()
+
     private let channel: AblyPlugin.RealtimeChannel
     private let client: AblyPlugin.RealtimeClient
     private let pluginAPI: PluginAPIProtocol
     private let logger: AblyPlugin.Logger
 
+    /// If set to true, ``publish(objectMessages:)`` will behave like a no-op.
+    ///
+    /// This enables the `testsOnly_overridePublish(with:)` test hook.
+    ///
+    /// - Note: This should be `throws(InternalError)` but that causes a compilation error of "Runtime support for typed throws function types is only available in macOS 15.0.0 or newer".
+    private nonisolated(unsafe) var overriddenPublishImplementation: (([OutboundObjectMessage]) async throws -> Void)?
+
     internal init(
         channel: AblyPlugin.RealtimeChannel,
         client: AblyPlugin.RealtimeClient,
@@ -35,6 +50,22 @@ internal final class DefaultCoreSDK: CoreSDK {
     internal func publish(objectMessages: [OutboundObjectMessage]) async throws(InternalError) {
         logger.log("publish(objectMessages: \(LoggingUtilities.formatObjectMessagesForLogging(objectMessages)))", level: .debug)
 
+        // Use the overridden implementation if supplied
+        let overriddenImplementation = mutex.withLock {
+            overriddenPublishImplementation
+        }
+        if let overriddenImplementation {
+            do {
+                try await overriddenImplementation(objectMessages)
+            } catch {
+                guard let internalError = error as? InternalError else {
+                    preconditionFailure("Expected InternalError, got \(error)")
+                }
+                throw internalError
+            }
+            return
+        }
+
         // TODO: Implement the full spec of RTO15 (https://github.com/ably/ably-cocoa-liveobjects-plugin/issues/47)
         try await DefaultInternalPlugin.sendObject(
             objectMessages: objectMessages,
@@ -44,6 +75,12 @@ internal final class DefaultCoreSDK: CoreSDK {
         )
     }
 
+    internal func testsOnly_overridePublish(with newImplementation: @escaping ([OutboundObjectMessage]) async throws(InternalError) -> Void) {
+        mutex.withLock {
+            overriddenPublishImplementation = newImplementation
+        }
+    }
+
     internal var channelState: ARTRealtimeChannelState {
         channel.state
     }

Sources/AblyLiveObjects/Public/Public Proxy Objects/PublicDefaultRealtimeObjects.swift

@@ -117,4 +117,13 @@ internal final class PublicDefaultRealtimeObjects: RealtimeObjects {
     internal var testsOnly_receivedObjectSyncProtocolMessages: AsyncStream<[InboundObjectMessage]> {
         proxied.testsOnly_receivedObjectSyncProtocolMessages
     }
+
+    // These are used by the integration tests.
+
+    /// Replaces the method that this `RealtimeObjects` uses to send any outbound `ObjectMessage`s.
+    ///
+    /// Used by integration tests, for example to disable `ObjectMessage` publishing so that a test can verify that a behaviour is not a side effect of an `ObjectMessage` sent by the SDK.
+    internal func testsOnly_overridePublish(with newImplementation: @escaping ([OutboundObjectMessage]) async throws(InternalError) -> Void) {
+        coreSDK.testsOnly_overridePublish(with: newImplementation)
+    }
 }

Tests/AblyLiveObjectsTests/Mocks/MockCoreSDK.swift

@@ -20,6 +20,10 @@ final class MockCoreSDK: CoreSDK {
         }
     }
 
+    func testsOnly_overridePublish(with _: @escaping ([OutboundObjectMessage]) async throws(InternalError) -> Void) {
+        protocolRequirementNotImplemented()
+    }
+
     var channelState: ARTRealtimeChannelState {
         get {
             mutex.withLock {