test: add comprehensive Realtime test coverage (#755)

Author: grdsdev

Sources/Realtime/PushV2.swift

@@ -16,12 +16,12 @@ public enum PushStatus: String, Sendable {
 
 @MainActor
 final class PushV2 {
-  private weak var channel: RealtimeChannelV2?
+  private weak var channel: (any RealtimeChannelProtocol)?
   let message: RealtimeMessageV2
 
   private var receivedContinuation: CheckedContinuation<PushStatus, Never>?
 
-  init(channel: RealtimeChannelV2?, message: RealtimeMessageV2) {
+  init(channel: (any RealtimeChannelProtocol)?, message: RealtimeMessageV2) {
     self.channel = channel
     self.message = message
   }

Sources/Realtime/RealtimeChannelV2.swift

@@ -24,7 +24,15 @@ public struct RealtimeChannelConfig: Sendable {
   public var isPrivate: Bool
 }
 
-public final class RealtimeChannelV2: Sendable {
+protocol RealtimeChannelProtocol: AnyObject, Sendable {
+  @MainActor var config: RealtimeChannelConfig { get }
+  var topic: String { get }
+  var logger: (any SupabaseLogger)? { get }
+
+  var socket: any RealtimeClientProtocol { get }
+}
+
+public final class RealtimeChannelV2: Sendable, RealtimeChannelProtocol {
   struct MutableState {
     var clientChanges: [PostgresJoinConfig] = []
     var joinRef: String?
@@ -39,7 +47,7 @@ public final class RealtimeChannelV2: Sendable {
   @MainActor var config: RealtimeChannelConfig
 
   let logger: (any SupabaseLogger)?
-  let socket: RealtimeClientV2
+  let socket: any RealtimeClientProtocol
 
   @MainActor var joinRef: String? { mutableState.joinRef }
 
@@ -70,7 +78,7 @@ public final class RealtimeChannelV2: Sendable {
   init(
     topic: String,
     config: RealtimeChannelConfig,
-    socket: RealtimeClientV2,
+    socket: any RealtimeClientProtocol,
     logger: (any SupabaseLogger)?
   ) {
     self.topic = topic

Sources/Realtime/RealtimeClientV2.swift

@@ -16,7 +16,20 @@ import Foundation
 typealias WebSocketTransport = @Sendable (_ url: URL, _ headers: [String: String]) async throws ->
   any WebSocket
 
-public final class RealtimeClientV2: Sendable {
+protocol RealtimeClientProtocol: AnyObject, Sendable {
+  var status: RealtimeClientStatus { get }
+  var options: RealtimeClientOptions { get }
+  var http: any HTTPClientType { get }
+  var broadcastURL: URL { get }
+
+  func connect() async
+  func push(_ message: RealtimeMessageV2)
+  func _getAccessToken() async -> String?
+  func makeRef() -> String
+  func _remove(_ channel: any RealtimeChannelProtocol)
+}
+
+public final class RealtimeClientV2: Sendable, RealtimeClientProtocol {
   struct MutableState {
     var accessToken: String?
     var ref = 0
@@ -320,7 +333,7 @@ public final class RealtimeClientV2: Sendable {
     }
   }
 
-  func _remove(_ channel: RealtimeChannelV2) {
+  func _remove(_ channel: any RealtimeChannelProtocol) {
     mutableState.withValue {
       $0.channels[channel.topic] = nil
     }

Supabase.xcworkspace/xcshareddata/xcschemes/Functions.xcscheme

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
    LastUpgradeVersion = "1510"
-   version = "1.7">
+   version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
       buildImplicitDependencies = "YES">

Tests/RealtimeTests/ExportsTests.swift

@@ -0,0 +1,31 @@
+//
+//  ExportsTests.swift
+//  Supabase
+//
+//  Created by Guilherme Souza on 29/07/25.
+//
+
+import XCTest
+
+@testable import Realtime
+
+final class ExportsTests: XCTestCase {
+  func testHelperImportIsAccessible() {
+    // Test that the Helpers module is properly exported
+    // This is a simple validation that the @_exported import works
+
+    // Test that we can access JSONObject from Helpers via Realtime
+    let jsonObject: JSONObject = [:]
+    XCTAssertNotNil(jsonObject)
+
+    // Test that we can access AnyJSON from Helpers via Realtime
+    let anyJSON: AnyJSON = .string("test")
+    XCTAssertEqual(anyJSON, .string("test"))
+
+    // Test that we can access ObservationToken from Helpers via Realtime
+    let token = ObservationToken {
+      // Empty cleanup
+    }
+    XCTAssertNotNil(token)
+  }
+}

Tests/RealtimeTests/PostgresActionTests.swift

@@ -0,0 +1,259 @@
+//
+//  PostgresActionTests.swift
+//  Supabase
+//
+//  Created by Guilherme Souza on 29/07/25.
+//
+
+import XCTest
+
+@testable import Realtime
+
+final class PostgresActionTests: XCTestCase {
+  private let sampleMessage = RealtimeMessageV2(
+    joinRef: nil,
+    ref: nil,
+    topic: "test:table",
+    event: "postgres_changes",
+    payload: [:]
+  )
+
+  private let sampleColumns = [
+    Column(name: "id", type: "int8"),
+    Column(name: "name", type: "text"),
+    Column(name: "email", type: "text"),
+  ]
+
+  private let sampleDate = Date(timeIntervalSince1970: 1_722_246_000)  // Fixed timestamp for consistency
+
+  func testColumnEquality() {
+    let column1 = Column(name: "id", type: "int8")
+    let column2 = Column(name: "id", type: "int8")
+    let column3 = Column(name: "email", type: "text")
+
+    XCTAssertEqual(column1, column2)
+    XCTAssertNotEqual(column1, column3)
+  }
+
+  func testInsertActionEventType() {
+    XCTAssertEqual(InsertAction.eventType, .insert)
+  }
+
+  func testInsertActionProperties() {
+    let record: JSONObject = ["id": .string("123"), "name": .string("John")]
+    let insertAction = InsertAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      rawMessage: sampleMessage
+    )
+
+    XCTAssertEqual(insertAction.columns, sampleColumns)
+    XCTAssertEqual(insertAction.commitTimestamp, sampleDate)
+    XCTAssertEqual(insertAction.record, record)
+    XCTAssertEqual(insertAction.rawMessage.topic, "test:table")
+  }
+
+  func testUpdateActionEventType() {
+    XCTAssertEqual(UpdateAction.eventType, .update)
+  }
+
+  func testUpdateActionProperties() {
+    let record: JSONObject = ["id": .string("123"), "name": .string("John Updated")]
+    let oldRecord: JSONObject = ["id": .string("123"), "name": .string("John")]
+
+    let updateAction = UpdateAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      oldRecord: oldRecord,
+      rawMessage: sampleMessage
+    )
+
+    XCTAssertEqual(updateAction.columns, sampleColumns)
+    XCTAssertEqual(updateAction.commitTimestamp, sampleDate)
+    XCTAssertEqual(updateAction.record, record)
+    XCTAssertEqual(updateAction.oldRecord, oldRecord)
+    XCTAssertEqual(updateAction.rawMessage.topic, "test:table")
+  }
+
+  func testDeleteActionEventType() {
+    XCTAssertEqual(DeleteAction.eventType, .delete)
+  }
+
+  func testDeleteActionProperties() {
+    let oldRecord: JSONObject = ["id": .string("123"), "name": .string("John")]
+
+    let deleteAction = DeleteAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      oldRecord: oldRecord,
+      rawMessage: sampleMessage
+    )
+
+    XCTAssertEqual(deleteAction.columns, sampleColumns)
+    XCTAssertEqual(deleteAction.commitTimestamp, sampleDate)
+    XCTAssertEqual(deleteAction.oldRecord, oldRecord)
+    XCTAssertEqual(deleteAction.rawMessage.topic, "test:table")
+  }
+
+  func testAnyActionEventType() {
+    XCTAssertEqual(AnyAction.eventType, .all)
+  }
+
+  func testAnyActionInsertCase() {
+    let record: JSONObject = ["id": .string("123"), "name": .string("John")]
+    let insertAction = InsertAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      rawMessage: sampleMessage
+    )
+
+    let anyAction = AnyAction.insert(insertAction)
+    XCTAssertEqual(anyAction.rawMessage.topic, "test:table")
+
+    if case let .insert(wrappedAction) = anyAction {
+      XCTAssertEqual(wrappedAction.record, record)
+    } else {
+      XCTFail("Expected insert case")
+    }
+  }
+
+  func testAnyActionUpdateCase() {
+    let record: JSONObject = ["id": .string("123"), "name": .string("John Updated")]
+    let oldRecord: JSONObject = ["id": .string("123"), "name": .string("John")]
+
+    let updateAction = UpdateAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      oldRecord: oldRecord,
+      rawMessage: sampleMessage
+    )
+
+    let anyAction = AnyAction.update(updateAction)
+    XCTAssertEqual(anyAction.rawMessage.topic, "test:table")
+
+    if case let .update(wrappedAction) = anyAction {
+      XCTAssertEqual(wrappedAction.record, record)
+      XCTAssertEqual(wrappedAction.oldRecord, oldRecord)
+    } else {
+      XCTFail("Expected update case")
+    }
+  }
+
+  func testAnyActionDeleteCase() {
+    let oldRecord: JSONObject = ["id": .string("123"), "name": .string("John")]
+
+    let deleteAction = DeleteAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      oldRecord: oldRecord,
+      rawMessage: sampleMessage
+    )
+
+    let anyAction = AnyAction.delete(deleteAction)
+    XCTAssertEqual(anyAction.rawMessage.topic, "test:table")
+
+    if case let .delete(wrappedAction) = anyAction {
+      XCTAssertEqual(wrappedAction.oldRecord, oldRecord)
+    } else {
+      XCTFail("Expected delete case")
+    }
+  }
+
+  func testAnyActionEquality() {
+    let record: JSONObject = ["id": .string("123")]
+    let insertAction1 = InsertAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      rawMessage: sampleMessage
+    )
+    let insertAction2 = InsertAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      rawMessage: sampleMessage
+    )
+
+    let anyAction1 = AnyAction.insert(insertAction1)
+    let anyAction2 = AnyAction.insert(insertAction2)
+
+    XCTAssertEqual(anyAction1, anyAction2)
+  }
+
+  func testDecodeRecord() throws {
+    struct TestRecord: Codable, Equatable {
+      let id: String
+      let name: String
+      let email: String?
+    }
+
+    let record: JSONObject = [
+      "id": .string("123"),
+      "name": .string("John"),
+      "email": .string("john@example.com"),
+    ]
+
+    let insertAction = InsertAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      rawMessage: sampleMessage
+    )
+
+    let decoder = JSONDecoder()
+    let decodedRecord = try insertAction.decodeRecord(as: TestRecord.self, decoder: decoder)
+
+    let expectedRecord = TestRecord(id: "123", name: "John", email: "john@example.com")
+    XCTAssertEqual(decodedRecord, expectedRecord)
+  }
+
+  func testDecodeOldRecord() throws {
+    struct TestRecord: Codable, Equatable {
+      let id: String
+      let name: String
+    }
+
+    let record: JSONObject = ["id": .string("123"), "name": .string("John Updated")]
+    let oldRecord: JSONObject = ["id": .string("123"), "name": .string("John")]
+
+    let updateAction = UpdateAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      oldRecord: oldRecord,
+      rawMessage: sampleMessage
+    )
+
+    let decoder = JSONDecoder()
+    let decodedOldRecord = try updateAction.decodeOldRecord(as: TestRecord.self, decoder: decoder)
+
+    let expectedOldRecord = TestRecord(id: "123", name: "John")
+    XCTAssertEqual(decodedOldRecord, expectedOldRecord)
+  }
+
+  func testDecodeRecordError() {
+    struct TestRecord: Codable {
+      let id: Int  // This will cause decode error since we're passing string
+      let name: String
+    }
+
+    let record: JSONObject = [
+      "id": .string("not-a-number"),  // This should cause decoding to fail
+      "name": .string("John"),
+    ]
+
+    let insertAction = InsertAction(
+      columns: sampleColumns,
+      commitTimestamp: sampleDate,
+      record: record,
+      rawMessage: sampleMessage
+    )
+
+    let decoder = JSONDecoder()
+    XCTAssertThrowsError(try insertAction.decodeRecord(as: TestRecord.self, decoder: decoder))
+  }
+}