@react-native-firebase/storage 26.4.0 → 27.1.0

package/ios/RNFBStorage/RNFBStorageErrorSnapshotDictBuilder.swift

@@ -0,0 +1,70 @@
+/**
+ * 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
+
+/**
+ * Error payload attachment previously inline in
+ * `+[RNFBStorageCommon buildErrorSnapshotDict:taskSnapshotDict:]` and
+ * `+[RNFBStorageCommon buildErrorSnapshotDictFromCodeAndMessage:taskSnapshotDict:]`.
+ *
+ * Mutates `taskSnapshotDict` in place and returns the same instance (or nil when
+ * the snapshot dict is nil — matching ObjC nil-messaging).
+ */
+@objc(RNFBStorageErrorSnapshotDictBuilder)
+public final class RNFBStorageErrorSnapshotDictBuilder: NSObject {
+  @objc(buildErrorSnapshotDict:taskSnapshotDict:)
+  public static func buildErrorSnapshotDict(
+    _ error: NSError?,
+    taskSnapshotDict: NSMutableDictionary?
+  ) -> NSDictionary? {
+    guard let taskSnapshotDict else {
+      return nil
+    }
+
+    let codeAndMessage = RNFBStorageErrorCodeMapper.codeAndMessage(for: error)
+    var errorPayload: [String: Any] = [
+      "code": codeAndMessage[0],
+      "message": codeAndMessage[1],
+    ]
+    // Pre-port ObjC always set this key from `[error localizedDescription]`.
+    if let error {
+      errorPayload["nativeErrorMessage"] = error.localizedDescription
+    } else {
+      errorPayload["nativeErrorMessage"] = NSNull()
+    }
+    taskSnapshotDict["error"] = errorPayload
+    return taskSnapshotDict
+  }
+
+  @objc(buildErrorSnapshotDictFromCodeAndMessage:taskSnapshotDict:)
+  public static func buildErrorSnapshotDictFromCodeAndMessage(
+    _ codeAndMessage: [Any]?,
+    taskSnapshotDict: NSMutableDictionary?
+  ) -> NSDictionary? {
+    guard let taskSnapshotDict else {
+      return nil
+    }
+
+    // Pre-port ObjC indexed without bounds checks; callers always pass [code, message].
+    let pair = codeAndMessage!
+    taskSnapshotDict["error"] = [
+      "code": pair[0],
+      "message": pair[1],
+    ]
+    return taskSnapshotDict
+  }
+}

package/ios/RNFBStorage/RNFBStorageTaskRegistry.m

@@ -23,8 +23,18 @@
 #import "RNFBApp/RNFBHandleMap.h"
 #endif
 
+#if __has_include(<RNFBStorage/RNFBStorage-Swift.h>)
+#import <RNFBStorage/RNFBStorage-Swift.h>
+#elif __has_include("RNFBStorage-Swift.h")
+#import "RNFBStorage-Swift.h"
+#elif __has_include("RNFBHandleMapStorage-Swift.inc")
+#import "RNFBHandleMapStorage-Swift.inc"
+#else
+#error "RNFBStorageTaskRegistryStorage Swift interface not found"
+#endif
+
 @interface RNFBStorageTaskRegistry ()
-@property(nonatomic, strong) RNFBHandleMap *map;
+@property(nonatomic, strong) RNFBStorageTaskRegistryStorage *storage;
 @end
 
 @implementation RNFBStorageTaskRegistry
@@ -32,63 +42,46 @@
 - (instancetype)init {
   self = [super init];
   if (self) {
-    _map = [[RNFBHandleMap alloc] init];
+    _storage = [[RNFBStorageTaskRegistryStorage alloc] init];
   }
   return self;
 }
 
-- (void)rnfb_cancelHandle:(id)handle {
-  if (handle && [handle respondsToSelector:@selector(cancel)]) {
-    [handle cancel];
-  }
-}
-
 - (BOOL)put:(id)key value:(id)value error:(NSError **)error {
-  return [self.map put:key value:value error:error];
+  if (![self.storage putIfAbsent:key value:value]) {
+    if (error != nil) {
+      NSString *message = [NSString stringWithFormat:@"Handle id already registered: %@", key];
+      *error = [NSError errorWithDomain:RNFBHandleMapErrorDomain
+                                   code:RNFBHandleMapErrorCollision
+                               userInfo:@{NSLocalizedDescriptionKey : message}];
+    }
+    return NO;
+  }
+  return YES;
 }
 
 - (BOOL)putOrDiscard:(id)key value:(id)value {
-  if ([self.map putIfAbsent:key value:value]) {
-    return YES;
-  }
-  [self rnfb_cancelHandle:value];
-  return NO;
+  return [self.storage putOrDiscard:key value:value];
 }
 
 - (id)get:(id)key {
-  return [self.map get:key];
+  return [self.storage get:key];
 }
 
 - (id)take:(id)key {
-  return [self.map take:key];
+  return [self.storage take:key];
 }
 
 - (id)takeIf:(id)key when:(BOOL (^)(id))condition {
-  return [self.map takeIf:key when:condition];
+  return [self.storage takeIf:key when:condition];
 }
 
 - (BOOL)takeAndCancel:(id)key {
-  // Align with Android RNFBStorageTaskRegistry.takeAndCancel: get → cancel → identity take.
-  // FIRStorage*Task cancel is void (no BOOL), so there is no keep-on-false path; always
-  // identity-take after cancel. Production setTaskStatus cancel uses takeIf then cancel
-  // (RNFBStorageHelper) — identity-safe; this helper matches Android ordering for registry/tests.
-  id handle = [self.map get:key];
-  if (handle == nil) {
-    return NO;
-  }
-  [self rnfb_cancelHandle:handle];
-  [self.map takeIf:key
-              when:^BOOL(id value) {
-                return value == handle;
-              }];
-  return YES;
+  return [self.storage takeAndCancel:key];
 }
 
 - (void)cancelAll {
-  NSArray *handlers = [self.map takeAll];
-  for (id handler in handlers) {
-    [self rnfb_cancelHandle:handler];
-  }
+  [self.storage cancelAll];
 }
 
 @end

package/ios/RNFBStorage/RNFBStorageTaskRegistryStorage.swift

@@ -0,0 +1,87 @@
+/**
+ * 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
+
+#if canImport(RNFBApp)
+import RNFBApp
+#endif
+
+/// Pending upload/download task map storage. Composes `RNFBHandleMapStorage`.
+/// `putOrDiscard` is first-wins and calls `cancel` on the incoming value on collision.
+/// Unique `put` collision errors stay on the ObjC façade.
+@objc(RNFBStorageTaskRegistryStorage)
+public final class RNFBStorageTaskRegistryStorage: NSObject {
+  private static let cancelSelector = Selector(("cancel"))
+
+  private let storage = RNFBHandleMapStorage()
+
+  private func cancelHandle(_ handle: AnyObject?) {
+    guard let handle = handle, handle.responds(to: Self.cancelSelector) else {
+      return
+    }
+    _ = handle.perform(Self.cancelSelector)
+  }
+
+  /// First-wins store without discarding the incoming value. Used by façade `put`.
+  @objc(putIfAbsent:value:)
+  public func putIfAbsent(_ key: AnyObject, value: AnyObject) -> Bool {
+    storage.putIfAbsent(key, value: value)
+  }
+
+  /// Unique put. On collision, `cancel`s the incoming value and leaves the existing mapping.
+  @objc(putOrDiscard:value:)
+  public func putOrDiscard(_ key: AnyObject, value: AnyObject) -> Bool {
+    if storage.putIfAbsent(key, value: value) {
+      return true
+    }
+    cancelHandle(value)
+    return false
+  }
+
+  @objc(get:)
+  public func get(_ key: AnyObject) -> AnyObject? {
+    storage.get(key)
+  }
+
+  @objc(take:)
+  public func take(_ key: AnyObject) -> AnyObject? {
+    storage.take(key)
+  }
+
+  @objc(takeIf:when:)
+  public func takeIf(_ key: AnyObject, when condition: (AnyObject) -> Bool) -> AnyObject? {
+    storage.takeIf(key, when: condition)
+  }
+
+  /// get → cancel → identity take (Android shape). FIRStorage cancel is void (no keep-on-false).
+  @objc(takeAndCancel:)
+  public func takeAndCancel(_ key: AnyObject) -> Bool {
+    guard let handle = storage.get(key) else {
+      return false
+    }
+    cancelHandle(handle)
+    _ = storage.takeIf(key, when: { $0 === handle })
+    return true
+  }
+
+  @objc
+  public func cancelAll() {
+    for handle in storage.takeAll() {
+      cancelHandle(handle)
+    }
+  }
+}

package/ios/RNFBStorage/RNFBStorageTaskStatusMapper.swift

@@ -0,0 +1,57 @@
+/**
+ * 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
+
+/**
+ * `FIRStorageTaskStatus` raw value → JS task-state string mapping previously
+ * inline in `+[RNFBStorageCommon getTaskStatus:]`.
+ *
+ * Raw ints from Firebase Storage `StorageTaskStatus`
+ * (`@objc(FIRStorageTaskStatus)` in `StorageConstants.swift`):
+ * - unknown = 0, resume = 1, progress = 2, pause = 3, success = 4, failure = 5
+ *
+ * Hardcoded so the Storage unit target does not need FirebaseStorage.
+ */
+@objc(RNFBStorageTaskStatusMapper)
+public final class RNFBStorageTaskStatusMapper: NSObject {
+  /// `FIRStorageTaskStatusResume`
+  private static let statusResume = 1
+  /// `FIRStorageTaskStatusProgress`
+  private static let statusProgress = 2
+  /// `FIRStorageTaskStatusPause`
+  private static let statusPause = 3
+  /// `FIRStorageTaskStatusSuccess`
+  private static let statusSuccess = 4
+  /// `FIRStorageTaskStatusFailure`
+  private static let statusFailure = 5
+
+  @objc(stringForTaskStatus:)
+  public static func string(forTaskStatus status: Int) -> String {
+    if status == statusResume || status == statusProgress {
+      return "running"
+    } else if status == statusPause {
+      return "paused"
+    } else if status == statusSuccess {
+      return "success"
+    } else if status == statusFailure {
+      return "error"
+    } else {
+      // `FIRStorageTaskStatusUnknown` (0) and any other raw value
+      return "unknown"
+    }
+  }
+}

package/ios/RNFBStorage.xcodeproj/project.pbxproj

@@ -12,6 +12,11 @@
 		27A35B652268E118005BE5A8 /* RNFBStorageDownloadTask.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A35B642268E118005BE5A8 /* RNFBStorageDownloadTask.m */; };
 		27A35B682268E138005BE5A8 /* RNFBStorageUploadTask.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A35B672268E138005BE5A8 /* RNFBStorageUploadTask.m */; };
 		27A35B6B2268E1BE005BE5A8 /* RNFBStorageCommon.m in Sources */ = {isa = PBXBuildFile; fileRef = 27A35B6A2268E1BE005BE5A8 /* RNFBStorageCommon.m */; };
+		RNFBSTOR0000000000000001 /* RNFBStorageTaskRegistry.m in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000002 /* RNFBStorageTaskRegistry.m */; };
+		RNFBSTOR0000000000000003 /* RNFBStorageTaskRegistryStorage.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000004 /* RNFBStorageTaskRegistryStorage.swift */; };
+		RNFBSTOR0000000000000006 /* RNFBStorageTaskStatusMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000007 /* RNFBStorageTaskStatusMapper.swift */; };
+		RNFBSTOR0000000000000008 /* RNFBStorageErrorCodeMapper.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR0000000000000009 /* RNFBStorageErrorCodeMapper.swift */; };
+		RNFBSTOR000000000000000A /* RNFBStorageErrorSnapshotDictBuilder.swift in Sources */ = {isa = PBXBuildFile; fileRef = RNFBSTOR000000000000000B /* RNFBStorageErrorSnapshotDictBuilder.swift */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXCopyFilesBuildPhase section */
@@ -38,6 +43,12 @@
 		27A35B692268E143005BE5A8 /* RNFBStorageUploadTask.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBStorageUploadTask.h; sourceTree = "<group>"; };
 		27A35B6A2268E1BE005BE5A8 /* RNFBStorageCommon.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = RNFBStorageCommon.m; sourceTree = "<group>"; };
 		27A35B6C2268E1C8005BE5A8 /* RNFBStorageCommon.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RNFBStorageCommon.h; sourceTree = "<group>"; };
+		RNFBSTOR0000000000000005 /* RNFBStorageTaskRegistry.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = RNFBStorageTaskRegistry.h; path = RNFBStorage/RNFBStorageTaskRegistry.h; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000002 /* RNFBStorageTaskRegistry.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; name = RNFBStorageTaskRegistry.m; path = RNFBStorage/RNFBStorageTaskRegistry.m; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000004 /* RNFBStorageTaskRegistryStorage.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageTaskRegistryStorage.swift; path = RNFBStorage/RNFBStorageTaskRegistryStorage.swift; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000007 /* RNFBStorageTaskStatusMapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageTaskStatusMapper.swift; path = RNFBStorage/RNFBStorageTaskStatusMapper.swift; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR0000000000000009 /* RNFBStorageErrorCodeMapper.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageErrorCodeMapper.swift; path = RNFBStorage/RNFBStorageErrorCodeMapper.swift; sourceTree = SOURCE_ROOT; };
+		RNFBSTOR000000000000000B /* RNFBStorageErrorSnapshotDictBuilder.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; name = RNFBStorageErrorSnapshotDictBuilder.swift; path = RNFBStorage/RNFBStorageErrorSnapshotDictBuilder.swift; sourceTree = SOURCE_ROOT; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -64,6 +75,12 @@
 			children = (
 				2744B98421F45429004F8E3F /* RNFBStorageModule.h */,
 				2744B98521F45429004F8E3F /* RNFBStorageModule.mm */,
+				RNFBSTOR0000000000000005 /* RNFBStorageTaskRegistry.h */,
+				RNFBSTOR0000000000000002 /* RNFBStorageTaskRegistry.m */,
+				RNFBSTOR0000000000000004 /* RNFBStorageTaskRegistryStorage.swift */,
+				RNFBSTOR0000000000000007 /* RNFBStorageTaskStatusMapper.swift */,
+				RNFBSTOR0000000000000009 /* RNFBStorageErrorCodeMapper.swift */,
+				RNFBSTOR000000000000000B /* RNFBStorageErrorSnapshotDictBuilder.swift */,
 				27A35B612268E0AB005BE5A8 /* RNFBStorageTask.m */,
 				27A35B632268E0CD005BE5A8 /* RNFBStorageTask.h */,
 				27A35B642268E118005BE5A8 /* RNFBStorageDownloadTask.m */,
@@ -142,6 +159,11 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				RNFBSTOR0000000000000003 /* RNFBStorageTaskRegistryStorage.swift in Sources */,
+				RNFBSTOR0000000000000006 /* RNFBStorageTaskStatusMapper.swift in Sources */,
+				RNFBSTOR0000000000000008 /* RNFBStorageErrorCodeMapper.swift in Sources */,
+				RNFBSTOR000000000000000A /* RNFBStorageErrorSnapshotDictBuilder.swift in Sources */,
+				RNFBSTOR0000000000000001 /* RNFBStorageTaskRegistry.m in Sources */,
 				27A35B622268E0AB005BE5A8 /* RNFBStorageTask.m in Sources */,
 				27A35B6B2268E1BE005BE5A8 /* RNFBStorageCommon.m in Sources */,
 				2744B98621F45429004F8E3F /* RNFBStorageModule.mm in Sources */,
@@ -172,6 +194,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = dwarf;
+				DEFINES_MODULE = YES;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_DYNAMIC_NO_PIC = NO;
 				GCC_OPTIMIZATION_LEVEL = 0;
@@ -188,6 +211,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = iphoneos;
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 5.10;
 				TARGETED_DEVICE_FAMILY = "1,2";
 			};
 			name = Debug;
@@ -211,6 +235,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				COPY_PHASE_STRIP = NO;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				DEFINES_MODULE = YES;
 				ENABLE_NS_ASSERTIONS = NO;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
@@ -222,6 +247,7 @@
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SDKROOT = iphoneos;
 				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 5.10;
 				TARGETED_DEVICE_FAMILY = "1,2";
 				VALIDATE_PRODUCT = YES;
 			};

package/ios/RNFBStorageUnitTests/RNFBStorageErrorCodeMapperFacadeTests.m

@@ -0,0 +1,91 @@
+/**
+ * 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"
+
+@interface RNFBStorageErrorCodeMapperFacadeTests : XCTestCase
+@end
+
+@implementation RNFBStorageErrorCodeMapperFacadeTests
+
+- (NSError *)errorWithCode:(NSInteger)code description:(NSString *)description {
+  return [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                             code:code
+                         userInfo:@{NSLocalizedDescriptionKey : description}];
+}
+
+- (void)testObjCSelectorNilAndKnownCodes {
+  NSArray *nilPair = [RNFBStorageErrorCodeMapper codeAndMessageForError:nil];
+  XCTAssertEqualObjects(nilPair[0], @"unknown");
+  XCTAssertEqualObjects(nilPair[1], @"An unknown error has occurred.");
+
+  // FIRStorageErrorCodeObjectNotFound
+  NSArray *notFound = [RNFBStorageErrorCodeMapper codeAndMessageForError:[self errorWithCode:-13010
+                                                                                 description:@"x"]];
+  XCTAssertEqualObjects(notFound[0], @"object-not-found");
+  XCTAssertEqualObjects(notFound[1], @"No object exists at the desired reference.");
+
+  // FIRStorageErrorCodeCancelled
+  NSArray *cancelled = [RNFBStorageErrorCodeMapper
+      codeAndMessageForError:[self errorWithCode:-13040 description:@"x"]];
+  XCTAssertEqualObjects(cancelled[0], @"cancelled");
+  XCTAssertEqualObjects(cancelled[1], @"User cancelled the operation.");
+}
+
+- (void)testObjCSelectorUnknownPermissionAndResponseBody {
+  // Permission-denied underlying → invalid-device-file-path
+  NSError *underlying = [NSError
+      errorWithDomain:NSPOSIXErrorDomain
+                 code:1
+             userInfo:@{
+               NSLocalizedDescriptionKey : @"The operation couldn’t be completed. Permission denied"
+             }];
+  NSError *permissionError = [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                                                 code:-13000
+                                             userInfo:@{NSUnderlyingErrorKey : underlying}];
+  NSArray *permissionPair = [RNFBStorageErrorCodeMapper codeAndMessageForError:permissionError];
+  XCTAssertEqualObjects(permissionPair[0], @"invalid-device-file-path");
+  XCTAssertEqualObjects(permissionPair[1],
+                        @"The specified device file path is invalid or is restricted.");
+
+  // ResponseBody → formatted unknown message
+  NSError *bodyError = [NSError errorWithDomain:@"FIRStorageErrorDomain"
+                                           code:-13000
+                                       userInfo:@{@"ResponseBody" : @"backend detail"}];
+  NSArray *bodyPair = [RNFBStorageErrorCodeMapper codeAndMessageForError:bodyError];
+  XCTAssertEqualObjects(bodyPair[0], @"unknown");
+  XCTAssertEqualObjects(bodyPair[1],
+                        @"An unknown error has occurred. (underlying reason 'backend detail')");
+}
+
+- (void)testObjCSelectorDefaultKeepsLocalizedDescription {
+  // FIRStorageErrorCodeInvalidArgument
+  NSArray *pair = [RNFBStorageErrorCodeMapper
+      codeAndMessageForError:[self errorWithCode:-13050 description:@"keep me"]];
+  XCTAssertEqualObjects(pair[0], @"unknown");
+  XCTAssertEqualObjects(pair[1], @"keep me");
+}
+
+- (void)testFacadePublicSelectorUnchanged {
+  XCTAssertTrue([RNFBStorageErrorCodeMapper respondsToSelector:@selector(codeAndMessageForError:)]);
+  NSMethodSignature *signature =
+      [RNFBStorageErrorCodeMapper methodSignatureForSelector:@selector(codeAndMessageForError:)];
+  XCTAssertEqual(strcmp(signature.methodReturnType, @encode(id)), 0);
+}
+
+@end