@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBInitializeAppArgumentsTests.swift

@@ -0,0 +1,256 @@
+/**
+ * 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 RNFBInitializeAppArgumentsTests: XCTestCase {
+  private func nullSentinel() -> NSDictionary {
+    ["__rnfbNull": true] as NSDictionary
+  }
+
+  private func requiredOptions() -> NSDictionary {
+    [
+      "apiKey": "key",
+      "appId": "1:123:ios:abc",
+      "messagingSenderId": "123",
+      "projectId": "project",
+    ] as NSDictionary
+  }
+
+  private func optionsByAdding(_ extra: [String: Any]) -> NSDictionary {
+    let options = NSMutableDictionary(dictionary: requiredOptions())
+    options.addEntries(from: extra)
+    return options
+  }
+
+  func testOptions_sentinelIosBundleId_isDropped() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["iosBundleId": nullSentinel()])
+    )!
+    XCTAssertNil(result["iosBundleId"])
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "iosBundleId" })
+  }
+
+  func testOptions_sentinelIosClientId_isDropped() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["iosClientId": nullSentinel()])
+    )!
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "iosClientId" })
+  }
+
+  func testOptions_sentinelAppGroupId_isDropped() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["appGroupId": nullSentinel()])
+    )!
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "appGroupId" })
+  }
+
+  func testOptions_sentinelAuthDomain_isDropped() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["authDomain": nullSentinel()])
+    )!
+    XCTAssertNil(result["authDomain"])
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "authDomain" })
+  }
+
+  func testOptions_sentinelDatabaseUrlAndStorageBucket_areDropped() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["databaseURL": nullSentinel(), "storageBucket": nullSentinel()])
+    )!
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "databaseURL" })
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "storageBucket" })
+  }
+
+  func testOptions_plainNSNullOptionalKey_isDropped() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["iosBundleId": NSNull()])
+    )!
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "iosBundleId" })
+  }
+
+  func testOptions_allOptionalKeysNull_onlyRequiredKeysRemain() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding([
+        "databaseURL": nullSentinel(),
+        "storageBucket": nullSentinel(),
+        "iosBundleId": nullSentinel(),
+        "iosClientId": nullSentinel(),
+        "appGroupId": nullSentinel(),
+        "authDomain": nullSentinel(),
+      ])
+    )
+    XCTAssertEqual(result, requiredOptions())
+  }
+
+  func testOptions_realStrings_areUnchanged() {
+    let input = optionsByAdding([
+      "databaseURL": "https://db.firebaseio.com",
+      "storageBucket": "bucket.appspot.com",
+      "iosBundleId": "com.example.app",
+      "iosClientId": "client-id",
+      "appGroupId": "group.com.example",
+      "authDomain": "example.firebaseapp.com",
+    ])
+    XCTAssertEqual(RNFBInitializeAppArguments.normalizedOptions(input), input)
+  }
+
+  func testOptions_nullOptionalKeyDoesNotAffectSiblingStrings() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding([
+        "iosBundleId": nullSentinel(),
+        "iosClientId": "client-id",
+        "authDomain": "example.firebaseapp.com",
+      ])
+    )!
+    XCTAssertFalse(result.allKeys.contains { ($0 as? String) == "iosBundleId" })
+    XCTAssertEqual(result["iosClientId"] as? String, "client-id")
+    XCTAssertEqual(result["authDomain"] as? String, "example.firebaseapp.com")
+    XCTAssertEqual(result["apiKey"] as? String, "key")
+  }
+
+  func testOptions_nonOptionalKeyWithNull_isLeftAsNSNull() {
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["projectId": nullSentinel()])
+    )!
+    XCTAssertTrue(result["projectId"] is NSNull)
+    XCTAssertEqual(result["apiKey"] as? String, "key")
+  }
+
+  func testOptions_oneKeyDictionaryThatIsNotSentinel_isUnchanged() {
+    let input = ["apiKey": "key"] as NSDictionary
+    XCTAssertEqual(RNFBInitializeAppArguments.normalizedOptions(input), input)
+  }
+
+  func testOptions_sentinelLookalikeValueForOptionalKey_isNotDropped() {
+    let notSentinel = ["__rnfbNull": false] as NSDictionary
+    let result = RNFBInitializeAppArguments.normalizedOptions(
+      optionsByAdding(["iosBundleId": notSentinel])
+    )!
+    XCTAssertEqual(result["iosBundleId"] as? NSDictionary, notSentinel)
+  }
+
+  func testOptions_nil_returnsNil() {
+    XCTAssertNil(RNFBInitializeAppArguments.normalizedOptions(nil))
+  }
+
+  func testOptions_rootSentinel_returnsNil() {
+    XCTAssertNil(RNFBInitializeAppArguments.normalizedOptions(nullSentinel()))
+  }
+
+  func testOptions_doesNotMutateInput() {
+    let input = optionsByAdding(["iosBundleId": nullSentinel()])
+    let copy = input.copy() as! NSDictionary
+    _ = RNFBInitializeAppArguments.normalizedOptions(input)
+    XCTAssertEqual(input, copy)
+  }
+
+  func testAppConfig_sentinelName_isDropped_andSentinelDataCollection_becomesNo() {
+    let result = RNFBInitializeAppArguments.normalizedAppConfig([
+      "name": nullSentinel(),
+      "automaticDataCollectionEnabled": nullSentinel(),
+    ])!
+    XCTAssertEqual(result.count, 1)
+    XCTAssertNil(result["name"])
+    XCTAssertEqual(result["automaticDataCollectionEnabled"] as? Bool, false)
+  }
+
+  func testAppConfig_nsNullDataCollection_becomesNo() {
+    let result = RNFBInitializeAppArguments.normalizedAppConfig([
+      "automaticDataCollectionEnabled": NSNull(),
+    ])!
+    XCTAssertEqual(result["automaticDataCollectionEnabled"] as? Bool, false)
+  }
+
+  func testAppConfig_omittedDataCollection_staysOmitted() {
+    let result = RNFBInitializeAppArguments.normalizedAppConfig(["name": "secondary"])!
+    XCTAssertNil(result["automaticDataCollectionEnabled"])
+  }
+
+  func testAppConfig_realValues_areUnchanged() {
+    let input = ["name": "secondary", "automaticDataCollectionEnabled": true] as NSDictionary
+    XCTAssertEqual(RNFBInitializeAppArguments.normalizedAppConfig(input), input)
+  }
+
+  func testAppConfig_unknownKeyWithNull_isLeftAsNSNull() {
+    let result = RNFBInitializeAppArguments.normalizedAppConfig([
+      "name": "secondary",
+      "extra": nullSentinel(),
+    ])!
+    XCTAssertEqual(result["name"] as? String, "secondary")
+    XCTAssertTrue(result["extra"] is NSNull)
+  }
+
+  func testAppConfig_nil_returnsNil() {
+    XCTAssertNil(RNFBInitializeAppArguments.normalizedAppConfig(nil))
+  }
+
+  func testAppConfig_rootSentinel_returnsNil() {
+    XCTAssertNil(RNFBInitializeAppArguments.normalizedAppConfig(nullSentinel()))
+  }
+
+  func testAutoDataCollection_yes_returnsYes() {
+    XCTAssertEqual(
+      RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: [
+        "automaticDataCollectionEnabled": true,
+      ]),
+      NSNumber(value: true)
+    )
+  }
+
+  func testAutoDataCollection_explicitNo_returnsNo() {
+    let result = RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: [
+      "automaticDataCollectionEnabled": false,
+    ])
+    XCTAssertNotNil(result)
+    XCTAssertFalse(result!.boolValue)
+  }
+
+  func testAutoDataCollection_absentKey_returnsNil() {
+    XCTAssertNil(
+      RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: ["name": "secondary"])
+    )
+  }
+
+  func testAutoDataCollection_nilAppConfig_returnsNil() {
+    XCTAssertNil(RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: nil))
+  }
+
+  func testAutoDataCollection_NSNull_returnsNil() {
+    XCTAssertNil(
+      RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: [
+        "automaticDataCollectionEnabled": NSNull(),
+      ])
+    )
+  }
+
+  func testAutoDataCollection_sentinelNormalizedUpstream_returnsNo() {
+    let normalized = RNFBInitializeAppArguments.normalizedAppConfig([
+      "automaticDataCollectionEnabled": nullSentinel(),
+    ])
+    let result = RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: normalized)
+    XCTAssertNotNil(result)
+    XCTAssertFalse(result!.boolValue)
+  }
+
+  func testAutoDataCollection_nonNumberValue_returnsNil() {
+    XCTAssertNil(
+      RNFBInitializeAppArguments.automaticDataCollectionEnabled(fromAppConfig: [
+        "automaticDataCollectionEnabled": "true",
+      ])
+    )
+  }
+}

package/ios/RNFBAppUnitTests/RNFBJSONImplementationTests.swift

@@ -0,0 +1,126 @@
+/**
+ * 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 RNFBJSONImplementationTests: XCTestCase {
+  private func base64(_ object: Any) throws -> String {
+    try JSONSerialization.data(withJSONObject: object).base64EncodedString()
+  }
+
+  func testNilInvalidBase64AndInvalidJSONProduceEmptyDictionaries() {
+    let implementations = [
+      RNFBJSONImplementation(rawValue: nil),
+      RNFBJSONImplementation(rawValue: "not base64"),
+      RNFBJSONImplementation(rawValue: Data("{".utf8).base64EncodedString()),
+    ]
+
+    for implementation in implementations {
+      XCTAssertFalse(implementation.contains("missing"))
+      XCTAssertEqual(
+        implementation.value(forKey: "missing", defaultValue: "fallback" as NSString) as? String,
+        "fallback"
+      )
+      XCTAssertEqual(implementation.jsonObject() as? NSDictionary, NSDictionary())
+    }
+  }
+
+  func testValidObjectPreservesFoundationValuesAndDefaultsOnlyForNilLookup() throws {
+    let implementation = RNFBJSONImplementation(rawValue: try base64([
+      "boolean": true,
+      "number": 3,
+      "string": "value",
+      "array": ["one", 2],
+      "object": ["nested": "value"],
+      "null": NSNull(),
+    ]))
+
+    XCTAssertTrue(implementation.contains("boolean"))
+    XCTAssertTrue(implementation.contains("null"))
+    XCTAssertFalse(implementation.contains("missing"))
+    XCTAssertEqual(
+      implementation.value(forKey: "missing", defaultValue: "fallback" as NSString) as? String,
+      "fallback"
+    )
+    XCTAssertTrue(implementation.value(
+      forKey: "null",
+      defaultValue: "fallback" as NSString
+    ) is NSNull)
+
+    let parsed = implementation.jsonObject() as! NSDictionary
+    XCTAssertEqual(parsed["boolean"] as? Bool, true)
+    XCTAssertEqual(parsed["number"] as? Int, 3)
+    XCTAssertEqual(parsed["string"] as? String, "value")
+    XCTAssertEqual(parsed["array"] as? NSArray, ["one", 2] as NSArray)
+    XCTAssertEqual(parsed["object"] as? NSDictionary, ["nested": "value"] as NSDictionary)
+  }
+
+  func testLookupMatchesNSDictionaryKVCForSpecialKeys() {
+    let dictionary: NSDictionary = [
+      "count": "count value",
+      "@count": "at-count value",
+      "description": "description value",
+    ]
+    let implementation = RNFBJSONImplementation(jsonObject: dictionary)
+
+    for key in ["count", "@count", "description"] {
+      XCTAssertEqual(
+        implementation.value(forKey: key, defaultValue: nil) as? NSObject,
+        dictionary.value(forKey: key) as? NSObject
+      )
+      XCTAssertEqual(implementation.contains(key), dictionary.value(forKey: key) != nil)
+    }
+  }
+
+  func testValidTopLevelArrayIsPreserved() throws {
+    let implementation = RNFBJSONImplementation(rawValue: try base64(["one", 2]))
+
+    XCTAssertEqual(implementation.jsonObject() as? NSArray, ["one", 2] as NSArray)
+  }
+
+  func testParsingIsAnInitializationSnapshot() throws {
+    let first = RNFBJSONImplementation(rawValue: try base64(["value": "first"]))
+    let second = RNFBJSONImplementation(rawValue: try base64(["value": "second"]))
+
+    XCTAssertEqual(first.value(forKey: "value", defaultValue: nil) as? String, "first")
+    XCTAssertEqual(second.value(forKey: "value", defaultValue: nil) as? String, "second")
+  }
+
+  func testRawJSONPreservesLegacyDecodeBehavior() {
+    XCTAssertEqual(RNFBJSONImplementation.rawJSON(from: nil), "{}")
+    XCTAssertNil(RNFBJSONImplementation.rawJSON(from: "not base64"))
+
+    let invalidJSON = "not JSON"
+    XCTAssertEqual(
+      RNFBJSONImplementation.rawJSON(
+        from: Data(invalidJSON.utf8).base64EncodedString()
+      ),
+      invalidJSON
+    )
+
+    let invalidUTF8 = Data([0xff, 0xfe]).base64EncodedString()
+    XCTAssertNil(RNFBJSONImplementation.rawJSON(from: invalidUTF8))
+
+    let validJSON = #"{"value":true}"#
+    XCTAssertEqual(
+      RNFBJSONImplementation.rawJSON(
+        from: Data(validJSON.utf8).base64EncodedString()
+      ),
+      validJSON
+    )
+  }
+}

package/ios/RNFBAppUnitTests/RNFBJSONTests.m

@@ -0,0 +1,172 @@
+/**
+ * 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 "RNFBJSON.h"
+
+@interface RNFBJSONTests : XCTestCase
+@end
+
+@implementation RNFBJSONTests
+
+- (RNFBJSON *)jsonWithObject:(NSObject *)object {
+  RNFBJSON *json = [[RNFBJSON alloc] init];
+  RNFBJSONImplementation *implementation =
+      [[RNFBJSONImplementation alloc] initWithJSONObject:object];
+  [json setValue:implementation forKey:@"implementation"];
+  return json;
+}
+
+- (void)testSharedUsesStableDispatchOnceIdentity {
+  RNFBJSON *first = RNFBJSON.shared;
+  XCTAssertNotNil(first);
+  XCTAssertIdentical(first, RNFBJSON.shared);
+}
+
+- (void)testPublicSelectorsAndReturnEncodingsAreUnchanged {
+  NSArray<NSString *> *selectorNames = @[
+    @"contains:",
+    @"getBooleanValue:defaultValue:",
+    @"getStringValue:defaultValue:",
+    @"getArrayValue:defaultValue:",
+    @"getAll",
+    @"getRawJSON",
+  ];
+  for (NSString *selectorName in selectorNames) {
+    XCTAssertTrue([[RNFBJSON shared] respondsToSelector:NSSelectorFromString(selectorName)]);
+  }
+  XCTAssertTrue([RNFBJSON respondsToSelector:@selector(shared)]);
+
+  NSMethodSignature *contains = [RNFBJSON instanceMethodSignatureForSelector:@selector(contains:)];
+  XCTAssertEqual(strcmp(contains.methodReturnType, @encode(BOOL)), 0);
+  NSMethodSignature *boolean =
+      [RNFBJSON instanceMethodSignatureForSelector:@selector(getBooleanValue:defaultValue:)];
+  XCTAssertEqual(strcmp(boolean.methodReturnType, @encode(BOOL)), 0);
+  XCTAssertEqual(strcmp([boolean getArgumentTypeAtIndex:3], @encode(BOOL)), 0);
+
+  NSArray<NSString *> *objectReturnSelectors = @[
+    @"getStringValue:defaultValue:", @"getArrayValue:defaultValue:", @"getAll", @"getRawJSON"
+  ];
+  for (NSString *selectorName in objectReturnSelectors) {
+    NSMethodSignature *signature =
+        [RNFBJSON instanceMethodSignatureForSelector:NSSelectorFromString(selectorName)];
+    XCTAssertEqual(strcmp(signature.methodReturnType, @encode(id)), 0);
+  }
+  NSMethodSignature *shared = [RNFBJSON methodSignatureForSelector:@selector(shared)];
+  XCTAssertEqual(strcmp(shared.methodReturnType, @encode(id)), 0);
+}
+
+- (void)testFacadePreservesKVCContainsDefaultsAndUncheckedObjectReturns {
+  NSDictionary *dictionary = @{
+    @"boolean" : @YES,
+    @"booleanFalse" : @NO,
+    @"numericZero" : @0,
+    @"booleanString" : @"YES",
+    @"string" : @"value",
+    @"array" : @[ @"one" ],
+    @"numberAsString" : @42,
+    @"stringAsArray" : @"unchecked",
+    @"null" : NSNull.null,
+    @"count" : @"count value",
+    @"@count" : @"at-count value",
+  };
+  RNFBJSON *json = [self jsonWithObject:dictionary];
+
+  XCTAssertTrue([json contains:@"boolean"]);
+  XCTAssertTrue([json contains:@"booleanFalse"]);
+  XCTAssertTrue([json contains:@"numericZero"]);
+  XCTAssertTrue([json contains:@"null"]);
+  XCTAssertFalse([json contains:@"missing"]);
+  XCTAssertTrue([json getBooleanValue:@"boolean" defaultValue:NO]);
+  XCTAssertFalse([json getBooleanValue:@"booleanFalse" defaultValue:YES]);
+  XCTAssertFalse([json getBooleanValue:@"numericZero" defaultValue:YES]);
+  XCTAssertTrue([json getBooleanValue:@"booleanString" defaultValue:NO]);
+  XCTAssertTrue([json getBooleanValue:@"missing" defaultValue:YES]);
+  XCTAssertEqualObjects([json getStringValue:@"missing" defaultValue:@"fallback"], @"fallback");
+  XCTAssertEqualObjects([json getArrayValue:@"missing" defaultValue:@[ @"fallback" ]],
+                        (@[ @"fallback" ]));
+  XCTAssertEqualObjects([json getStringValue:@"string" defaultValue:@"fallback"], @"value");
+  XCTAssertEqualObjects([json getArrayValue:@"array" defaultValue:@[]], (@[ @"one" ]));
+
+  id uncheckedString = [json getStringValue:@"numberAsString" defaultValue:@"fallback"];
+  id uncheckedArray = [json getArrayValue:@"stringAsArray" defaultValue:@[]];
+  XCTAssertEqualObjects(uncheckedString, @42);
+  XCTAssertEqualObjects(uncheckedArray, @"unchecked");
+  XCTAssertIdentical([json getStringValue:@"null" defaultValue:@"fallback"], NSNull.null);
+
+  for (NSString *key in @[ @"count", @"@count" ]) {
+    XCTAssertEqualObjects([json getStringValue:key defaultValue:@"fallback"],
+                          [dictionary valueForKey:key]);
+    XCTAssertEqual([json contains:key], [dictionary valueForKey:key] != nil);
+  }
+}
+
+- (void)testGetBooleanValueThrowsForNSNullArrayAndDictionaryReceivers {
+  NSDictionary *dictionary = @{
+    @"null" : NSNull.null,
+    @"array" : @[ @"one" ],
+    @"object" : @{@"nested" : @"value"},
+  };
+  RNFBJSON *json = [self jsonWithObject:dictionary];
+
+  XCTAssertThrowsSpecificNamed([json getBooleanValue:@"null" defaultValue:YES], NSException,
+                               NSInvalidArgumentException);
+  XCTAssertThrowsSpecificNamed([json getBooleanValue:@"array" defaultValue:YES], NSException,
+                               NSInvalidArgumentException);
+  XCTAssertThrowsSpecificNamed([json getBooleanValue:@"object" defaultValue:YES], NSException,
+                               NSInvalidArgumentException);
+
+  @try {
+    [json getBooleanValue:@"null" defaultValue:YES];
+    XCTFail(@"expected NSNull boolValue to throw");
+  } @catch (NSException *exception) {
+    XCTAssertEqualObjects(exception.name, NSInvalidArgumentException);
+    XCTAssertTrue([exception.reason containsString:@"boolValue"]);
+  }
+}
+
+- (void)testGetAllCopiesItemsAndReturnsIndependentImmutableSnapshot {
+  NSMutableString *mutableString = [NSMutableString stringWithString:@"before"];
+  NSMutableArray *mutableArray = [NSMutableArray arrayWithObject:@"first"];
+  NSDictionary *source = @{@"string" : mutableString, @"array" : mutableArray};
+  RNFBJSON *json = [self jsonWithObject:source];
+
+  NSDictionary *snapshot = [json getAll];
+
+  XCTAssertNotIdentical(snapshot, source);
+  XCTAssertNotIdentical(snapshot[@"string"], mutableString);
+  XCTAssertNotIdentical(snapshot[@"array"], mutableArray);
+  [mutableString appendString:@"-after"];
+  [mutableArray addObject:@"second"];
+  XCTAssertEqualObjects(snapshot[@"string"], @"before");
+  XCTAssertEqualObjects(snapshot[@"array"], (@[ @"first" ]));
+}
+
+- (void)testGetAllPreservesNonDictionaryExceptionBehavior {
+  RNFBJSON *json = [self jsonWithObject:@[ @"valid", @"JSON", @"array" ]];
+
+  XCTAssertThrowsSpecificNamed([json getAll], NSException, NSInvalidArgumentException);
+}
+
+- (void)testRawFacadeUsesCurrentBundleValueAndSwiftDecoder {
+  NSString *raw = [[NSBundle mainBundle].infoDictionary valueForKey:@"firebase_json_raw"];
+  XCTAssertEqualObjects([RNFBJSON.shared getRawJSON],
+                        [RNFBJSONImplementation rawJSONFromRawValue:raw]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBMetaStorageTests.swift

@@ -0,0 +1,106 @@
+/**
+ * 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 RNFBMetaStorageTests: XCTestCase {
+  private func storage(_ plist: [String: Any]) -> RNFBMetaStorage {
+    RNFBMetaStorage(infoDictionary: plist)
+  }
+
+  func testMissingKeysUseDefaultsAndAreNotContained() {
+    let meta = storage([:])
+
+    XCTAssertFalse(meta.contains("missing"))
+    XCTAssertTrue(meta.getBooleanValue("missing", defaultValue: true))
+    XCTAssertFalse(meta.getBooleanValue("missing", defaultValue: false))
+    XCTAssertEqual(meta.getStringValue("missing", defaultValue: "fallback"), "fallback")
+    XCTAssertEqual(meta.getAll() as NSDictionary, NSDictionary())
+  }
+
+  func testPrefixIsAppliedAndUnprefixedKeysAreIgnored() {
+    let meta = storage([
+      "rnfirebase_present": "value",
+      "other_key": "ignored",
+      "rnfirebase": "not-prefixed-enough",
+    ])
+
+    XCTAssertTrue(meta.contains("present"))
+    XCTAssertFalse(meta.contains("other_key"))
+    XCTAssertEqual(meta.getStringValue("present", defaultValue: "fallback"), "value")
+    XCTAssertEqual(meta.getStringValue("other_key", defaultValue: "fallback"), "fallback")
+
+    let all = meta.getAll()
+    XCTAssertEqual(all as NSDictionary, ["rnfirebase_present": "value"] as NSDictionary)
+    XCTAssertNil(all["other_key"])
+    XCTAssertNil(all["rnfirebase"])
+  }
+
+  func testGetAllReturnsPrefixedKeysUnstripped() {
+    let meta = storage([
+      "rnfirebase_string": "abc",
+      "rnfirebase_boolean_true": true,
+      "rnfirebase_boolean_false": false,
+      "unrelated": 1,
+    ])
+
+    let all = meta.getAll()
+    XCTAssertEqual(Set(all.keys), Set([
+      "rnfirebase_string",
+      "rnfirebase_boolean_true",
+      "rnfirebase_boolean_false",
+    ]))
+    XCTAssertEqual(all["rnfirebase_string"] as? String, "abc")
+    XCTAssertEqual(all["rnfirebase_boolean_true"] as? Bool, true)
+    XCTAssertEqual(all["rnfirebase_boolean_false"] as? Bool, false)
+  }
+
+  func testPresentBooleanFalseAndNumericZeroOverrideDefaultYes() {
+    let meta = storage([
+      "rnfirebase_boolFalse": false,
+      "rnfirebase_numericZero": 0,
+      "rnfirebase_boolTrue": true,
+      "rnfirebase_numericOne": 1,
+      "rnfirebase_boolStringYes": "YES",
+      "rnfirebase_boolStringNo": "0",
+    ])
+
+    XCTAssertTrue(meta.contains("boolFalse"))
+    XCTAssertTrue(meta.contains("numericZero"))
+    XCTAssertFalse(meta.getBooleanValue("boolFalse", defaultValue: true))
+    XCTAssertFalse(meta.getBooleanValue("numericZero", defaultValue: true))
+    XCTAssertTrue(meta.getBooleanValue("boolTrue", defaultValue: false))
+    XCTAssertTrue(meta.getBooleanValue("numericOne", defaultValue: false))
+    XCTAssertTrue(meta.getBooleanValue("boolStringYes", defaultValue: false))
+    XCTAssertFalse(meta.getBooleanValue("boolStringNo", defaultValue: true))
+  }
+
+  func testStringLookupPreservesPresentValues() {
+    let meta = storage([
+      "rnfirebase_string": "abc",
+    ])
+
+    XCTAssertEqual(meta.getStringValue("string", defaultValue: "fallback"), "abc")
+  }
+
+  func testDefaultInitializerUsesMainBundleInfoDictionary() {
+    let production = RNFBMetaStorage()
+    let fromBundle = RNFBMetaStorage(infoDictionary: Bundle.main.infoDictionary ?? [:])
+
+    XCTAssertEqual(production.getAll() as NSDictionary, fromBundle.getAll() as NSDictionary)
+  }
+}