Tests WIP

More tests WIP

Tests WIP. This one seems to work.

Migrate to Swift Testing

Fix handing tests

Fix tests

Author: peterfriese

Firestore/Swift/Tests/Unit/AsyncAwait/AsyncSequenceTests.swift

@@ -1,178 +1,247 @@
-/*
- * Copyright 2025 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import Testing
+import FirebaseCore
 @testable import FirebaseFirestore
-import XCTest
-
-// MARK: - Mock Objects for Testing
-
-private class MockListenerRegistration: ListenerRegistration {
-  var isRemoved = false
-  func remove() {
-    isRemoved = true
-  }
-}
 
-private typealias SnapshotListener = (QuerySnapshot?, Error?) -> Void
-private typealias DocumentSnapshotListener = (DocumentSnapshot?, Error?) -> Void
+private final class AssociationKey: Sendable {}
 
-private class MockQuery: Query {
-  var capturedListener: SnapshotListener?
-  let mockListenerRegistration = MockListenerRegistration()
+/// A wrapper to safely pass a non-Sendable closure to a Sendable context.
+///
+/// This is safe in this specific test because the listener closure originates from
+/// an `AsyncStream` continuation, which is guaranteed to be thread-safe.
+private final class SendableListenerWrapper: @unchecked Sendable {
+  let listener: (QuerySnapshot?, Error?) -> Void
 
-  override func addSnapshotListener(_ listener: @escaping SnapshotListener)
-    -> ListenerRegistration {
-    capturedListener = listener
-    return mockListenerRegistration
-  }
-
-  override func addSnapshotListener(includeMetadataChanges: Bool,
-                                    listener: @escaping SnapshotListener) -> ListenerRegistration {
-    capturedListener = listener
-    return mockListenerRegistration
+  init(_ listener: @escaping (QuerySnapshot?, Error?) -> Void) {
+    self.listener = listener
   }
 }
 
-private class MockDocumentReference: DocumentReference {
-  var capturedListener: DocumentSnapshotListener?
-  let mockListenerRegistration = MockListenerRegistration()
+@Suite("Query AsyncSequence Tests")
+struct AsyncSequenceTests {
+  fileprivate static let associationKey = AssociationKey()
+
+  // This static property handles the one-time setup for FirebaseApp.
+  @MainActor
+  private static let firebaseApp: FirebaseApp = {
+    let options = FirebaseOptions(googleAppID: "1:1234567890:ios:abcdef",
+                                  gcmSenderID: "1234s567890")
+    options.projectID = "Firestore-Testing-Project"
+    FirebaseApp.configure(options: options)
+    return FirebaseApp.app()!
+  }()
+
+  // Swizzling is managed by this helper struct using a simple RAII pattern.
+  // The swizzling is active for the lifetime of the struct instance.
+  private struct Swizzler: ~Copyable {
+    init() {
+      Self.swizzle(
+        Query.self,
+        originalSelector: #selector(Query.addSnapshotListener(includeMetadataChanges:listener:)),
+        swizzledSelector: #selector(Query.swizzled_addSnapshotListener(includeMetadataChanges:listener:))
+      )
+    }
 
-  override func addSnapshotListener(_ listener: @escaping DocumentSnapshotListener)
-    -> ListenerRegistration {
-    capturedListener = listener
-    return mockListenerRegistration
-  }
+    deinit {
+      Self.swizzle(
+        Query.self,
+        originalSelector: #selector(Query.swizzled_addSnapshotListener(includeMetadataChanges:listener:)),
+        swizzledSelector: #selector(Query.addSnapshotListener(includeMetadataChanges:listener:))
+      )
+    }
 
-  override func addSnapshotListener(includeMetadataChanges: Bool,
-                                    listener: @escaping DocumentSnapshotListener)
-    -> ListenerRegistration {
-    capturedListener = listener
-    return mockListenerRegistration
+    private static func swizzle(_ cls: AnyClass, originalSelector: Selector, swizzledSelector: Selector) {
+      guard let originalMethod = class_getInstanceMethod(cls, originalSelector),
+            let swizzledMethod = class_getInstanceMethod(cls, swizzledSelector) else {
+        #expect(false, "Failed to get methods for swizzling")
+        return
+      }
+      method_exchangeImplementations(originalMethod, swizzledMethod)
+    }
   }
-}
-
-// MARK: - AsyncSequenceTests
 
-@available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *)
-class AsyncSequenceTests: XCTestCase {
-  func testQuerySnapshotsYieldsValues() async throws {
-    let mockQuery = MockQuery()
-    let expectation = XCTestExpectation(description: "Received snapshot")
+  @available(iOS 18.0, *)
+  @MainActor
+  @Test("Stream handles cancellation correctly")
+  func test_snapshotStream_handlesCancellationCorrectly() async throws {
+    // Ensure Firebase is configured before swizzling, as interacting with the
+    // Query class can trigger SDK initialization that requires a configured app.
+    let app = Self.firebaseApp
+    let swizzler = Swizzler()
+    defer { withExtendedLifetime(swizzler) {} }
+
+    let actor = TestStateActor()
+    let query = Firestore.firestore(app: app)
+      .collection("test-\(UUID().uuidString)")
+    let key = Unmanaged.passUnretained(Self.associationKey).toOpaque()
+    objc_setAssociatedObject(query, key, actor, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
 
     let task = Task {
-      for try await _ in mockQuery.snapshots {
-        expectation.fulfill()
-        break // Exit after first result
+      for try await _ in query.snapshots {
+        // Do nothing
       }
     }
 
-    // Ensure the listener has been set up
-    XCTAssertNotNil(mockQuery.capturedListener)
-
-    // Simulate a snapshot event
-    mockQuery.capturedListener?(QuerySnapshot(), nil)
-
-    await fulfillment(of: [expectation], timeout: 1.0)
+    await actor.waitForListenerSetup()
     task.cancel()
+    await actor.waitForListenerRemoval()
   }
 
-  func testQuerySnapshotsThrowsErrors() async throws {
-    let mockQuery = MockQuery()
-    let expectedError = NSError(domain: "TestError", code: 123, userInfo: nil)
-    var receivedError: Error?
+  @available(iOS 18.0, *)
+  @MainActor
+  @Test("Stream propagates errors")
+  func test_snapshotStream_propagatesErrors() async throws {
+    // Ensure Firebase is configured before swizzling, as interacting with the
+    // Query class can trigger SDK initialization that requires a configured app.
+    let app = Self.firebaseApp
+    let swizzler = Swizzler()
+    defer { withExtendedLifetime(swizzler) {} }
+
+    let actor = TestStateActor()
+    let query = Firestore.firestore(app: app)
+      .collection("test-\(UUID().uuidString)")
+    let key = Unmanaged.passUnretained(Self.associationKey).toOpaque()
+    objc_setAssociatedObject(query, key, actor, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
 
     let task = Task {
       do {
-        for try await _ in mockQuery.snapshots {
-          XCTFail("Should not have received a value.")
-        }
+        for try await _ in query.snapshots {}
+        throw "Stream did not throw"
       } catch {
-        receivedError = error
+        return error
       }
     }
 
-    // Ensure the listener has been set up
-    XCTAssertNotNil(mockQuery.capturedListener)
-
-    // Simulate an error event
-    mockQuery.capturedListener?(nil, expectedError)
+    await actor.waitForListenerSetup()
+    await actor.invokeListener(withSnapshot: nil, error: TestError.mockError)
 
-    // Allow the task to process the error
-    try await Task.sleep(nanoseconds: 100_000_000)
-
-    XCTAssertNotNil(receivedError)
-    XCTAssertEqual((receivedError as NSError?)?.domain, expectedError.domain)
-    XCTAssertEqual((receivedError as NSError?)?.code, expectedError.code)
+    let caughtError = await task.value
+    #expect(caughtError as? TestError == .mockError)
     task.cancel()
   }
 
-  func testQuerySnapshotsCancellationRemovesListener() async throws {
-    let mockQuery = MockQuery()
+  @available(iOS 18.0, *)
+  @MainActor
+  @Test("Stream handles (nil, nil) events gracefully")
+  func test_snapshotStream_handlesNilSnapshotAndNilErrorGracefully() async throws {
+    // Ensure Firebase is configured before swizzling, as interacting with the
+    // Query class can trigger SDK initialization that requires a configured app.
+    let app = Self.firebaseApp
+    let swizzler = Swizzler()
+    defer { withExtendedLifetime(swizzler) {} }
+
+    let actor = TestStateActor()
+    let query = Firestore.firestore(app: app)
+      .collection("test-\(UUID().uuidString)")
+    let key = Unmanaged.passUnretained(Self.associationKey).toOpaque()
+    objc_setAssociatedObject(query, key, actor, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
 
     let task = Task {
-      for try await _ in mockQuery.snapshots {
-        XCTFail("Should not receive any values as the task is cancelled immediately.")
+      for try await _ in query.snapshots {
+        #expect(false, "The stream should not have produced any values.")
       }
     }
 
-    // Ensure the listener was attached before we cancel
-    XCTAssertNotNil(mockQuery.capturedListener)
-    XCTAssertFalse(mockQuery.mockListenerRegistration.isRemoved)
-
+    await actor.waitForListenerSetup()
+    await actor.invokeListener(withSnapshot: nil, error: nil)
     task.cancel()
+    await actor.waitForListenerRemoval()
 
-    // Allow time for the cancellation handler to execute
-    try await Task.sleep(nanoseconds: 100_000_000)
-
-    XCTAssertTrue(mockQuery.mockListenerRegistration.isRemoved)
+    // Awaiting the task will rethrow a CancellationError, which is expected
+    // and handled by the `throws` on the test function.
+    try await task.value
   }
+}
+
+private enum TestError: Error, Equatable {
+  case mockError
+}
 
-  func testDocumentReferenceSnapshotsYieldsValues() async throws {
-    let mockDocRef = MockDocumentReference()
-    let expectation = XCTestExpectation(description: "Received document snapshot")
+// We can finally use a real actor, which is much safer and cleaner.
+private actor TestStateActor {
+  private var capturedListenerWrapper: SendableListenerWrapper?
+  private var listenerSetupContinuation: CheckedContinuation<Void, Never>?
+  private var listenerRemovedContinuation: CheckedContinuation<Void, Never>?
 
-    let task = Task {
-      for try await _ in mockDocRef.snapshots {
-        expectation.fulfill()
-        break
-      }
+  private var hasSetUpListener = false
+  private var hasRemovedListener = false
+
+  func waitForListenerSetup() async {
+    if hasSetUpListener { return }
+    await withCheckedContinuation { continuation in
+      self.listenerSetupContinuation = continuation
     }
+  }
 
-    XCTAssertNotNil(mockDocRef.capturedListener)
-    mockDocRef.capturedListener?(DocumentSnapshot(), nil)
+  func waitForListenerRemoval() async {
+    if hasRemovedListener { return }
+    await withCheckedContinuation { continuation in
+      self.listenerRemovedContinuation = continuation
+    }
+  }
 
-    await fulfillment(of: [expectation], timeout: 1.0)
-    task.cancel()
+  func listenerDidSetUp(wrapper: SendableListenerWrapper) {
+    capturedListenerWrapper = wrapper
+    hasSetUpListener = true
+    listenerSetupContinuation?.resume()
+    listenerSetupContinuation = nil
   }
 
-  func testDocumentReferenceSnapshotsCancellationRemovesListener() async throws {
-    let mockDocRef = MockDocumentReference()
+  func listenerDidRemove() {
+    hasRemovedListener = true
+    listenerRemovedContinuation?.resume()
+    listenerRemovedContinuation = nil
+  }
 
-    let task = Task {
-      for try await _ in mockDocRef.snapshots {
-        XCTFail("Should not receive values.")
-      }
-    }
+  func invokeListener(withSnapshot snapshot: QuerySnapshot?, error: Error?) {
+    capturedListenerWrapper?.listener(snapshot, error)
+  }
+}
 
-    XCTAssertNotNil(mockDocRef.capturedListener)
-    XCTAssertFalse(mockDocRef.mockListenerRegistration.isRemoved)
+private final class MockListenerRegistration: NSObject, ListenerRegistration {
+  private var actor: TestStateActor
 
-    task.cancel()
-    try await Task.sleep(nanoseconds: 100_000_000)
+  init(actor: TestStateActor) {
+    self.actor = actor
+  }
 
-    XCTAssertTrue(mockDocRef.mockListenerRegistration.isRemoved)
+  func remove() {
+    let actor = self.actor
+    Task {
+      await actor.listenerDidRemove()
+    }
   }
 }
+
+extension Query {
+  @objc func swizzled_addSnapshotListener(
+    includeMetadataChanges: Bool,
+    listener: @escaping (QuerySnapshot?, Error?) -> Void
+  ) -> ListenerRegistration {
+    let key = Unmanaged.passUnretained(AsyncSequenceTests.associationKey).toOpaque()
+    let actor = objc_getAssociatedObject(self, key) as! TestStateActor
+    let registration = MockListenerRegistration(actor: actor)
+    let wrapper = SendableListenerWrapper(listener)
+    Task {
+        await actor.listenerDidSetUp(wrapper: wrapper)
+    }
+    return registration
+  }
+}
+
+extension String: Error {}

Package.swift

@@ -1552,6 +1552,18 @@ func firestoreTargets() -> [Target] {
           .swiftLanguageMode(SwiftLanguageMode.v5),
         ]
       ),
+      .testTarget(
+        name: "FirebaseFirestoreTests",
+        dependencies: [
+          "Firebase",
+          "FirebaseCore",
+          "FirebaseFirestoreTarget"
+        ],
+        path: "Firestore/Swift/Tests/Unit",
+        cSettings: [
+          .headerSearchPath("../../../"),
+        ]
+      ),
     ]
   }