@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBAppLogLevelMapperTests.swift

@@ -0,0 +1,59 @@
+/**
+ * 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 RNFBAppLogLevelMapperTests: XCTestCase {
+  /// `FIRLoggerLevelError`
+  private let errorLevel = 3
+  /// `FIRLoggerLevelWarning`
+  private let warningLevel = 4
+  /// `FIRLoggerLevelInfo`
+  private let infoLevel = 6
+  /// `FIRLoggerLevelDebug`
+  private let debugLevel = 7
+
+  func testVerboseMapsToDebug() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "verbose"), debugLevel)
+  }
+
+  func testDebugMapsToDebug() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "debug"), debugLevel)
+  }
+
+  func testInfoMapsToInfo() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "info"), infoLevel)
+  }
+
+  func testWarnMapsToWarning() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "warn"), warningLevel)
+  }
+
+  func testUnknownMapsToError() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "silent"), errorLevel)
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "error"), errorLevel)
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: "bogus"), errorLevel)
+  }
+
+  func testNilMapsToError() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: nil), errorLevel)
+  }
+
+  func testEmptyStringMapsToError() {
+    XCTAssertEqual(RNFBAppLogLevelMapper.loggerLevel(forString: ""), errorLevel)
+  }
+}

package/ios/RNFBAppUnitTests/RNFBAppModuleFirebaseFacadeTests.m

@@ -0,0 +1,215 @@
+/**
+ * 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 "FirebaseCore/FirebaseCore.h"
+#import "RNFBHandleMapStorage-Swift.inc"
+
+@interface RNFBAppModuleFirebaseFacadeTests : XCTestCase
+@end
+
+@implementation RNFBAppModuleFirebaseFacadeTests
+
+- (void)tearDown {
+  [FIRApp resetRegistryForTesting];
+  [FIRConfiguration resetForTesting];
+  [RNFBAppModuleFirebase resetRegisterLibraryOnceForTesting];
+  [RNFBAppCustomAuthDomains resetCustomDomainsForTesting];
+  [super tearDown];
+}
+
+- (void)testFacadeOptionsFactoryCreatesFIROptions {
+  id<RNFBFIROptionsCreating> factory = [RNFBAppModuleFirebase optionsFactory];
+  id options = [factory createWithGoogleAppID:@"app-id" gcmSenderID:@"sender-id"];
+  XCTAssertTrue([options isKindOfClass:NSClassFromString(@"RNFBFIROptionsConfiguringAdapter")]);
+  FIROptions *firOptions = [options valueForKey:@"options"];
+
+  XCTAssertEqualObjects(firOptions.googleAppID, @"app-id");
+  XCTAssertEqualObjects(firOptions.GCMSenderID, @"sender-id");
+}
+
+- (void)testFacadeOptionsFactoryForwardsNilGoogleAppIDAndSenderID {
+  id<RNFBFIROptionsCreating> factory = [RNFBAppModuleFirebase optionsFactory];
+  id options = [factory createWithGoogleAppID:nil gcmSenderID:nil];
+  XCTAssertTrue([options isKindOfClass:NSClassFromString(@"RNFBFIROptionsConfiguringAdapter")]);
+  FIROptions *firOptions = [options valueForKey:@"options"];
+
+  XCTAssertNil(firOptions.googleAppID);
+  XCTAssertNil(firOptions.GCMSenderID);
+}
+
+- (void)testFacadeAllAppsIncludesConfiguredDefaultAndNamed {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  [FIRApp configureWithOptions:options];
+  [FIRApp configureWithName:@"secondary" options:options];
+
+  NSArray *apps = [RNFBAppModuleFirebase allApps];
+  XCTAssertEqual(apps.count, 2);
+}
+
+- (void)testFacadeConfigureOrReuseDefaultReusesExisting {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  [FIRApp configureWithOptions:options];
+  FIRApp *existing = [FIRApp defaultApp];
+
+  RNFBAppInitializeNameResolution *names =
+      [[RNFBAppInitializeNameResolution alloc] initWithAppName:@"[DEFAULT]"
+                                                     jsAppName:@"[DEFAULT]"
+                                                  isDefaultApp:YES];
+  id result = [RNFBAppModuleFirebase configureOrReuseAppWithOptions:(id)options
+                                                     nameResolution:names];
+
+  XCTAssertEqual(result, existing);
+}
+
+- (void)testFacadeConfigureOrReuseDefaultConfiguresWhenMissing {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  RNFBAppInitializeNameResolution *names =
+      [[RNFBAppInitializeNameResolution alloc] initWithAppName:nil
+                                                     jsAppName:@"[DEFAULT]"
+                                                  isDefaultApp:YES];
+
+  id result = [RNFBAppModuleFirebase configureOrReuseAppWithOptions:(id)options
+                                                     nameResolution:names];
+
+  XCTAssertEqual(result, [FIRApp defaultApp]);
+  XCTAssertEqualObjects(((FIRApp *)result).options.googleAppID, @"app-id");
+}
+
+- (void)testFacadeConfigureOrReuseNamed {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  RNFBAppInitializeNameResolution *names =
+      [[RNFBAppInitializeNameResolution alloc] initWithAppName:@"secondary"
+                                                     jsAppName:@"secondary"
+                                                  isDefaultApp:NO];
+
+  id result = [RNFBAppModuleFirebase configureOrReuseAppWithOptions:(id)options
+                                                     nameResolution:names];
+
+  XCTAssertEqual(result, [FIRApp appNamed:@"secondary"]);
+}
+
+- (void)testFacadeRegisterLibraryOnceRecordsNameAndVersion {
+  [RNFBAppModuleFirebase registerLibraryOnceWithName:@"react-native-firebase" version:@"9.9.9"];
+  [RNFBAppModuleFirebase registerLibraryOnceWithName:@"react-native-firebase" version:@"ignored"];
+
+  XCTAssertEqualObjects([FIRApp lastRegisteredLibraryNameForTesting], @"react-native-firebase");
+  XCTAssertEqualObjects([FIRApp lastRegisteredLibraryVersionForTesting], @"9.9.9");
+}
+
+- (void)testFacadeSetLoggerLevelAppliesDebug {
+  [RNFBAppModuleFirebase setLoggerLevel:FIRLoggerLevelDebug];
+  XCTAssertEqual([FIRConfiguration sharedInstance].loggerLevel, FIRLoggerLevelDebug);
+}
+
+- (void)testFacadeSetLoggerLevelPassesThroughUnknownRawValue {
+  [RNFBAppModuleFirebase setLoggerLevel:99];
+  XCTAssertEqual([FIRConfiguration sharedInstance].loggerLevel, (FIRLoggerLevel)99);
+}
+
+- (void)testFacadeSetAutomaticDataCollectionEnabled {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  FIRApp *app = [[FIRApp alloc] initWithName:@"secondary" options:options];
+  [FIRApp registerAppForTesting:app];
+
+  [RNFBAppModuleFirebase setAutomaticDataCollectionEnabled:YES forAppName:@"secondary"];
+  XCTAssertTrue(app.isDataCollectionDefaultEnabled);
+}
+
+- (void)testFacadeSetAutomaticDataCollectionEnabledMissingAppReturnsEarly {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  FIRApp *app = [[FIRApp alloc] initWithName:@"secondary" options:options];
+  [FIRApp registerAppForTesting:app];
+
+  [RNFBAppModuleFirebase setAutomaticDataCollectionEnabled:YES forAppName:@"missing"];
+  XCTAssertFalse(app.isDataCollectionDefaultEnabled);
+}
+
+- (void)testFacadeSetDataCollectionDefaultEnabled {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  FIRApp *app = [[FIRApp alloc] initWithName:@"secondary" options:options];
+
+  [RNFBAppModuleFirebase setDataCollectionDefaultEnabled:YES forApp:app];
+  XCTAssertTrue(app.isDataCollectionDefaultEnabled);
+}
+
+- (void)testFacadeSetDataCollectionDefaultEnabledNonFirebaseAppReturnsEarly {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  FIRApp *app = [[FIRApp alloc] initWithName:@"secondary" options:options];
+  [FIRApp registerAppForTesting:app];
+
+  [RNFBAppModuleFirebase setDataCollectionDefaultEnabled:YES forApp:[NSObject new]];
+  XCTAssertFalse(app.isDataCollectionDefaultEnabled);
+}
+
+- (void)testFacadeDeleteAppRemovesFromRegistry {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  FIRApp *app = [[FIRApp alloc] initWithName:@"secondary" options:options];
+  [FIRApp registerAppForTesting:app];
+
+  XCTestExpectation *expectation = [self expectationWithDescription:@"delete"];
+  [RNFBAppModuleFirebase deleteApp:app
+                        completion:^(BOOL success) {
+                          XCTAssertTrue(success);
+                          [expectation fulfill];
+                        }];
+  [self waitForExpectationsWithTimeout:1 handler:nil];
+  XCTAssertNil([FIRApp appNamed:@"secondary"]);
+}
+
+- (void)testFacadeDeleteAppNamedMissingResolvesNull {
+  XCTestExpectation *expectation = [self expectationWithDescription:@"missing"];
+  [RNFBAppModuleFirebase deleteAppNamed:@"does-not-exist"
+      resolve:^(id result) {
+        XCTAssertEqual(result, [NSNull null]);
+        [expectation fulfill];
+      }
+      reject:^(NSString *code, NSString *message, NSError *error) {
+        XCTFail(@"should resolve");
+      }];
+  [self waitForExpectationsWithTimeout:1 handler:nil];
+}
+
+- (void)testFacadeDeleteAppNamedSuccessClearsDomain {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  FIRApp *app = [[FIRApp alloc] initWithName:@"secondary" options:options];
+  [FIRApp registerAppForTesting:app];
+  [RNFBAppCustomAuthDomains setCustomDomain:@"auth.example.com" forAppName:@"secondary"];
+
+  XCTestExpectation *expectation = [self expectationWithDescription:@"delete-named"];
+  [RNFBAppModuleFirebase deleteAppNamed:@"secondary"
+      resolve:^(id result) {
+        XCTAssertEqual(result, [NSNull null]);
+        [expectation fulfill];
+      }
+      reject:^(NSString *code, NSString *message, NSError *error) {
+        XCTFail(@"should resolve");
+      }];
+  [self waitForExpectationsWithTimeout:1 handler:nil];
+  XCTAssertNil([FIRApp appNamed:@"secondary"]);
+  XCTAssertNil([RNFBAppCustomAuthDomains getCustomDomain:@"secondary"]);
+}
+
+- (void)testFacadeAppForNameUsesDefaultDisplayName {
+  FIROptions *options = [[FIROptions alloc] initWithGoogleAppID:@"app-id" GCMSenderID:@"sender"];
+  [FIRApp configureWithOptions:options];
+
+  id result = [RNFBAppModuleFirebase appForName:@"[DEFAULT]"];
+  XCTAssertEqual(result, [FIRApp defaultApp]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBAppModuleFirebaseTests.swift

@@ -0,0 +1,430 @@
+/**
+ * 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 FirebaseCore
+import Foundation
+import XCTest
+
+private final class StubFIRAppToken: NSObject {
+  let label: String
+  init(label: String) {
+    self.label = label
+  }
+}
+
+private final class StubFIRAppLifecycle: NSObject, RNFBFIRAppLifecycle {
+  var defaultAppValue: AnyObject?
+  var namedApps: [String: AnyObject] = [:]
+  var allAppsValue: [AnyHashable: Any]?
+  var lastConfigureOptions: AnyObject?
+  var lastConfigureName: String?
+  var configureDefaultCalled = false
+  /// When false, configure succeeds without registering an app (SDK read-back returns nil).
+  var registersApps = true
+
+  func defaultApp() -> AnyObject? {
+    defaultAppValue
+  }
+
+  func appNamed(_ name: String) -> AnyObject? {
+    namedApps[name]
+  }
+
+  func allApps() -> [AnyHashable: Any]? {
+    allAppsValue
+  }
+
+  func configure(withOptions options: AnyObject) {
+    configureDefaultCalled = true
+    lastConfigureOptions = options
+    guard registersApps else { return }
+    let app = StubFIRAppToken(label: "configured-default")
+    defaultAppValue = app
+  }
+
+  func configure(withName name: String, options: AnyObject) {
+    lastConfigureName = name
+    lastConfigureOptions = options
+    guard registersApps else { return }
+    let app = StubFIRAppToken(label: "configured-\(name)")
+    namedApps[name] = app
+  }
+}
+
+private final class StubFIRLibraryRegistrar: NSObject, RNFBFIRLibraryRegistering {
+  var names: [String] = []
+  var versions: [String] = []
+
+  func registerLibrary(_ name: String, withVersion version: String) {
+    names.append(name)
+    versions.append(version)
+  }
+}
+
+private final class StubFIRLoggerConfiguration: NSObject, RNFBFIRLoggerConfiguring {
+  var levels: [Int] = []
+
+  func setLoggerLevel(_ level: Int) {
+    levels.append(level)
+  }
+}
+
+private final class StubFIRAppMutating: NSObject, RNFBFIRAppMutating {
+  var dataCollectionEnabled: Bool?
+  var deleteResults: [Bool]
+  var deleteCallCount = 0
+
+  init(deleteResults: [Bool] = [true]) {
+    self.deleteResults = deleteResults
+  }
+
+  func setDataCollectionDefaultEnabled(_ enabled: Bool) {
+    dataCollectionEnabled = enabled
+  }
+
+  func deleteApp(_ completion: @escaping (Bool) -> Void) {
+    let index = min(deleteCallCount, deleteResults.count - 1)
+    let result = deleteResults[index]
+    deleteCallCount += 1
+    completion(result)
+  }
+}
+
+final class RNFBAppModuleFirebaseTests: XCTestCase {
+  override func tearDown() {
+    RNFBAppModuleFirebase.resetRegisterLibraryOnceForTesting()
+    RNFBAppCustomAuthDomains.resetCustomDomainsForTesting()
+    super.tearDown()
+  }
+
+  func testAllAppsReturnsValuesWhenPresent() {
+    let lifecycle = StubFIRAppLifecycle()
+    let appA = StubFIRAppToken(label: "a")
+    let appB = StubFIRAppToken(label: "b")
+    lifecycle.allAppsValue = ["a": appA, "b": appB]
+
+    let result = RNFBAppModuleFirebase.allApps(lifecycle: lifecycle)
+
+    XCTAssertEqual(result.count, 2)
+    XCTAssertTrue(result.contains { $0 === appA })
+    XCTAssertTrue(result.contains { $0 === appB })
+  }
+
+  func testAllAppsReturnsEmptyWhenNil() {
+    let lifecycle = StubFIRAppLifecycle()
+    XCTAssertEqual(RNFBAppModuleFirebase.allApps(lifecycle: lifecycle).count, 0)
+  }
+
+  func testConfigureOrReuseDefaultReusesExisting() {
+    let lifecycle = StubFIRAppLifecycle()
+    let existing = StubFIRAppToken(label: "existing-default")
+    lifecycle.defaultAppValue = existing
+    let names = RNFBAppInitializeNameResolution(
+      appName: "[DEFAULT]",
+      jsAppName: "[DEFAULT]",
+      isDefaultApp: true
+    )
+
+    let result = RNFBAppModuleFirebase.configureOrReuseApp(
+      options: ConfiguringOptionsStub(),
+      nameResolution: names,
+      lifecycle: lifecycle
+    )
+
+    XCTAssertTrue(result === existing)
+    XCTAssertFalse(lifecycle.configureDefaultCalled)
+  }
+
+  func testConfigureOrReuseDefaultConfiguresWhenMissing() {
+    let lifecycle = StubFIRAppLifecycle()
+    let names = RNFBAppInitializeNameResolution(
+      appName: nil,
+      jsAppName: "[DEFAULT]",
+      isDefaultApp: true
+    )
+    let configuring = ConfiguringOptionsStub()
+    let result = RNFBAppModuleFirebase.configureOrReuseApp(
+      options: configuring,
+      nameResolution: names,
+      lifecycle: lifecycle
+    )
+
+    XCTAssertTrue(lifecycle.configureDefaultCalled)
+    XCTAssertTrue(result === lifecycle.defaultAppValue)
+  }
+
+  func testConfigureOrReuseNamedUsesConfigureWithName() {
+    let lifecycle = StubFIRAppLifecycle()
+    let names = RNFBAppInitializeNameResolution(
+      appName: "secondary",
+      jsAppName: "secondary",
+      isDefaultApp: false
+    )
+    let configuring = ConfiguringOptionsStub()
+
+    let result = RNFBAppModuleFirebase.configureOrReuseApp(
+      options: configuring,
+      nameResolution: names,
+      lifecycle: lifecycle
+    )
+
+    XCTAssertEqual(lifecycle.lastConfigureName, "secondary")
+    XCTAssertTrue(result === lifecycle.namedApps["secondary"])
+  }
+
+  func testConfigureOrReuseDefaultReturnsNilInsteadOfTrappingWhenReadBackIsNil() {
+    let lifecycle = StubFIRAppLifecycle()
+    lifecycle.registersApps = false
+    let names = RNFBAppInitializeNameResolution(
+      appName: nil,
+      jsAppName: "[DEFAULT]",
+      isDefaultApp: true
+    )
+
+    let result = RNFBAppModuleFirebase.configureOrReuseApp(
+      options: ConfiguringOptionsStub(),
+      nameResolution: names,
+      lifecycle: lifecycle
+    )
+
+    XCTAssertTrue(lifecycle.configureDefaultCalled)
+    XCTAssertNil(result)
+  }
+
+  func testConfigureOrReuseNamedReturnsNilInsteadOfTrappingWhenReadBackIsNil() {
+    let lifecycle = StubFIRAppLifecycle()
+    lifecycle.registersApps = false
+    let names = RNFBAppInitializeNameResolution(
+      appName: "secondary",
+      jsAppName: "secondary",
+      isDefaultApp: false
+    )
+
+    let result = RNFBAppModuleFirebase.configureOrReuseApp(
+      options: ConfiguringOptionsStub(),
+      nameResolution: names,
+      lifecycle: lifecycle
+    )
+
+    XCTAssertEqual(lifecycle.lastConfigureName, "secondary")
+    XCTAssertNil(result)
+  }
+
+  func testConfigureOrReuseUnwrapsConfiguringAdapterToLiveOptions() {
+    let lifecycle = StubFIRAppLifecycle()
+    let names = RNFBAppInitializeNameResolution(
+      appName: "secondary",
+      jsAppName: "secondary",
+      isDefaultApp: false
+    )
+    let live = FirebaseOptions(googleAppID: "app-id", gcmSenderID: "sender-id")
+    let adapter = RNFBFIROptionsConfiguringAdapter(live)
+
+    _ = RNFBAppModuleFirebase.configureOrReuseApp(
+      options: adapter,
+      nameResolution: names,
+      lifecycle: lifecycle
+    )
+
+    XCTAssertTrue(lifecycle.lastConfigureOptions === live)
+  }
+
+  func testOptionsFactoryReleasesOptionsAndPreservesNilIdentifiers() {
+    weak var releasedOptions: FirebaseOptions?
+
+    autoreleasepool {
+      let configured = RNFBAppModuleFirebase.optionsFactory().create(
+        googleAppID: nil,
+        gcmSenderID: nil
+      )
+      let adapter = configured as! RNFBFIROptionsConfiguringAdapter
+      releasedOptions = adapter.options
+
+      XCTAssertNil(adapter.options.googleAppID)
+      XCTAssertNil(adapter.options.gcmSenderID)
+    }
+
+    XCTAssertNil(releasedOptions)
+  }
+
+  func testDirectRegisterLibrarySkipsMissingSelectorAndForwardsWhenPresent() {
+    FirebaseApp.resetRegistryForTesting()
+    RNFBFIRLibraryRegisteringAdapter.registerLibrary("skipped", version: "0", on: NSObject.self)
+    XCTAssertNil(FirebaseApp.lastRegisteredLibraryNameForTesting())
+
+    RNFBFIRLibraryRegisteringAdapter.registerLibrary(
+      "react-native-firebase",
+      version: "1.0.0",
+      on: FirebaseApp.self
+    )
+    XCTAssertEqual(FirebaseApp.lastRegisteredLibraryNameForTesting(), "react-native-firebase")
+    XCTAssertEqual(FirebaseApp.lastRegisteredLibraryVersionForTesting(), "1.0.0")
+  }
+
+  func testRegisterLibraryOnceOnlyRegistersOnce() {
+    let registrar = StubFIRLibraryRegistrar()
+
+    RNFBAppModuleFirebase.registerLibraryOnce(
+      name: "react-native-firebase",
+      version: "1.2.3",
+      registrar: registrar
+    )
+    RNFBAppModuleFirebase.registerLibraryOnce(
+      name: "react-native-firebase",
+      version: "9.9.9",
+      registrar: registrar
+    )
+
+    XCTAssertEqual(registrar.names, ["react-native-firebase"])
+    XCTAssertEqual(registrar.versions, ["1.2.3"])
+  }
+
+  func testSetLoggerLevelForwardsToConfiguration() {
+    let configuration = StubFIRLoggerConfiguration()
+    RNFBAppModuleFirebase.setLoggerLevel(7, configuration: configuration)
+    XCTAssertEqual(configuration.levels, [7])
+  }
+
+  func testDeleteAppForwardsToMutating() {
+    let mutating = StubFIRAppMutating(deleteResults: [true])
+    let app = StubFIRAppToken(label: "app")
+    let expectation = expectation(description: "delete")
+
+    RNFBAppModuleFirebase.deleteApp(app, mutating: mutating) { success in
+      XCTAssertTrue(success)
+      expectation.fulfill()
+    }
+
+    waitForExpectations(timeout: 1)
+    XCTAssertEqual(mutating.deleteCallCount, 1)
+  }
+  func testDeleteAppCastFailureCompletesFalse() {
+    let expectation = expectation(description: "cast-failure")
+    RNFBAppModuleFirebase.deleteApp(StubFIRAppToken(label: "not-firebase")) { success in
+      XCTAssertFalse(success)
+      expectation.fulfill()
+    }
+    waitForExpectations(timeout: 1)
+  }
+
+  func testDeleteAppNamedResolvesNullWhenMissing() {
+    let expectation = expectation(description: "missing")
+    RNFBAppModuleFirebase.deleteApp(
+      named: "missing",
+      resolve: { result in
+        XCTAssertTrue(result is NSNull)
+        expectation.fulfill()
+      },
+      reject: { _, _, _ in
+        XCTFail("should resolve, not reject")
+      },
+      appLookup: { _ in nil },
+      performDelete: { _, _ in
+        XCTFail("should not delete")
+      }
+    )
+    waitForExpectations(timeout: 1)
+  }
+
+  func testDeleteAppNamedResolvesOnFirstSuccess() {
+    let app = StubFIRAppToken(label: "app")
+    var deleteCalls = 0
+    RNFBAppCustomAuthDomains.setCustomDomain("auth.example.com", forAppName: "secondary")
+    let expectation = expectation(description: "first-success")
+
+    RNFBAppModuleFirebase.deleteApp(
+      named: "secondary",
+      resolve: { result in
+        XCTAssertTrue(result is NSNull)
+        expectation.fulfill()
+      },
+      reject: { _, _, _ in
+        XCTFail("should resolve")
+      },
+      appLookup: { _ in app },
+      performDelete: { _, completion in
+        deleteCalls += 1
+        completion(true)
+      }
+    )
+
+    waitForExpectations(timeout: 1)
+    XCTAssertEqual(deleteCalls, 1)
+    XCTAssertNil(RNFBAppCustomAuthDomains.getCustomDomain("secondary"))
+  }
+
+  func testDeleteAppNamedRetriesOnceThenResolves() {
+    let app = StubFIRAppToken(label: "app")
+    var deleteCalls = 0
+    let expectation = expectation(description: "retry-success")
+
+    RNFBAppModuleFirebase.deleteApp(
+      named: "secondary",
+      resolve: { result in
+        XCTAssertTrue(result is NSNull)
+        expectation.fulfill()
+      },
+      reject: { _, _, _ in
+        XCTFail("should resolve after retry")
+      },
+      appLookup: { _ in app },
+      performDelete: { _, completion in
+        deleteCalls += 1
+        completion(deleteCalls > 1)
+      }
+    )
+
+    waitForExpectations(timeout: 1)
+    XCTAssertEqual(deleteCalls, 2)
+  }
+
+  func testDeleteAppNamedRejectsWhenBothDeletesFail() {
+    let app = StubFIRAppToken(label: "app")
+    var deleteCalls = 0
+    let expectation = expectation(description: "reject")
+
+    RNFBAppModuleFirebase.deleteApp(
+      named: "secondary",
+      resolve: { _ in
+        XCTFail("should reject")
+      },
+      reject: { code, message, _ in
+        XCTAssertEqual(code, "app/delete-app-failed")
+        XCTAssertEqual(message, "Failed to delete the specified app.")
+        expectation.fulfill()
+      },
+      appLookup: { _ in app },
+      performDelete: { _, completion in
+        deleteCalls += 1
+        completion(false)
+      }
+    )
+
+    waitForExpectations(timeout: 1)
+    XCTAssertEqual(deleteCalls, 2)
+  }
+
+}
+
+private final class ConfiguringOptionsStub: NSObject, RNFBFIROptionsConfiguring {
+  var APIKey: String?
+  var projectID: String?
+  var clientID: String?
+  var databaseURL: String?
+  var storageBucket: String?
+  var bundleID: String?
+  var appGroupID: String?
+}