@react-native-firebase/app 26.3.3 → 27.0.0

package/ios/RNFBAppUnitTests/RNFBPreferencesStorageTests.swift

@@ -0,0 +1,105 @@
+/**
+ * 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 RNFBPreferencesStorageTests: XCTestCase {
+  private var domainIdentifier: String!
+  private var userDefaults: UserDefaults!
+  private var storage: RNFBPreferencesStorage!
+
+  override func setUp() {
+    super.setUp()
+    domainIdentifier = "io.invertase.firebase.tests.\(UUID().uuidString)"
+    userDefaults = UserDefaults(suiteName: domainIdentifier)
+    userDefaults.removePersistentDomain(forName: domainIdentifier)
+    storage = RNFBPreferencesStorage(
+      userDefaults: userDefaults,
+      domainIdentifier: domainIdentifier
+    )
+  }
+
+  override func tearDown() {
+    userDefaults.removePersistentDomain(forName: domainIdentifier)
+    storage = nil
+    userDefaults = nil
+    domainIdentifier = nil
+    super.tearDown()
+  }
+
+  func testMissingKeysUseDefaultsAndAreNotContained() {
+    XCTAssertFalse(storage.contains("missing"))
+    XCTAssertTrue(storage.getBooleanValue("missing", defaultValue: true))
+    XCTAssertEqual(storage.getIntegerValue("missing", defaultValue: Int.max), Int.max)
+    XCTAssertEqual(storage.getStringValue("missing", defaultValue: "fallback"), "fallback")
+  }
+
+  func testSettersAndGettersPreserveValuesAndDictionaryRepresentation() {
+    storage.setBooleanValue("bool", boolValue: true)
+    storage.setIntegerValue("integer", integerValue: Int.max)
+    storage.setStringValue("string", stringValue: "value")
+
+    XCTAssertTrue(storage.contains("bool"))
+    XCTAssertTrue(storage.getBooleanValue("bool", defaultValue: false))
+    XCTAssertEqual(storage.getIntegerValue("integer", defaultValue: 0), Int.max)
+    XCTAssertEqual(storage.getStringValue("string", defaultValue: "fallback"), "value")
+
+    let all = storage.getAll()
+    XCTAssertEqual(all["bool"] as? Bool, true)
+    XCTAssertEqual(all["integer"] as? Int, Int.max)
+    XCTAssertEqual(all["string"] as? String, "value")
+  }
+
+  func testStringForPresentNonStringValueMatchesNSUserDefaults() {
+    userDefaults.set(["value"], forKey: "notString")
+
+    XCTAssertTrue(storage.contains("notString"))
+    XCTAssertNil(storage.getStringValue("notString", defaultValue: "fallback"))
+  }
+
+  func testRemoveAndClearAllUseTheConfiguredPersistentDomain() {
+    storage.setStringValue("first", stringValue: "one")
+    storage.setStringValue("second", stringValue: "two")
+
+    storage.remove("first")
+    XCTAssertFalse(storage.contains("first"))
+    XCTAssertTrue(storage.contains("second"))
+
+    storage.clearAll()
+    XCTAssertFalse(storage.contains("second"))
+    let clearedDomain = userDefaults.persistentDomain(forName: domainIdentifier)
+    XCTAssertTrue(
+      clearedDomain == nil || clearedDomain?.isEmpty == true,
+      "clearAll must leave the persistent domain nil or empty; got \(String(describing: clearedDomain))"
+    )
+  }
+
+  func testDefaultInitializerUsesRNFBPreferencesSuite() {
+    let suiteName = "io.invertase.firebase"
+    let productionDefaults = UserDefaults(suiteName: suiteName)!
+    let key = "RNFBPreferencesStorageTests.\(UUID().uuidString)"
+    productionDefaults.removeObject(forKey: key)
+    defer {
+      productionDefaults.removeObject(forKey: key)
+    }
+
+    let productionStorage = RNFBPreferencesStorage()
+    productionStorage.setStringValue(key, stringValue: "suite-value")
+
+    XCTAssertEqual(productionDefaults.string(forKey: key), "suite-value")
+  }
+}

package/ios/RNFBAppUnitTests/RNFBPreferencesTests.m

@@ -0,0 +1,110 @@
+/**
+ * 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 "RNFBPreferences.h"
+
+@interface RNFBPreferencesTests : XCTestCase
+@property(nonatomic, strong) NSString *domainIdentifier;
+@property(nonatomic, strong) NSUserDefaults *userDefaults;
+@property(nonatomic, strong) RNFBPreferences *preferences;
+@end
+
+@implementation RNFBPreferencesTests
+
+- (void)setUp {
+  [super setUp];
+  self.domainIdentifier =
+      [@"io.invertase.firebase.tests." stringByAppendingString:NSUUID.UUID.UUIDString];
+  self.userDefaults = [[NSUserDefaults alloc] initWithSuiteName:self.domainIdentifier];
+  [self.userDefaults removePersistentDomainForName:self.domainIdentifier];
+  RNFBPreferencesStorage *storage =
+      [[RNFBPreferencesStorage alloc] initWithUserDefaults:self.userDefaults
+                                          domainIdentifier:self.domainIdentifier];
+  self.preferences = [[RNFBPreferences alloc] init];
+  [self.preferences setValue:storage forKey:@"storage"];
+}
+
+- (void)tearDown {
+  [self.userDefaults removePersistentDomainForName:self.domainIdentifier];
+  self.preferences = nil;
+  self.userDefaults = nil;
+  self.domainIdentifier = nil;
+  [super tearDown];
+}
+
+- (void)testSharedIsAvailableAndStable {
+  XCTAssertNotNil(RNFBPreferences.shared);
+  XCTAssertIdentical(RNFBPreferences.shared, RNFBPreferences.shared);
+}
+
+- (void)testPublicSelectorsAndIntegerWidthsAreUnchanged {
+  NSArray<NSString *> *selectorNames = @[
+    @"contains:",
+    @"getBooleanValue:defaultValue:",
+    @"setBooleanValue:boolValue:",
+    @"setIntegerValue:integerValue:",
+    @"setStringValue:stringValue:",
+    @"getStringValue:defaultValue:",
+    @"getIntegerValue:defaultValue:",
+    @"getAll",
+    @"clearAll",
+    @"remove:",
+  ];
+  for (NSString *selectorName in selectorNames) {
+    XCTAssertTrue([self.preferences respondsToSelector:NSSelectorFromString(selectorName)]);
+  }
+
+  NSMethodSignature *setter =
+      [RNFBPreferences instanceMethodSignatureForSelector:@selector(setIntegerValue:integerValue:)];
+  XCTAssertEqual(strcmp([setter getArgumentTypeAtIndex:3], @encode(NSInteger)), 0);
+
+  NSMethodSignature *getter =
+      [RNFBPreferences instanceMethodSignatureForSelector:@selector(getIntegerValue:defaultValue:)];
+  XCTAssertEqual(strcmp(getter.methodReturnType, @encode(NSInteger)), 0);
+  XCTAssertEqual(strcmp([getter getArgumentTypeAtIndex:3], @encode(NSInteger)), 0);
+}
+
+- (void)testFacadeForwardsEveryPreferenceOperation {
+  XCTAssertFalse([self.preferences contains:@"missing"]);
+  XCTAssertTrue([self.preferences getBooleanValue:@"missing" defaultValue:YES]);
+  XCTAssertEqual([self.preferences getIntegerValue:@"missing" defaultValue:NSIntegerMax],
+                 NSIntegerMax);
+  XCTAssertEqualObjects([self.preferences getStringValue:@"missing" defaultValue:@"fallback"],
+                        @"fallback");
+
+  [self.preferences setBooleanValue:@"bool" boolValue:YES];
+  [self.preferences setIntegerValue:@"integer" integerValue:NSIntegerMax];
+  [self.preferences setStringValue:@"string" stringValue:@"value"];
+
+  XCTAssertTrue([self.preferences contains:@"bool"]);
+  XCTAssertTrue([self.preferences getBooleanValue:@"bool" defaultValue:NO]);
+  XCTAssertEqual([self.preferences getIntegerValue:@"integer" defaultValue:0], NSIntegerMax);
+  XCTAssertEqualObjects([self.preferences getStringValue:@"string" defaultValue:@"fallback"],
+                        @"value");
+  XCTAssertEqualObjects([self.preferences getAll][@"string"], @"value");
+
+  [self.preferences remove:@"bool"];
+  XCTAssertFalse([self.preferences contains:@"bool"]);
+
+  [self.preferences clearAll];
+  XCTAssertFalse([self.preferences contains:@"integer"]);
+  XCTAssertFalse([self.preferences contains:@"string"]);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBRCTEventEmitterCoreTests.swift

@@ -0,0 +1,163 @@
+/**
+ * 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 RNFBRCTEventEmitterCoreTests: XCTestCase {
+  private var bridgePresent = false
+  private var emitted: [(String, Any?)] = []
+  private var core: RNFBRCTEventEmitterCore!
+
+  override func setUp() {
+    super.setUp()
+    bridgePresent = false
+    emitted = []
+    core = RNFBRCTEventEmitterCore(
+      isBridgePresent: { [unowned self] in self.bridgePresent },
+      emitHandler: { [unowned self] name, body in
+        self.emitted.append((name, body))
+      }
+    )
+  }
+
+  override func tearDown() {
+    core = nil
+    super.tearDown()
+  }
+
+  func testInvalidateResetsState() {
+    core.sendEvent(name: "a", body: ["x": 1])
+    core.addListener("a")
+    core.notifyJsReady(true)
+
+    core.invalidate()
+
+    let dict = core.getListenersDictionary()
+    XCTAssertEqual(dict["listeners"] as? Int, 0)
+    XCTAssertEqual(dict["queued"] as? Int, 0)
+    XCTAssertEqual((dict["events"] as? NSDictionary)?.count, 0)
+  }
+
+  func testSendEventQueuesWhenNotReadyToEmit() {
+    core.sendEvent(name: "evt", body: ["k": "v"])
+
+    let dict = core.getListenersDictionary()
+    XCTAssertEqual(dict["queued"] as? Int, 1)
+    XCTAssertTrue(emitted.isEmpty)
+  }
+
+  func testSendEventEmitsWhenBridgeObservingAndRegistered() {
+    bridgePresent = true
+    core.notifyJsReady(true)
+    core.addListener("evt")
+    emitted = []
+
+    core.sendEvent(name: "evt", body: ["k": "v"])
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertEqual((emitted[0].1 as? NSDictionary)?["k"] as? String, "v")
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 0)
+  }
+
+  func testNotifyJsReadyFlushesQueue() {
+    bridgePresent = true
+    core.addListener("evt")
+    core.sendEvent(name: "evt", body: ["k": 1])
+    emitted = []
+
+    core.notifyJsReady(true)
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 0)
+  }
+
+  func testAddListenerFlushesMatchingQueuedEvents() {
+    bridgePresent = true
+    core.notifyJsReady(true)
+    core.sendEvent(name: "evt", body: ["k": 1])
+    core.sendEvent(name: "other", body: ["k": 2])
+    emitted = []
+
+    core.addListener("evt")
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 1)
+  }
+
+  func testAddListenerIncrementsCounts() {
+    core.addListener("evt")
+    core.addListener("evt")
+
+    let dict = core.getListenersDictionary()
+    XCTAssertEqual(dict["listeners"] as? Int, 2)
+    XCTAssertEqual((dict["events"] as? NSDictionary)?["evt"] as? Int, 2)
+  }
+
+  func testRemoveListenersDecrementsAndRemoves() {
+    core.addListener("evt")
+    core.addListener("evt")
+
+    core.removeListeners("evt", all: false)
+    XCTAssertEqual((core.getListenersDictionary()["events"] as? NSDictionary)?["evt"] as? Int, 1)
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 1)
+
+    core.removeListeners("evt", all: false)
+    XCTAssertNil((core.getListenersDictionary()["events"] as? NSDictionary)?["evt"])
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 0)
+  }
+
+  func testRemoveListenersAllRemovesEntireCount() {
+    core.addListener("evt")
+    core.addListener("evt")
+    core.addListener("evt")
+
+    core.removeListeners("evt", all: true)
+
+    XCTAssertNil((core.getListenersDictionary()["events"] as? NSDictionary)?["evt"])
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 0)
+  }
+
+  func testRemoveListenersNoOpWhenMissing() {
+    core.removeListeners("missing", all: true)
+    XCTAssertEqual(core.getListenersDictionary()["listeners"] as? Int, 0)
+  }
+
+  func testSendEventWithNilBodyWhenEmitting() {
+    bridgePresent = true
+    core.notifyJsReady(true)
+    core.addListener("evt")
+    emitted = []
+
+    core.sendEvent(name: "evt", body: nil)
+
+    XCTAssertEqual(emitted.count, 1)
+    XCTAssertEqual(emitted[0].0, "evt")
+    XCTAssertNil(emitted[0].1)
+  }
+
+  func testIsObservingRequiresJsReady() {
+    bridgePresent = true
+    core.addListener("evt")
+    core.sendEvent(name: "evt", body: ["k": 1])
+
+    XCTAssertTrue(emitted.isEmpty)
+    XCTAssertEqual(core.getListenersDictionary()["queued"] as? Int, 1)
+  }
+}

package/ios/RNFBAppUnitTests/RNFBRCTEventEmitterFacadeTests.m

@@ -0,0 +1,141 @@
+/**
+ * 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 <React/RCTBridge.h>
+#import "RNFBHandleMapStorage-Swift.inc"
+#import "RNFBRCTEventEmitter.h"
+
+@interface RNFBRCTEventEmitterFacadeTests : XCTestCase
+@property(nonatomic, strong) RNFBRCTEventEmitter *emitter;
+@property(nonatomic, strong) RCTBridge *bridge;
+@end
+
+@implementation RNFBRCTEventEmitterFacadeTests
+
+- (void)setUp {
+  [super setUp];
+  self.emitter = [[RNFBRCTEventEmitter alloc] init];
+  self.bridge = [[RCTBridge alloc] init];
+  [self.emitter invalidate];
+}
+
+- (void)tearDown {
+  [self.emitter invalidate];
+  self.emitter.bridge = nil;
+  self.emitter = nil;
+  self.bridge = nil;
+  [super tearDown];
+}
+
+- (void)testSharedIsSingleton {
+  XCTAssertIdentical([RNFBRCTEventEmitter shared], [RNFBRCTEventEmitter shared]);
+}
+
+- (void)testPublicSelectorsUnchanged {
+  NSArray<NSString *> *selectorNames = @[
+    @"invalidate",
+    @"addListener:",
+    @"removeListeners:all:",
+    @"sendEventWithName:body:",
+    @"notifyJsReady:",
+    @"getListenersDictionary",
+  ];
+  for (NSString *selectorName in selectorNames) {
+    XCTAssertTrue([self.emitter respondsToSelector:NSSelectorFromString(selectorName)]);
+  }
+  XCTAssertTrue([RNFBRCTEventEmitter respondsToSelector:@selector(shared)]);
+  XCTAssertTrue([self.emitter respondsToSelector:@selector(bridge)]);
+  XCTAssertTrue([self.emitter respondsToSelector:@selector(setBridge:)]);
+}
+
+- (void)testInvalidateResetsListenersAndQueue {
+  [self.emitter sendEventWithName:@"evt" body:@{@"a" : @1}];
+  [self.emitter addListener:@"evt"];
+  [self.emitter notifyJsReady:YES];
+
+  [self.emitter invalidate];
+
+  NSDictionary *dict = [self.emitter getListenersDictionary];
+  XCTAssertEqualObjects(dict[@"listeners"], @0);
+  XCTAssertEqualObjects(dict[@"queued"], @0);
+  XCTAssertEqual([dict[@"events"] count], 0u);
+}
+
+- (void)testSendEventQueuesWithoutBridge {
+  [self.emitter notifyJsReady:YES];
+  [self.emitter addListener:@"evt"];
+  [self.emitter sendEventWithName:@"evt" body:@{@"a" : @1}];
+
+  NSDictionary *dict = [self.emitter getListenersDictionary];
+  XCTAssertEqualObjects(dict[@"queued"], @1);
+  XCTAssertNil(self.bridge.lastModule);
+}
+
+- (void)testSendEventEmitsViaBridgeWhenReady {
+  self.emitter.bridge = self.bridge;
+  [self.emitter notifyJsReady:YES];
+  [self.emitter addListener:@"evt"];
+  [self.bridge resetLastJSCallForTesting];
+
+  [self.emitter sendEventWithName:@"evt" body:@{@"a" : @1}];
+
+  XCTAssertEqualObjects(self.bridge.lastModule, @"RCTDeviceEventEmitter");
+  XCTAssertEqualObjects(self.bridge.lastMethod, @"emit");
+  XCTAssertEqualObjects(self.bridge.lastArgs[0], @"rnfb_evt");
+  XCTAssertEqualObjects(self.bridge.lastArgs[1][@"a"], @1);
+  XCTAssertEqualObjects([self.emitter getListenersDictionary][@"queued"], @0);
+}
+
+- (void)testSendEventEmitsNilBodyAsSingleArg {
+  self.emitter.bridge = self.bridge;
+  [self.emitter notifyJsReady:YES];
+  [self.emitter addListener:@"evt"];
+  [self.bridge resetLastJSCallForTesting];
+
+  [self.emitter sendEventWithName:@"evt" body:nil];
+
+  XCTAssertEqualObjects(self.bridge.lastArgs, (@[ @"rnfb_evt" ]));
+}
+
+- (void)testNotifyJsReadyFlushesQueuedEvents {
+  self.emitter.bridge = self.bridge;
+  [self.emitter addListener:@"evt"];
+  [self.emitter sendEventWithName:@"evt" body:@{@"a" : @1}];
+  [self.bridge resetLastJSCallForTesting];
+
+  [self.emitter notifyJsReady:YES];
+
+  XCTAssertEqualObjects(self.bridge.lastArgs[0], @"rnfb_evt");
+  XCTAssertEqualObjects([self.emitter getListenersDictionary][@"queued"], @0);
+}
+
+- (void)testAddAndRemoveListeners {
+  [self.emitter addListener:@"evt"];
+  [self.emitter addListener:@"evt"];
+  XCTAssertEqualObjects([self.emitter getListenersDictionary][@"listeners"], @2);
+  XCTAssertEqualObjects([self.emitter getListenersDictionary][@"events"][@"evt"], @2);
+
+  [self.emitter removeListeners:@"evt" all:NO];
+  XCTAssertEqualObjects([self.emitter getListenersDictionary][@"events"][@"evt"], @1);
+
+  [self.emitter removeListeners:@"evt" all:YES];
+  XCTAssertNil([self.emitter getListenersDictionary][@"events"][@"evt"]);
+  XCTAssertEqualObjects([self.emitter getListenersDictionary][@"listeners"], @0);
+}
+
+@end

package/ios/RNFBAppUnitTests/RNFBSharedUtilsConfigFacadeTests.m

@@ -0,0 +1,100 @@
+/**
+ * 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"
+#import "RNFBPreferences.h"
+#import "RNFBSharedUtils.h"
+
+@interface RNFBSharedUtilsConfigFacadeTests : XCTestCase
+@end
+
+@implementation RNFBSharedUtilsConfigFacadeTests
+
+- (void)tearDown {
+  [[RNFBPreferences shared] remove:@"__rnfb_config_facade_prefs__"];
+  [[RNFBPreferences shared] remove:@"__rnfb_config_facade_bool__"];
+  [[RNFBPreferences shared] remove:@"__rnfb_config_facade_json_lose__"];
+  [super tearDown];
+}
+
+- (void)testFacadeConfigContainsViaPreferences {
+  NSString *key = @"__rnfb_config_facade_prefs__";
+  XCTAssertFalse([RNFBSharedUtils configContains:key]);
+
+  [[RNFBPreferences shared] setBooleanValue:key boolValue:YES];
+  XCTAssertTrue([RNFBSharedUtils configContains:key]);
+}
+
+- (void)testFacadeGetConfigBooleanValuePreferencesWins {
+  NSString *key = @"__rnfb_config_facade_bool__";
+  [[RNFBPreferences shared] setBooleanValue:key boolValue:YES];
+
+  XCTAssertTrue([RNFBSharedUtils getConfigBooleanValue:@"ConfigFacadeTests"
+                                                   key:key
+                                          defaultValue:NO]);
+}
+
+- (void)testFacadeGetConfigBooleanValueMetaPathUsesDefault {
+  NSString *key = @"__rnfb_config_facade_missing_everywhere__";
+  // Absent from Preferences / JSON / Meta → Meta path with passed-in defaultValue.
+  XCTAssertFalse([RNFBSharedUtils getConfigBooleanValue:@"ConfigFacadeTests"
+                                                    key:key
+                                           defaultValue:NO]);
+  XCTAssertTrue([RNFBSharedUtils getConfigBooleanValue:@"ConfigFacadeTests"
+                                                   key:key
+                                          defaultValue:YES]);
+  XCTAssertFalse([RNFBSharedUtils configContains:key]);
+}
+
+- (void)testFacadeGetConfigBooleanValueJsonOverMeta {
+  NSString *key = @"__rnfb_config_facade_json_win__";
+  RNFBJSONImplementation *implementation =
+      [[RNFBJSONImplementation alloc] initWithJSONObject:@{key : @YES}];
+
+  // Temporarily swap the shared JSON implementation so the façade resolves JSON before Meta.
+  RNFBJSON *shared = [RNFBJSON shared];
+  id previous = [shared valueForKey:@"implementation"];
+  [shared setValue:implementation forKey:@"implementation"];
+
+  @try {
+    XCTAssertFalse([[RNFBPreferences shared] contains:key]);
+    XCTAssertTrue([RNFBSharedUtils configContains:key]);
+    XCTAssertTrue([RNFBSharedUtils getConfigBooleanValue:@"ConfigFacadeTests"
+                                                     key:key
+                                            defaultValue:NO]);
+  } @finally {
+    [shared setValue:previous forKey:@"implementation"];
+  }
+}
+
+- (void)testFacadePublicSelectorsUnchanged {
+  XCTAssertTrue([RNFBSharedUtils respondsToSelector:@selector(configContains:)]);
+  XCTAssertTrue(
+      [RNFBSharedUtils respondsToSelector:@selector(getConfigBooleanValue:key:defaultValue:)]);
+
+  NSMethodSignature *contains =
+      [RNFBSharedUtils methodSignatureForSelector:@selector(configContains:)];
+  XCTAssertEqual(strcmp(contains.methodReturnType, @encode(BOOL)), 0);
+
+  NSMethodSignature *boolean = [RNFBSharedUtils
+      methodSignatureForSelector:@selector(getConfigBooleanValue:key:defaultValue:)];
+  XCTAssertEqual(strcmp(boolean.methodReturnType, @encode(BOOL)), 0);
+}
+
+@end