add tests

Author: cherylEnkidu

Firestore/Swift/Source/Helper/PipelineHelper.swift

@@ -24,6 +24,8 @@ enum Helper {
       return map(value as! [String: Sendable?])
     } else if value is [Sendable?] {
       return array(value as! [Sendable?])
+    } else if value is TimeUnit {
+      return Constant((value as! TimeUnit).rawValue)
     } else {
       return Constant(value)
     }
@@ -79,4 +81,30 @@ enum Helper {
       return Constant(value).bridge
     }
   }
+  
+  static func convertObjCToSwift(_ objValue: Sendable) -> Sendable? {
+    switch objValue {
+        case is NSNumber, is NSString:
+            return objValue
+
+        case is NSNull:
+            return nil
+
+        case let data as NSData:
+            return [UInt8](data)
+      
+    case let data as NSArray:
+      return data.map{ convertObjCToSwift($0) }
+      
+    case let data as NSDictionary:
+      var swiftDict = [String: Sendable?]()
+              for (key, value) in data {
+                swiftDict[key as! String] = convertObjCToSwift(value)
+              }
+              return swiftDict
+      
+        default:
+            return objValue
+        }
+  }
 }

Firestore/Swift/Source/SwiftAPI/Pipeline/PipelineResult.swift

@@ -27,7 +27,7 @@ public struct PipelineResult: @unchecked Sendable {
     self.bridge = bridge
     ref = self.bridge.reference
     id = self.bridge.documentID
-    data = self.bridge.data()
+    data = self.bridge.data().mapValues{ Helper.convertObjCToSwift($0)}
     createTime = self.bridge.create_time
     updateTime = self.bridge.update_time
   }
@@ -51,20 +51,20 @@ public struct PipelineResult: @unchecked Sendable {
   /// - Parameter fieldPath: The field path (e.g., "foo" or "foo.bar").
   /// - Returns: The data at the specified field location or `nil` if no such field exists.
   public func get(_ fieldName: String) -> Sendable? {
-    return bridge.get(fieldName)
+    return Helper.convertObjCToSwift(bridge.get(fieldName))
   }
 
   /// Retrieves the field specified by `fieldPath`.
   /// - Parameter fieldPath: The field path (e.g., "foo" or "foo.bar").
   /// - Returns: The data at the specified field location or `nil` if no such field exists.
   public func get(_ fieldPath: FieldPath) -> Sendable? {
-    return bridge.get(fieldPath)
+    return Helper.convertObjCToSwift(bridge.get(fieldPath))
   }
 
   /// Retrieves the field specified by `fieldPath`.
   /// - Parameter fieldPath: The field path (e.g., "foo" or "foo.bar").
   /// - Returns: The data at the specified field location or `nil` if no such field exists.
   public func get(_ field: Field) -> Sendable? {
-    return bridge.get(field.fieldName)
+    return Helper.convertObjCToSwift(bridge.get(field.fieldName))
   }
 }

Firestore/Swift/Tests/Integration/PipelineTests.swift

@@ -586,6 +586,45 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
 
     TestHelper.compare(pipelineResult: snapshot.results.first!, expected: expectedResultsMap)
   }
+  
+  
+  func testFailed() async throws {
+    let db = firestore()
+    let randomCol = collectionRef() // Ensure a unique collection for the test
+
+    // Add a dummy document to the collection.
+    // A pipeline query with .select against an empty collection might not behave as expected.
+    try await randomCol.document("dummyDoc").setData(["field": "value"])
+
+    let constantsFirst: [Selectable] = [
+      //Constant([1, 2, 3, 4, 5, 6, 7, 0] as [UInt8]).as("bytes"),
+      Constant([1, 2, 3]).as("arrayValue"), // Treated as an array of numbers
+    ]
+
+//    let constantsSecond: [Selectable] = [
+//      ArrayExpression([
+//        [11, 22, 33] as [UInt8]
+//    ]).as("array")
+//    ]
+
+    let expectedResultsMap: [String: Sendable?] = [
+//      "bytes": [1, 2, 3, 4, 5, 6, 7, 0] as [UInt8],
+//      "array": [
+//        [11, 22, 33] as [UInt8]
+//      ],
+      "arrayValue": [1, 2, 3]
+    ]
+
+    let pipeline = db.pipeline()
+      .collection(randomCol.path)
+      .limit(1)
+      .select(
+        constantsFirst
+      )
+    let snapshot = try await pipeline.execute()
+
+    TestHelper.compare(pipelineResult: snapshot.results.first!, expected: expectedResultsMap)
+  }
 
   func testAcceptsAndReturnsNil() async throws {
     let db = firestore()
@@ -595,8 +634,6 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
     // A pipeline query with .select against an empty collection might not behave as expected.
     try await randomCol.document("dummyDoc").setData(["field": "value"])
 
-    let refDate = Date(timeIntervalSince1970: 1_678_886_400)
-
     let constantsFirst: [Selectable] = [
       Constant.nil.as("nil"),
     ]
@@ -2595,4 +2632,117 @@ class PipelineIntegrationTests: FSTIntegrationTestCase {
       XCTFail("No document retrieved for testSupportsTimestampConversions")
     }
   }
+  
+  func testSupportsTimestampMath() async throws {
+      let db = firestore()
+      let randomCol = collectionRef()
+      try await randomCol.document("dummyDoc").setData(["field": "value"])
+
+      let initialTimestamp = Timestamp(seconds: 1_741_380_235, nanoseconds: 0)
+
+      let pipeline = db.pipeline()
+        .collection(randomCol.path)
+        .limit(1)
+        .select(
+          Constant(initialTimestamp).as("timestamp")
+        )
+        .select(
+          Field("timestamp").timestampAdd(.day, 10).as("plus10days"),
+          Field("timestamp").timestampAdd(.hour, 10).as("plus10hours"),
+          Field("timestamp").timestampAdd(.minute, 10).as("plus10minutes"),
+          Field("timestamp").timestampAdd(.second, 10).as("plus10seconds"),
+          Field("timestamp").timestampAdd(.microsecond, 10).as("plus10micros"),
+          Field("timestamp").timestampAdd(.millisecond, 10).as("plus10millis"),
+          Field("timestamp").timestampSub(.day, 10).as("minus10days"),
+          Field("timestamp").timestampSub(.hour, 10).as("minus10hours"),
+          Field("timestamp").timestampSub(.minute, 10).as("minus10minutes"),
+          Field("timestamp").timestampSub(.second, 10).as("minus10seconds"),
+          Field("timestamp").timestampSub(.microsecond, 10).as("minus10micros"),
+          Field("timestamp").timestampSub(.millisecond, 10).as("minus10millis")
+        )
+
+      let snapshot = try await pipeline.execute()
+
+      let expectedResults: [String: Timestamp] = [
+        "plus10days": Timestamp(seconds: 1_742_244_235, nanoseconds: 0),
+        "plus10hours": Timestamp(seconds: 1_741_416_235, nanoseconds: 0),
+        "plus10minutes": Timestamp(seconds: 1_741_380_835, nanoseconds: 0),
+        "plus10seconds": Timestamp(seconds: 1_741_380_245, nanoseconds: 0),
+        "plus10micros": Timestamp(seconds: 1_741_380_235, nanoseconds: 10_000),
+        "plus10millis": Timestamp(seconds: 1_741_380_235, nanoseconds: 10_000_000),
+        "minus10days": Timestamp(seconds: 1_740_516_235, nanoseconds: 0),
+        "minus10hours": Timestamp(seconds: 1_741_344_235, nanoseconds: 0),
+        "minus10minutes": Timestamp(seconds: 1_741_379_635, nanoseconds: 0),
+        "minus10seconds": Timestamp(seconds: 1_741_380_225, nanoseconds: 0),
+        "minus10micros": Timestamp(seconds: 1_741_380_234, nanoseconds: 999_990_000),
+        "minus10millis": Timestamp(seconds: 1_741_380_234, nanoseconds: 990_000_000)
+      ]
+
+      XCTAssertEqual(snapshot.results.count, 1, "Should retrieve one document")
+      if let resultDoc = snapshot.results.first {
+        TestHelper.compare(pipelineResult: resultDoc, expected: expectedResults)
+      } else {
+        XCTFail("No document retrieved for timestamp math test")
+      }
+    }
+  
+  func testSupportsByteLength() async throws {
+      let db = firestore()
+      let randomCol = collectionRef()
+      try await randomCol.document("dummyDoc").setData(["field": "value"])
+
+    let bytes : [UInt8] = [1, 2, 3, 4, 5, 6, 7, 0]
+
+      let pipeline = db.pipeline()
+        .collection(randomCol.path)
+        .limit(1)
+        .select(
+          Constant(bytes).as("bytes")
+        )
+        .select(
+          Field("bytes").byteLength().as("byteLength")
+        )
+
+      let snapshot = try await pipeline.execute()
+
+    let expectedResults: [String: Sendable] = [
+        "byteLength": 8
+      ]
+
+      XCTAssertEqual(snapshot.results.count, 1, "Should retrieve one document")
+      if let resultDoc = snapshot.results.first {
+        TestHelper.compare(pipelineResult: resultDoc, expected: expectedResults.mapValues { $0 as Sendable })
+      } else {
+        XCTFail("No document retrieved for byte length test")
+      }
+    }
+
+    func testSupportsNot() async throws {
+      let db = firestore()
+      let randomCol = collectionRef()
+      try await randomCol.document("dummyDoc").setData(["field": "value"])
+
+      let pipeline = db.pipeline()
+        .collection(randomCol.path)
+        .limit(1)
+        .select(Constant(true).as("trueField"))
+        .select(
+          Field("trueField"),
+          (!(Field("trueField").eq(true))).as("falseField")
+        )
+
+      let snapshot = try await pipeline.execute()
+
+      let expectedResults: [String: Bool] = [
+        "trueField": true,
+        "falseField": false
+      ]
+
+      XCTAssertEqual(snapshot.results.count, 1, "Should retrieve one document")
+      if let resultDoc = snapshot.results.first {
+        TestHelper.compare(pipelineResult: resultDoc, expected: expectedResults)
+      } else {
+        XCTFail("No document retrieved for not operator test")
+      }
+    }
 }

Firestore/Swift/Tests/TestHelper/TestHelper.swift

@@ -163,10 +163,10 @@ public enum TestHelper {
       guard let value2 = dict2[key], areEqual(value1, value2) else {
         XCTFail("""
         Dictionary value mismatch for key: '\(key)'
-        Expected value: '\(String(describing: value1))' (from dict1)
-        Actual value:   '\(String(describing: dict2[key]))' (from dict2)
-        Full dict1: \(String(describing: dict1))
-        Full dict2: \(String(describing: dict2))
+        Actual value: '\(String(describing: value1))' (from dict1)
+        Expected value:   '\(String(describing: dict2[key]))' (from dict2)
+        Full actual value: \(String(describing: dict1))
+        Full expected value: \(String(describing: dict2))
         """)
         return false
       }
@@ -182,8 +182,8 @@ public enum TestHelper {
       if !areEqual(value1, value2) {
         XCTFail("""
         Array value mismatch.
-        Expected array value: '\(String(describing: value1))'
-        Actual array value:   '\(String(describing: value2))'
+        Actual array value: '\(String(describing: value1))'
+        Expected array value:   '\(String(describing: value2))'
         """)
         return false
       }