@react-native-firebase/app 26.4.0 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBSharedUtilsFIRAppTests.swift

@@ -0,0 +1,173 @@
+/**
+ * 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
+
+private final class StubFIROptions: NSObject, RNFBFIROptionsProviding {
+  var apiKey: String?
+  var googleAppID: String?
+  var projectID: String?
+  var databaseURL: String?
+  var storageBucket: String?
+  var gcmSenderID: String?
+  var clientID: String?
+}
+
+private final class StubFIRApp: NSObject, RNFBFIRAppProviding {
+  var name: String
+  var options: RNFBFIROptionsProviding
+  var dataCollectionEnabled = false
+
+  init(name: String, options: RNFBFIROptionsProviding) {
+    self.name = name
+    self.options = options
+  }
+
+  func isDataCollectionDefaultEnabled() -> Bool {
+    dataCollectionEnabled
+  }
+}
+
+private final class StubCustomDomainProvider: NSObject, RNFBCustomDomainProviding {
+  var domains: [String: String] = [:]
+  var lastRequestedName: String?
+
+  func getCustomDomain(_ appName: String) -> String? {
+    lastRequestedName = appName
+    return domains[appName]
+  }
+}
+
+private final class RecordingEventSender: NSObject, RNFBJSEventSending {
+  var lastName: String?
+  var lastBody: Any?
+
+  func sendEvent(name: String, body: Any?) {
+    lastName = name
+    lastBody = body
+  }
+}
+
+final class RNFBSharedUtilsFIRAppTests: XCTestCase {
+  private func fullyPopulatedOptions() -> StubFIROptions {
+    let options = StubFIROptions()
+    options.apiKey = "api-key"
+    options.googleAppID = "app-id"
+    options.projectID = "project-id"
+    options.databaseURL = "https://example.firebaseio.com"
+    options.storageBucket = "example.appspot.com"
+    options.gcmSenderID = "sender-id"
+    options.clientID = "client-id"
+    return options
+  }
+
+  func testDefaultAppNameMapsToDisplayName() {
+    let app = StubFIRApp(name: "__FIRAPP_DEFAULT", options: fullyPopulatedOptions())
+    app.dataCollectionEnabled = true
+    let domains = StubCustomDomainProvider()
+
+    let result = RNFBSharedUtilsFIRApp.firAppToDictionary(app, customDomainProvider: domains)
+    let appConfig = result["appConfig"] as? NSDictionary
+
+    XCTAssertEqual(appConfig?["name"] as? String, "[DEFAULT]")
+    XCTAssertEqual(appConfig?["automaticDataCollectionEnabled"] as? Bool, true)
+    XCTAssertEqual(domains.lastRequestedName, "[DEFAULT]")
+  }
+
+  func testNamedAppPreservesName() {
+    let app = StubFIRApp(name: "secondary", options: fullyPopulatedOptions())
+    let domains = StubCustomDomainProvider()
+
+    let result = RNFBSharedUtilsFIRApp.firAppToDictionary(app, customDomainProvider: domains)
+    let appConfig = result["appConfig"] as? NSDictionary
+
+    XCTAssertEqual(appConfig?["name"] as? String, "secondary")
+    XCTAssertEqual(domains.lastRequestedName, "secondary")
+  }
+
+  func testOptionsFieldMapping() {
+    let app = StubFIRApp(name: "secondary", options: fullyPopulatedOptions())
+    let domains = StubCustomDomainProvider()
+
+    let result = RNFBSharedUtilsFIRApp.firAppToDictionary(app, customDomainProvider: domains)
+    let options = result["options"] as? NSDictionary
+
+    XCTAssertEqual(options?["apiKey"] as? String, "api-key")
+    XCTAssertEqual(options?["appId"] as? String, "app-id")
+    XCTAssertEqual(options?["projectId"] as? String, "project-id")
+    XCTAssertEqual(options?["databaseURL"] as? String, "https://example.firebaseio.com")
+    XCTAssertEqual(options?["storageBucket"] as? String, "example.appspot.com")
+    XCTAssertEqual(options?["messagingSenderId"] as? String, "sender-id")
+    XCTAssertEqual(options?["clientId"] as? String, "client-id")
+    XCTAssertNil(options?["authDomain"])
+  }
+
+  func testAuthDomainPresentWhenProviderReturnsValue() {
+    let app = StubFIRApp(name: "secondary", options: fullyPopulatedOptions())
+    let domains = StubCustomDomainProvider()
+    domains.domains["secondary"] = "custom.example.com"
+
+    let result = RNFBSharedUtilsFIRApp.firAppToDictionary(app, customDomainProvider: domains)
+    let options = result["options"] as? NSDictionary
+
+    XCTAssertEqual(options?["authDomain"] as? String, "custom.example.com")
+  }
+
+  func testAuthDomainAbsentWhenProviderReturnsNil() {
+    let app = StubFIRApp(name: "__FIRAPP_DEFAULT", options: fullyPopulatedOptions())
+    let domains = StubCustomDomainProvider()
+
+    let result = RNFBSharedUtilsFIRApp.firAppToDictionary(app, customDomainProvider: domains)
+    let options = result["options"] as? NSDictionary
+
+    XCTAssertNil(options?["authDomain"])
+    XCTAssertEqual(domains.lastRequestedName, "[DEFAULT]")
+  }
+
+  func testSendJSEventInjectsAppNameAndForwards() {
+    let app = StubFIRApp(name: "__FIRAPP_DEFAULT", options: fullyPopulatedOptions())
+    let sender = RecordingEventSender()
+    let body: NSDictionary = ["foo": "bar"]
+
+    RNFBSharedUtilsFIRApp.sendJSEvent(
+      forApp: app,
+      name: "app_event",
+      body: body,
+      eventSender: sender
+    )
+
+    XCTAssertEqual(sender.lastName, "app_event")
+    let forwarded = sender.lastBody as? NSDictionary
+    XCTAssertEqual(forwarded?["foo"] as? String, "bar")
+    XCTAssertEqual(forwarded?["appName"] as? String, "[DEFAULT]")
+  }
+
+  func testSendJSEventPreservesNamedAppName() {
+    let app = StubFIRApp(name: "secondary", options: fullyPopulatedOptions())
+    let sender = RecordingEventSender()
+
+    RNFBSharedUtilsFIRApp.sendJSEvent(
+      forApp: app,
+      name: "named_event",
+      body: [:],
+      eventSender: sender
+    )
+
+    let forwarded = sender.lastBody as? NSDictionary
+    XCTAssertEqual(forwarded?["appName"] as? String, "secondary")
+  }
+}

package/ios/RNFBAppUnitTests/RNFBSharedUtilsFormattingFacadeTests.m

@@ -0,0 +1,38 @@
+/**
+ * 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 RNFBSharedUtilsFormattingFacadeTests : XCTestCase
+@end
+
+@implementation RNFBSharedUtilsFormattingFacadeTests
+
+- (void)testFacadeMapsDefaultAppName {
+  XCTAssertEqualObjects([RNFBSharedUtils getAppJavaScriptName:DEFAULT_APP_NAME],
+                        DEFAULT_APP_DISPLAY_NAME);
+  XCTAssertEqualObjects([RNFBSharedUtils getAppJavaScriptName:@"secondary"], @"secondary");
+}
+
+- (void)testFacadeFormatsISO8601WithTrailingZ {
+  NSDate *date = [NSDate dateWithTimeIntervalSince1970:1577934245];
+  XCTAssertEqualObjects([RNFBSharedUtils getISO8601String:date], @"2020-01-02T03:04:05Z");
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBSharedUtilsFormattingTests.swift

@@ -0,0 +1,82 @@
+/**
+ * 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 RNFBSharedUtilsFormattingTests: XCTestCase {
+  func testDefaultAppNameMapsToDisplayName() {
+    XCTAssertEqual(
+      RNFBSharedUtilsFormatting.getAppJavaScriptName("__FIRAPP_DEFAULT"),
+      "[DEFAULT]"
+    )
+  }
+
+  func testNonDefaultAppNameIsReturnedUnchanged() {
+    XCTAssertEqual(
+      RNFBSharedUtilsFormatting.getAppJavaScriptName("secondary"),
+      "secondary"
+    )
+    XCTAssertEqual(
+      RNFBSharedUtilsFormatting.getAppJavaScriptName("[DEFAULT]"),
+      "[DEFAULT]"
+    )
+    XCTAssertEqual(RNFBSharedUtilsFormatting.getAppJavaScriptName(""), "")
+  }
+
+  func testNilAppNameReturnsNil() {
+    XCTAssertNil(RNFBSharedUtilsFormatting.getAppJavaScriptName(nil))
+  }
+
+  func testISO8601UsesPOSIXUTCAndTrailingZ() {
+    var components = DateComponents()
+    components.calendar = Calendar(identifier: .gregorian)
+    components.timeZone = TimeZone(abbreviation: "UTC")
+    components.year = 2020
+    components.month = 1
+    components.day = 2
+    components.hour = 3
+    components.minute = 4
+    components.second = 5
+
+    let date = components.date!
+    XCTAssertEqual(
+      RNFBSharedUtilsFormatting.getISO8601String(date),
+      "2020-01-02T03:04:05Z"
+    )
+  }
+
+  func testISO8601FormatsInUTCRegardlessOfLocalOffset() {
+    // 2020-01-02 03:04:05 UTC as absolute instant; format must stay UTC/`Z`.
+    let date = Date(timeIntervalSince1970: 1_577_934_245)
+    XCTAssertEqual(
+      RNFBSharedUtilsFormatting.getISO8601String(date),
+      "2020-01-02T03:04:05Z"
+    )
+  }
+
+  func testISO8601OmitsFractionalSeconds() {
+    let date = Date(timeIntervalSince1970: 1_577_934_245.789)
+    XCTAssertEqual(
+      RNFBSharedUtilsFormatting.getISO8601String(date),
+      "2020-01-02T03:04:05Z"
+    )
+  }
+
+  func testNilDateReturnsNil() {
+    XCTAssertNil(RNFBSharedUtilsFormatting.getISO8601String(nil))
+  }
+}

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")
+  }
+}