@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBSharedUtilsNullSentinelTests.m

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBSharedUtils.h"
+
+@interface RNFBSharedUtilsNullSentinelTests : XCTestCase
+@end
+
+@implementation RNFBSharedUtilsNullSentinelTests
+
+- (void)testFacadeForwardsSentinelAndNonContainer {
+  NSDictionary *sentinel = @{@"__rnfbNull" : @YES};
+  XCTAssertTrue([[RNFBSharedUtils decodeNullSentinels:sentinel] isKindOfClass:[NSNull class]]);
+
+  NSNumber *number = @42;
+  XCTAssertTrue([RNFBSharedUtils decodeNullSentinels:number] == number);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBSharedUtilsPromiseRejectionFacadeTests.m

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBSharedUtils.h"
+
+@interface RNFBSharedUtilsPromiseRejectionFacadeTests : XCTestCase
+@end
+
+@implementation RNFBSharedUtilsPromiseRejectionFacadeTests
+
+- (void)testFacadeExceptionPath {
+  NSException *exception = [NSException exceptionWithName:@"FacadeException"
+                                                   reason:@"facade boom"
+                                                 userInfo:nil];
+
+  __block NSString *capturedCode = nil;
+  __block NSString *capturedMessage = nil;
+  __block NSError *capturedError = nil;
+
+  [RNFBSharedUtils
+      rejectPromiseWithExceptionDict:^(NSString *code, NSString *message, NSError *error) {
+        capturedCode = code;
+        capturedMessage = message;
+        capturedError = error;
+      }
+                           exception:exception];
+
+  XCTAssertEqualObjects(capturedCode, @"FacadeException");
+  XCTAssertEqualObjects(capturedMessage, @"facade boom");
+  XCTAssertEqualObjects(capturedError.domain, @"RNFBErrorDomain");
+  XCTAssertEqual(capturedError.code, 666);
+  XCTAssertEqualObjects(capturedError.userInfo[@"fatal"], @YES);
+  XCTAssertEqualObjects(capturedError.userInfo[@"code"], @"unknown");
+  XCTAssertEqualObjects(capturedError.userInfo[@"message"], @"facade boom");
+  XCTAssertEqualObjects(capturedError.userInfo[@"nativeErrorCode"], @"FacadeException");
+  XCTAssertEqualObjects(capturedError.userInfo[@"nativeErrorMessage"], @"facade boom");
+}
+
+- (void)testFacadeNSErrorPath {
+  NSError *source = [NSError errorWithDomain:@"SourceDomain"
+                                        code:7
+                                    userInfo:@{NSLocalizedDescriptionKey : @"ns fail"}];
+
+  __block NSString *capturedCode = nil;
+  __block NSString *capturedMessage = nil;
+  __block NSError *capturedError = nil;
+
+  [RNFBSharedUtils
+      rejectPromiseWithNSError:^(NSString *code, NSString *message, NSError *error) {
+        capturedCode = code;
+        capturedMessage = message;
+        capturedError = error;
+      }
+                         error:source];
+
+  XCTAssertEqualObjects(capturedCode, @"unknown");
+  XCTAssertEqualObjects(capturedMessage, @"ns fail");
+  XCTAssertEqualObjects(capturedError.domain, @"RNFBErrorDomain");
+  XCTAssertEqual(capturedError.code, 666);
+  XCTAssertEqualObjects(capturedError.userInfo[@"fatal"], @NO);
+  XCTAssertEqualObjects(capturedError.userInfo[@"nativeErrorCode"], @7);
+  XCTAssertEqualObjects(capturedError.userInfo[@"nativeErrorMessage"], @"ns fail");
+}
+
+- (void)testFacadeUserInfoPath {
+  NSMutableDictionary *userInfo = [@{
+    @"code" : @"storage/unknown",
+    @"message" : @"user info reject",
+  } mutableCopy];
+
+  __block NSString *capturedCode = nil;
+  __block NSString *capturedMessage = nil;
+  __block NSError *capturedError = nil;
+
+  [RNFBSharedUtils
+      rejectPromiseWithUserInfo:^(NSString *code, NSString *message, NSError *error) {
+        capturedCode = code;
+        capturedMessage = message;
+        capturedError = error;
+      }
+                       userInfo:userInfo];
+
+  XCTAssertEqualObjects(capturedCode, @"storage/unknown");
+  XCTAssertEqualObjects(capturedMessage, @"user info reject");
+  XCTAssertEqualObjects(capturedError.domain, @"RNFBErrorDomain");
+  XCTAssertEqual(capturedError.code, 666);
+  XCTAssertEqualObjects(capturedError.userInfo[@"code"], @"storage/unknown");
+  XCTAssertEqualObjects(capturedError.userInfo[@"message"], @"user info reject");
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBSharedUtilsPromiseRejectionTests.swift

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 Foundation
+import XCTest
+
+final class RNFBSharedUtilsPromiseRejectionTests: XCTestCase {
+  private let expectedDomain = "RNFBErrorDomain"
+  private let expectedCode = 666
+
+  func testExceptionPathRejectArgsAndUserInfo() {
+    let exception = NSException(
+      name: NSExceptionName("SomeException"),
+      reason: "boom reason",
+      userInfo: nil
+    )
+
+    var capturedCode: String?
+    var capturedMessage: String?
+    var capturedError: NSError?
+
+    RNFBSharedUtilsPromiseRejection.rejectPromise(withException: { code, message, error in
+      capturedCode = code
+      capturedMessage = message
+      capturedError = error as NSError?
+    }, exception: exception)
+
+    XCTAssertEqual(capturedCode, "SomeException")
+    XCTAssertEqual(capturedMessage, "boom reason")
+    XCTAssertEqual(capturedError?.domain, expectedDomain)
+    XCTAssertEqual(capturedError?.code, expectedCode)
+
+    let userInfo = capturedError?.userInfo ?? [:]
+    XCTAssertEqual(userInfo["fatal"] as? Bool, true)
+    XCTAssertEqual(userInfo["code"] as? String, "unknown")
+    XCTAssertEqual(userInfo["message"] as? String, "boom reason")
+    XCTAssertEqual(userInfo["nativeErrorCode"] as? String, "SomeException")
+    XCTAssertEqual(userInfo["nativeErrorMessage"] as? String, "boom reason")
+  }
+
+  func testExceptionPathNilReasonOmitsMessageKeys() {
+    let exception = NSException(
+      name: NSExceptionName("NilReason"),
+      reason: nil,
+      userInfo: nil
+    )
+
+    var capturedMessage: String?
+    var capturedError: NSError?
+
+    RNFBSharedUtilsPromiseRejection.rejectPromise(withException: { _, message, error in
+      capturedMessage = message
+      capturedError = error as NSError?
+    }, exception: exception)
+
+    XCTAssertNil(capturedMessage)
+    let userInfo = capturedError?.userInfo ?? [:]
+    XCTAssertNil(userInfo["message"])
+    XCTAssertNil(userInfo["nativeErrorMessage"])
+    XCTAssertEqual(userInfo["fatal"] as? Bool, true)
+    XCTAssertEqual(userInfo["code"] as? String, "unknown")
+    XCTAssertEqual(userInfo["nativeErrorCode"] as? String, "NilReason")
+  }
+
+  func testNSErrorPathRejectArgsAndUserInfo() {
+    let source = NSError(
+      domain: "SourceDomain",
+      code: 42,
+      userInfo: [NSLocalizedDescriptionKey: "localized fail"]
+    )
+
+    var capturedCode: String?
+    var capturedMessage: String?
+    var capturedError: NSError?
+
+    RNFBSharedUtilsPromiseRejection.rejectPromise(withNSError: { code, message, error in
+      capturedCode = code
+      capturedMessage = message
+      capturedError = error as NSError?
+    }, error: source)
+
+    XCTAssertEqual(capturedCode, "unknown")
+    XCTAssertEqual(capturedMessage, "localized fail")
+    XCTAssertEqual(capturedError?.domain, expectedDomain)
+    XCTAssertEqual(capturedError?.code, expectedCode)
+
+    let userInfo = capturedError?.userInfo ?? [:]
+    XCTAssertEqual(userInfo["fatal"] as? Bool, false)
+    XCTAssertEqual(userInfo["code"] as? String, "unknown")
+    XCTAssertEqual(userInfo["message"] as? String, "localized fail")
+    XCTAssertEqual(userInfo["nativeErrorCode"] as? NSNumber, NSNumber(value: 42))
+    XCTAssertEqual(userInfo["nativeErrorMessage"] as? String, "localized fail")
+  }
+
+  func testUserInfoPathRejectArgsAndError() {
+    let userInfo: NSMutableDictionary = [
+      "code": "auth/invalid",
+      "message": "bad creds",
+      "extra": "kept",
+    ]
+
+    var capturedCode: String?
+    var capturedMessage: String?
+    var capturedError: NSError?
+
+    RNFBSharedUtilsPromiseRejection.rejectPromise(withUserInfo: { code, message, error in
+      capturedCode = code
+      capturedMessage = message
+      capturedError = error as NSError?
+    }, userInfo: userInfo)
+
+    XCTAssertEqual(capturedCode, "auth/invalid")
+    XCTAssertEqual(capturedMessage, "bad creds")
+    XCTAssertEqual(capturedError?.domain, expectedDomain)
+    XCTAssertEqual(capturedError?.code, expectedCode)
+    XCTAssertEqual(capturedError?.userInfo["code"] as? String, "auth/invalid")
+    XCTAssertEqual(capturedError?.userInfo["message"] as? String, "bad creds")
+    XCTAssertEqual(capturedError?.userInfo["extra"] as? String, "kept")
+  }
+}

package/ios/RNFBAppUnitTests/RNFBUtilsHelpersTests.swift

@@ -0,0 +1,144 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 Foundation
+import XCTest
+
+final class RNFBUtilsHelpersTests: XCTestCase {
+  func testPathForDirectoryReturnsSearchPathFirstObject() {
+    let caches = RNFBUtilsHelpers.path(
+      forDirectory: Int32(FileManager.SearchPathDirectory.cachesDirectory.rawValue)
+    )
+    let expected = NSSearchPathForDirectoriesInDomains(.cachesDirectory, .userDomainMask, true)
+      .first
+    XCTAssertEqual(caches, expected)
+    XCTAssertNotNil(caches)
+  }
+
+  func testUtilsConstantsDictionaryIncludesRequiredKeys() {
+    let constants = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/App.app",
+      appVersion: "1.2.3",
+      pathProvider: { directory in "path-\(directory)" },
+      temporaryDirectory: "/tmp/rnfb"
+    )
+
+    XCTAssertEqual(constants["isRunningInTestLab"] as? Bool, false)
+    XCTAssertEqual(constants["MAIN_BUNDLE"] as? String, "/App.app")
+    XCTAssertEqual(
+      constants["CACHES_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.cachesDirectory.rawValue)"
+    )
+    XCTAssertEqual(
+      constants["DOCUMENT_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.documentDirectory.rawValue)"
+    )
+    XCTAssertEqual(
+      constants["PICTURES_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.picturesDirectory.rawValue)"
+    )
+    XCTAssertEqual(
+      constants["MOVIES_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.moviesDirectory.rawValue)"
+    )
+    XCTAssertEqual(constants["TEMP_DIRECTORY"] as? String, "/tmp/rnfb")
+    XCTAssertEqual(
+      constants["LIBRARY_DIRECTORY"] as? String,
+      "path-\(FileManager.SearchPathDirectory.libraryDirectory.rawValue)"
+    )
+    XCTAssertEqual(constants["appVersion"] as? String, "1.2.3")
+  }
+
+  func testUtilsConstantsDictionaryOmitsAppVersionWhenMissingEmptyOrNonString() {
+    let pathProvider: RNFBUtilsPathProvider = { _ in "/p" }
+
+    let missing = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/b",
+      appVersion: nil,
+      pathProvider: pathProvider,
+      temporaryDirectory: "/t"
+    )
+    XCTAssertNil(missing["appVersion"])
+
+    let empty = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/b",
+      appVersion: "",
+      pathProvider: pathProvider,
+      temporaryDirectory: "/t"
+    )
+    XCTAssertNil(empty["appVersion"])
+
+    let nonString = RNFBUtilsHelpers.utilsConstantsDictionary(
+      bundlePath: "/b",
+      appVersion: NSNumber(value: 42),
+      pathProvider: pathProvider,
+      temporaryDirectory: "/t"
+    )
+    XCTAssertNil(nonString["appVersion"])
+  }
+
+  func testUtilsConstantsDictionaryDefaultUsesMainBundle() {
+    let constants = RNFBUtilsHelpers.utilsConstantsDictionary()
+    XCTAssertEqual(constants["MAIN_BUNDLE"] as? String, Bundle.main.bundlePath)
+    XCTAssertEqual(constants["isRunningInTestLab"] as? Bool, false)
+    XCTAssertNotNil(constants["CACHES_DIRECTORY"])
+    XCTAssertNotNil(constants["TEMP_DIRECTORY"])
+  }
+
+  func testIsRemoteAssetPrefixChecks() {
+    XCTAssertTrue(RNFBUtilsHelpers.isRemoteAsset("assets-library://asset/foo"))
+    XCTAssertTrue(RNFBUtilsHelpers.isRemoteAsset("ph://LOCAL-ID"))
+    XCTAssertFalse(RNFBUtilsHelpers.isRemoteAsset("file:///tmp/x.jpg"))
+    XCTAssertFalse(RNFBUtilsHelpers.isRemoteAsset(""))
+    XCTAssertFalse(RNFBUtilsHelpers.isRemoteAsset(nil))
+  }
+
+  func testUnusedIsHeicCaseInsensitiveAndNilMessaging() {
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic("photo.heic"))
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic("photo.HEIC"))
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic("photo.Heic"))
+    XCTAssertFalse(RNFBUtilsHelpers.unusedIsHeic("photo.jpg"))
+    XCTAssertFalse(RNFBUtilsHelpers.unusedIsHeic("heic"))
+    // Pre-port ObjC nil messaging → YES
+    XCTAssertTrue(RNFBUtilsHelpers.unusedIsHeic(nil))
+  }
+
+  func testValueForKeyFromQueryItemsUsesNamePredicateAndFirstObject() {
+    let items = [
+      URLQueryItem(name: "other", value: "a"),
+      URLQueryItem(name: "id", value: "first-id"),
+      URLQueryItem(name: "id", value: "second-id"),
+    ]
+
+    XCTAssertEqual(
+      RNFBUtilsHelpers.value(forKey: "id", fromQueryItems: items),
+      "first-id"
+    )
+    XCTAssertEqual(
+      RNFBUtilsHelpers.value(forKey: "other", fromQueryItems: items),
+      "a"
+    )
+    XCTAssertNil(RNFBUtilsHelpers.value(forKey: "missing", fromQueryItems: items))
+    XCTAssertNil(RNFBUtilsHelpers.value(forKey: "id", fromQueryItems: nil))
+    XCTAssertNil(RNFBUtilsHelpers.value(forKey: "id", fromQueryItems: []))
+    XCTAssertNil(
+      RNFBUtilsHelpers.value(
+        forKey: "id",
+        fromQueryItems: [URLQueryItem(name: "id", value: nil)]
+      )
+    )
+  }
+}

package/ios/RNFBAppUnitTests/RNFBUtilsModuleFacadeTests.m

@@ -0,0 +1,72 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBUtilsModule.h"
+
+@interface RNFBUtilsModuleFacadeTests : XCTestCase
+@end
+
+@implementation RNFBUtilsModuleFacadeTests
+
+- (void)testFacadePathForDirectoryMatchesSearchPath {
+  NSString *path = [RNFBUtilsHelpers pathForDirectory:(int)NSCachesDirectory];
+  NSString *expected =
+      [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
+  XCTAssertEqualObjects(path, expected);
+}
+
+- (void)testFacadeUtilsConstantsDictionaryKeys {
+  NSDictionary *constants = [RNFBUtilsHelpers
+      utilsConstantsDictionaryWithBundlePath:@"/Bundle.app"
+                                  appVersion:@"9.9.9"
+                                pathProvider:^NSString *(int directory) {
+                                  return [NSString stringWithFormat:@"dir-%d", directory];
+                                }
+                          temporaryDirectory:@"/tmp/facade"];
+
+  XCTAssertEqualObjects(constants[@"isRunningInTestLab"], @NO);
+  XCTAssertEqualObjects(constants[@"MAIN_BUNDLE"], @"/Bundle.app");
+  XCTAssertEqualObjects(constants[@"TEMP_DIRECTORY"], @"/tmp/facade");
+  XCTAssertEqualObjects(constants[@"appVersion"], @"9.9.9");
+  XCTAssertEqualObjects(constants[@"CACHES_DIRECTORY"],
+                        ([NSString stringWithFormat:@"dir-%d", (int)NSCachesDirectory]));
+}
+
+- (void)testFacadeIsRemoteAsset {
+  XCTAssertTrue([RNFBUtilsModule isRemoteAsset:@"assets-library://x"]);
+  XCTAssertTrue([RNFBUtilsModule isRemoteAsset:@"ph://y"]);
+  XCTAssertFalse([RNFBUtilsModule isRemoteAsset:@"/local/file.jpg"]);
+}
+
+- (void)testFacadeUnusedIsHeic {
+  XCTAssertTrue([RNFBUtilsModule unused_isHeic:@"a.HEIC"]);
+  XCTAssertFalse([RNFBUtilsModule unused_isHeic:@"a.png"]);
+}
+
+- (void)testFacadeValueForKeyFromQueryItems {
+  NSArray *items = @[
+    [NSURLQueryItem queryItemWithName:@"id" value:@"asset-1"],
+    [NSURLQueryItem queryItemWithName:@"w" value:@"100"],
+  ];
+  XCTAssertEqualObjects([RNFBUtilsModule valueForKey:@"id" fromQueryItems:items], @"asset-1");
+  XCTAssertEqualObjects([RNFBUtilsModule valueForKey:@"w" fromQueryItems:items], @"100");
+  XCTAssertNil([RNFBUtilsModule valueForKey:@"missing" fromQueryItems:items]);
+}
+
+@end