@react-native-firebase/perf 26.4.0 → 27.0.0

package/ios/RNFBPerfUnitTests/HostStubs/Firebase/FIRPerformanceHostStub.m

@@ -0,0 +1,170 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ */
+#import <Firebase/Firebase.h>
+
+@implementation FIRTrace {
+  NSString *_name;
+  NSMutableDictionary<NSString *, NSNumber *> *_metrics;
+  NSMutableDictionary<NSString *, NSString *> *_attributes;
+}
+
+- (instancetype)initWithName:(NSString *)name {
+  self = [super init];
+  if (self) {
+    _name = [name copy];
+    _metrics = [NSMutableDictionary new];
+    _attributes = [NSMutableDictionary new];
+  }
+  return self;
+}
+
+- (NSString *)name {
+  return _name;
+}
+
+- (NSMutableDictionary<NSString *, NSNumber *> *)metrics {
+  return _metrics;
+}
+
+- (NSMutableDictionary<NSString *, NSString *> *)attributes {
+  return _attributes;
+}
+
+- (void)start {
+  self.startCallCount += 1;
+}
+
+- (void)stop {
+  self.stopCallCount += 1;
+}
+
+- (void)setIntValue:(int64_t)value forMetric:(NSString *)metricName {
+  _metrics[metricName] = @(value);
+}
+
+- (void)setValue:(NSString *)value forAttribute:(NSString *)attributeName {
+  _attributes[attributeName] = value;
+}
+
+@end
+
+@implementation FIRHTTPMetric {
+  NSURL *_url;
+  FIRHTTPMethod _HTTPMethod;
+  NSMutableDictionary<NSString *, NSString *> *_attributes;
+}
+
+- (instancetype)initWithURL:(NSURL *)url HTTPMethod:(FIRHTTPMethod)httpMethod {
+  self = [super init];
+  if (self) {
+    _url = url;
+    _HTTPMethod = httpMethod;
+    _attributes = [NSMutableDictionary new];
+    _responseCode = 0;
+    _requestPayloadSize = 0;
+    _responsePayloadSize = 0;
+    [FIRPerformance recordCreatedHttpMetric:self];
+  }
+  return self;
+}
+
+- (NSURL *)url {
+  return _url;
+}
+
+- (FIRHTTPMethod)HTTPMethod {
+  return _HTTPMethod;
+}
+
+- (NSMutableDictionary<NSString *, NSString *> *)attributes {
+  return _attributes;
+}
+
+- (void)start {
+  self.startCallCount += 1;
+}
+
+- (void)stop {
+  self.stopCallCount += 1;
+}
+
+- (void)setValue:(NSString *)value forAttribute:(NSString *)attributeName {
+  _attributes[attributeName] = value;
+}
+
+- (void)setResponseCode:(NSInteger)responseCode {
+  _responseCode = responseCode;
+}
+
+- (void)setRequestPayloadSize:(NSInteger)bytes {
+  _requestPayloadSize = bytes;
+}
+
+- (void)setResponsePayloadSize:(NSInteger)bytes {
+  _responsePayloadSize = bytes;
+}
+
+- (void)setResponseContentType:(NSString *)contentType {
+  _responseContentType = [contentType copy];
+}
+
+@end
+
+@implementation FIRPerformance
+
+static FIRPerformance *sShared;
+static NSMutableArray<FIRTrace *> *sCreatedTraces;
+static NSMutableArray<FIRHTTPMetric *> *sCreatedHttpMetrics;
+
++ (void)initialize {
+  if (self == [FIRPerformance class]) {
+    sCreatedTraces = [NSMutableArray new];
+    sCreatedHttpMetrics = [NSMutableArray new];
+  }
+}
+
++ (instancetype)sharedInstance {
+  static dispatch_once_t once;
+  dispatch_once(&once, ^{
+    sShared = [[FIRPerformance alloc] init];
+  });
+  return sShared;
+}
+
+- (FIRTrace *)traceWithName:(NSString *)name {
+  FIRTrace *trace = [[FIRTrace alloc] initWithName:name];
+  [sCreatedTraces addObject:trace];
+  return trace;
+}
+
++ (NSArray<FIRTrace *> *)createdTraces {
+  return [sCreatedTraces copy];
+}
+
++ (void)setCreatedTraces:(NSArray<FIRTrace *> *)createdTraces {
+  sCreatedTraces = createdTraces ? [createdTraces mutableCopy] : [NSMutableArray new];
+}
+
++ (NSArray<FIRHTTPMetric *> *)createdHttpMetrics {
+  return [sCreatedHttpMetrics copy];
+}
+
++ (void)setCreatedHttpMetrics:(NSArray<FIRHTTPMetric *> *)createdHttpMetrics {
+  sCreatedHttpMetrics =
+      createdHttpMetrics ? [createdHttpMetrics mutableCopy] : [NSMutableArray new];
+}
+
++ (void)recordCreatedHttpMetric:(FIRHTTPMetric *)metric {
+  [sCreatedHttpMetrics addObject:metric];
+}
+
++ (void)resetTestState {
+  FIRPerformance *shared = [self sharedInstance];
+  shared.dataCollectionEnabled = NO;
+  shared.instrumentationEnabled = NO;
+  [sCreatedTraces removeAllObjects];
+  [sCreatedHttpMetrics removeAllObjects];
+}
+
+@end

package/ios/RNFBPerfUnitTests/HostStubs/Firebase/Firebase.h

@@ -0,0 +1,75 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ * Enough of Firebase Performance for compiling RNFBPerfHelper.m and
+ * asserting SDK call wiring without linking the real SDK.
+ */
+#import <Foundation/Foundation.h>
+
+typedef NS_ENUM(NSInteger, FIRHTTPMethod) {
+  FIRHTTPMethodGET = 0,
+  FIRHTTPMethodPUT = 1,
+  FIRHTTPMethodPOST = 2,
+  FIRHTTPMethodDELETE = 3,
+  FIRHTTPMethodHEAD = 4,
+  FIRHTTPMethodPATCH = 5,
+  FIRHTTPMethodOPTIONS = 6,
+  FIRHTTPMethodTRACE = 7,
+  FIRHTTPMethodCONNECT = 8,
+};
+
+@interface FIRTrace : NSObject
+
+@property(nonatomic, readonly, copy) NSString *name;
+@property(nonatomic, assign) NSUInteger startCallCount;
+@property(nonatomic, assign) NSUInteger stopCallCount;
+@property(nonatomic, readonly, strong) NSMutableDictionary<NSString *, NSNumber *> *metrics;
+@property(nonatomic, readonly, strong) NSMutableDictionary<NSString *, NSString *> *attributes;
+
+- (instancetype)initWithName:(NSString *)name;
+- (void)start;
+- (void)stop;
+- (void)setIntValue:(int64_t)value forMetric:(NSString *)metricName;
+- (void)setValue:(NSString *)value forAttribute:(NSString *)attributeName;
+
+@end
+
+@interface FIRHTTPMetric : NSObject
+
+@property(nonatomic, readonly, copy) NSURL *url;
+@property(nonatomic, readonly, assign) FIRHTTPMethod HTTPMethod;
+@property(nonatomic, assign) NSUInteger startCallCount;
+@property(nonatomic, assign) NSUInteger stopCallCount;
+@property(nonatomic, assign) NSInteger responseCode;
+@property(nonatomic, assign) NSInteger requestPayloadSize;
+@property(nonatomic, assign) NSInteger responsePayloadSize;
+@property(nonatomic, copy, nullable) NSString *responseContentType;
+@property(nonatomic, readonly, strong) NSMutableDictionary<NSString *, NSString *> *attributes;
+
+- (instancetype)initWithURL:(NSURL *)url HTTPMethod:(FIRHTTPMethod)httpMethod;
+- (void)start;
+- (void)stop;
+- (void)setValue:(NSString *)value forAttribute:(NSString *)attributeName;
+- (void)setResponseCode:(NSInteger)responseCode;
+- (void)setRequestPayloadSize:(NSInteger)bytes;
+- (void)setResponsePayloadSize:(NSInteger)bytes;
+- (void)setResponseContentType:(NSString *)contentType;
+
+@end
+
+@interface FIRPerformance : NSObject
+
+@property(nonatomic, assign) BOOL dataCollectionEnabled;
+@property(nonatomic, assign) BOOL instrumentationEnabled;
+
++ (instancetype)sharedInstance;
+
+- (FIRTrace *)traceWithName:(NSString *)name;
+
+/** Test seams */
+@property(class, nonatomic, copy, nullable) NSArray<FIRTrace *> *createdTraces;
+@property(class, nonatomic, copy, nullable) NSArray<FIRHTTPMetric *> *createdHttpMetrics;
+
++ (void)resetTestState;
++ (void)recordCreatedHttpMetric:(FIRHTTPMetric *)metric;
+
+@end

package/ios/RNFBPerfUnitTests/HostStubs/RNFBApp/RNFBSharedUtils.h

@@ -0,0 +1,12 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ */
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+
+@interface RNFBSharedUtils : NSObject
+
++ (void)rejectPromiseWithUserInfo:(RCTPromiseRejectBlock)reject
+                         userInfo:(NSMutableDictionary *)userInfo;
+
+@end

package/ios/RNFBPerfUnitTests/HostStubs/RNFBApp/RNFBSharedUtilsHostStub.m

@@ -0,0 +1,18 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ */
+#import "RNFBApp/RNFBSharedUtils.h"
+
+@implementation RNFBSharedUtils
+
++ (void)rejectPromiseWithUserInfo:(RCTPromiseRejectBlock)reject
+                         userInfo:(NSMutableDictionary *)userInfo {
+  if (reject == nil) {
+    return;
+  }
+  NSString *code = userInfo[@"code"] ?: @"unknown";
+  NSString *message = userInfo[@"message"] ?: @"";
+  reject(code, message, nil);
+}
+
+@end

package/ios/RNFBPerfUnitTests/HostStubs/React/RCTBridgeModule.h

@@ -0,0 +1,10 @@
+/**
+ * Host-only stub for macOS XCTest. Not shipped in the production pod.
+ */
+#import <Foundation/Foundation.h>
+
+typedef void (^RCTPromiseResolveBlock)(id result);
+typedef void (^RCTPromiseRejectBlock)(NSString *code, NSString *message, NSError *error);
+
+@protocol RCTBridgeModule <NSObject>
+@end

package/ios/RNFBPerfUnitTests/RNFBPerfHandleRegistryTests.m

@@ -65,6 +65,13 @@
   XCTAssertEqual(first, [self.registry get:@1]);
 }
 
+- (void)testPut_occupiedId_nilErrorPointer_returnsNO {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@1 value:first error:nil]);
+  XCTAssertFalse([self.registry put:@1 value:[[FakePerfHandle alloc] init] error:nil]);
+  XCTAssertEqual(first, [self.registry get:@1]);
+}
+
 - (void)testPutOrDiscard_collision_dropsIncomingWithoutStop {
   FakePerfHandle *first = [[FakePerfHandle alloc] init];
   FakePerfHandle *duplicate = [[FakePerfHandle alloc] init];
@@ -90,6 +97,45 @@
   XCTAssertEqual(second, [self.registry get:@3]);
 }
 
+- (void)testPutReplacing_whenFree_returnsNil {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  XCTAssertNil([self.registry putReplacing:@7 value:handle]);
+  XCTAssertEqual(handle, [self.registry get:@7]);
+}
+
+- (void)testTakeIf_missingDoesNotCallCondition {
+  __block BOOL conditionCalled = NO;
+  XCTAssertNil([self.registry takeIf:@99
+                                when:^BOOL(id value) {
+                                  (void)value;
+                                  conditionCalled = YES;
+                                  return YES;
+                                }]);
+  XCTAssertFalse(conditionCalled);
+}
+
+- (void)testTakeIf_falseLeavesValue {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@8 value:handle error:nil]);
+  XCTAssertNil([self.registry takeIf:@8
+                                when:^BOOL(id value) {
+                                  XCTAssertEqual(handle, value);
+                                  return NO;
+                                }]);
+  XCTAssertEqual(handle, [self.registry get:@8]);
+}
+
+- (void)testTakeIf_trueRemovesAndReturns {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@9 value:handle error:nil]);
+  XCTAssertEqual(handle, [self.registry takeIf:@9
+                                          when:^BOOL(id value) {
+                                            return value == handle;
+                                          }]);
+  XCTAssertNil([self.registry get:@9]);
+  XCTAssertEqual(handle.stopCount, 0);
+}
+
 - (void)testPutReplacing_moduleCollisionPattern_stopsDisplacedOutsideLock {
   FakePerfHandle *first = [[FakePerfHandle alloc] init];
   FakePerfHandle *second = [[FakePerfHandle alloc] init];

package/ios/RNFBPerfUnitTests/RNFBPerfHelperHostStubTests.m

@@ -0,0 +1,200 @@
+/**
+ * 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 <Firebase/Firebase.h>
+#import "RNFBPerfHandleRegistry.h"
+#import "RNFBPerfHelper.h"
+
+@interface RNFBPerfHelperHostStubTests : XCTestCase
+@property(nonatomic, strong) RNFBPerfHandleRegistry *traces;
+@property(nonatomic, strong) RNFBPerfHandleRegistry *httpMetrics;
+@end
+
+@implementation RNFBPerfHelperHostStubTests
+
+- (void)setUp {
+  [super setUp];
+  [FIRPerformance resetTestState];
+  self.traces = [[RNFBPerfHandleRegistry alloc] init];
+  self.httpMetrics = [[RNFBPerfHandleRegistry alloc] init];
+}
+
+- (void)tearDown {
+  [FIRPerformance resetTestState];
+  self.traces = nil;
+  self.httpMetrics = nil;
+  [super tearDown];
+}
+
+- (void)testConstantsDictionary_reflectsSharedInstanceFlags {
+  [FIRPerformance sharedInstance].dataCollectionEnabled = YES;
+  [FIRPerformance sharedInstance].instrumentationEnabled = YES;
+
+  NSDictionary *constants = [RNFBPerfHelper constantsDictionary];
+  XCTAssertEqualObjects(constants[@"isPerformanceCollectionEnabled"], @YES);
+  XCTAssertEqualObjects(constants[@"isInstrumentationEnabled"], @YES);
+}
+
+- (void)testSetPerformanceCollectionEnabled_setsFlagAndResolves {
+  __block id resolved = @"unset";
+  __block BOOL rejected = NO;
+
+  [RNFBPerfHelper setPerformanceCollectionEnabled:YES
+      resolve:^(id result) {
+        resolved = result;
+      }
+      reject:^(NSString *code, NSString *message, NSError *error) {
+        (void)code;
+        (void)message;
+        (void)error;
+        rejected = YES;
+      }];
+
+  XCTAssertFalse(rejected);
+  XCTAssertEqualObjects(resolved, [NSNull null]);
+  XCTAssertTrue([FIRPerformance sharedInstance].dataCollectionEnabled);
+}
+
+- (void)testSetInstrumentationEnabled_setsFlagAndResolves {
+  __block id resolved = @"unset";
+
+  [RNFBPerfHelper setInstrumentationEnabled:YES
+      resolve:^(id result) {
+        resolved = result;
+      }
+      reject:^(NSString *code, NSString *message, NSError *error) {
+        (void)code;
+        (void)message;
+        (void)error;
+        XCTFail(@"unexpected reject");
+      }];
+
+  XCTAssertEqualObjects(resolved, [NSNull null]);
+  XCTAssertTrue([FIRPerformance sharedInstance].instrumentationEnabled);
+}
+
+- (void)testStartTrace_startsAndStoresHandle {
+  [RNFBPerfHelper startTraceWithId:@1 identifier:@"trace-a" inRegistry:self.traces];
+
+  FIRTrace *trace = [self.traces get:@1];
+  XCTAssertNotNil(trace);
+  XCTAssertEqualObjects(trace.name, @"trace-a");
+  XCTAssertEqual(trace.startCallCount, 1u);
+  XCTAssertEqual(FIRPerformance.createdTraces.count, 1u);
+}
+
+- (void)testStartTrace_displacesPreviousAndStopsIt {
+  [RNFBPerfHelper startTraceWithId:@1 identifier:@"first" inRegistry:self.traces];
+  FIRTrace *first = [self.traces get:@1];
+
+  [RNFBPerfHelper startTraceWithId:@1 identifier:@"second" inRegistry:self.traces];
+  FIRTrace *second = [self.traces get:@1];
+
+  XCTAssertNotEqual(first, second);
+  XCTAssertEqual(first.stopCallCount, 1u);
+  XCTAssertEqual(second.startCallCount, 1u);
+  XCTAssertEqualObjects(second.name, @"second");
+}
+
+- (void)testStopTrace_appliesMetricsAttributesAndStops {
+  [RNFBPerfHelper startTraceWithId:@7 identifier:@"stop-me" inRegistry:self.traces];
+  FIRTrace *trace = [self.traces get:@7];
+
+  [RNFBPerfHelper stopTraceWithId:@7
+                          metrics:@{@"bytes" : @42}
+                       attributes:@{@"screen" : @"home"}
+                       inRegistry:self.traces];
+
+  XCTAssertNil([self.traces get:@7]);
+  XCTAssertEqualObjects(trace.metrics[@"bytes"], @42);
+  XCTAssertEqualObjects(trace.attributes[@"screen"], @"home");
+  XCTAssertEqual(trace.stopCallCount, 1u);
+}
+
+- (void)testStopTrace_missingHandle_isNoOp {
+  [RNFBPerfHelper stopTraceWithId:@99 metrics:@{@"m" : @1} attributes:nil inRegistry:self.traces];
+  XCTAssertEqual(FIRPerformance.createdTraces.count, 0u);
+}
+
+- (void)testStartHttpMetric_mapsMethodStartsAndStores {
+  [RNFBPerfHelper startHttpMetricWithId:@3
+                                    url:@"https://example.com/api"
+                             httpMethod:@"POST"
+                             inRegistry:self.httpMetrics];
+
+  FIRHTTPMetric *metric = [self.httpMetrics get:@3];
+  XCTAssertNotNil(metric);
+  XCTAssertEqualObjects(metric.url.absoluteString, @"https://example.com/api");
+  XCTAssertEqual(metric.HTTPMethod, FIRHTTPMethodPOST);
+  XCTAssertEqual(metric.startCallCount, 1u);
+}
+
+- (void)testStartHttpMetric_displacesPreviousAndStopsIt {
+  [RNFBPerfHelper startHttpMetricWithId:@3
+                                    url:@"https://example.com/a"
+                             httpMethod:@"GET"
+                             inRegistry:self.httpMetrics];
+  FIRHTTPMetric *first = [self.httpMetrics get:@3];
+
+  [RNFBPerfHelper startHttpMetricWithId:@3
+                                    url:@"https://example.com/b"
+                             httpMethod:@"PUT"
+                             inRegistry:self.httpMetrics];
+  FIRHTTPMetric *second = [self.httpMetrics get:@3];
+
+  XCTAssertNotEqual(first, second);
+  XCTAssertEqual(first.stopCallCount, 1u);
+  XCTAssertEqual(second.HTTPMethod, FIRHTTPMethodPUT);
+}
+
+- (void)testStopHttpMetric_appliesFieldsAndStops {
+  [RNFBPerfHelper startHttpMetricWithId:@4
+                                    url:@"https://example.com"
+                             httpMethod:@"GET"
+                             inRegistry:self.httpMetrics];
+  FIRHTTPMetric *metric = [self.httpMetrics get:@4];
+
+  [RNFBPerfHelper stopHttpMetricWithId:@4
+                            attributes:@{@"route" : @"/v1"}
+                      httpResponseCode:@204
+                    requestPayloadSize:@10
+                   responsePayloadSize:@20
+                   responseContentType:@"application/json"
+                            inRegistry:self.httpMetrics];
+
+  XCTAssertNil([self.httpMetrics get:@4]);
+  XCTAssertEqualObjects(metric.attributes[@"route"], @"/v1");
+  XCTAssertEqual(metric.responseCode, 204);
+  XCTAssertEqual(metric.requestPayloadSize, 10);
+  XCTAssertEqual(metric.responsePayloadSize, 20);
+  XCTAssertEqualObjects(metric.responseContentType, @"application/json");
+  XCTAssertEqual(metric.stopCallCount, 1u);
+}
+
+- (void)testStopHttpMetric_missingHandle_isNoOp {
+  [RNFBPerfHelper stopHttpMetricWithId:@88
+                            attributes:nil
+                      httpResponseCode:@200
+                    requestPayloadSize:nil
+                   responsePayloadSize:nil
+                   responseContentType:nil
+                            inRegistry:self.httpMetrics];
+  XCTAssertEqual(FIRPerformance.createdHttpMetrics.count, 0u);
+}
+
+@end

package/ios/RNFBPerfUnitTests/RNFBPerfHttpMethodMapperFacadeTests.m

@@ -0,0 +1,52 @@
+/**
+ * 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 RNFBPerfHttpMethodMapperFacadeTests : XCTestCase
+@end
+
+@implementation RNFBPerfHttpMethodMapperFacadeTests
+
+- (void)testObjCSelectorMapsKnownMethods {
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"put"], 1);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"POST"], 2);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"delete"], 3);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"HEAD"], 4);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"patch"], 5);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"OPTIONS"], 6);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"trace"], 7);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"CONNECT"], 8);
+}
+
+- (void)testObjCSelectorDefaultsUnknownNilEmptyGetToGet {
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"get"], 0);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@"bogus"], 0);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:@""], 0);
+  XCTAssertEqual([RNFBPerfHttpMethodMapper httpMethodRawValueForString:nil], 0);
+}
+
+- (void)testFacadePublicSelectorUnchanged {
+  XCTAssertTrue(
+      [RNFBPerfHttpMethodMapper respondsToSelector:@selector(httpMethodRawValueForString:)]);
+  NSMethodSignature *signature =
+      [RNFBPerfHttpMethodMapper methodSignatureForSelector:@selector(httpMethodRawValueForString:)];
+  XCTAssertEqual(strcmp(signature.methodReturnType, @encode(NSInteger)), 0);
+}
+
+@end

package/ios/RNFBPerfUnitTests/RNFBPerfHttpMethodMapperTests.swift

@@ -0,0 +1,92 @@
+/**
+ * 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 RNFBPerfHttpMethodMapperTests: XCTestCase {
+  /// `FIRHTTPMethodGET`
+  private let getMethod = 0
+  /// `FIRHTTPMethodPUT`
+  private let putMethod = 1
+  /// `FIRHTTPMethodPOST`
+  private let postMethod = 2
+  /// `FIRHTTPMethodDELETE`
+  private let deleteMethod = 3
+  /// `FIRHTTPMethodHEAD`
+  private let headMethod = 4
+  /// `FIRHTTPMethodPATCH`
+  private let patchMethod = 5
+  /// `FIRHTTPMethodOPTIONS`
+  private let optionsMethod = 6
+  /// `FIRHTTPMethodTRACE`
+  private let traceMethod = 7
+  /// `FIRHTTPMethodCONNECT`
+  private let connectMethod = 8
+
+  func testPutMapsToPut() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "put"), putMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "PUT"), putMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "Put"), putMethod)
+  }
+
+  func testPostMapsToPost() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "post"), postMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "POST"), postMethod)
+  }
+
+  func testHeadMapsToHead() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "head"), headMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "HEAD"), headMethod)
+  }
+
+  func testTraceMapsToTrace() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "trace"), traceMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "TRACE"), traceMethod)
+  }
+
+  func testPatchMapsToPatch() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "patch"), patchMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "PATCH"), patchMethod)
+  }
+
+  func testDeleteMapsToDelete() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "delete"), deleteMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "DELETE"), deleteMethod)
+  }
+
+  func testOptionsMapsToOptions() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "options"), optionsMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "OPTIONS"), optionsMethod)
+  }
+
+  func testConnectMapsToConnect() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "connect"), connectMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "CONNECT"), connectMethod)
+  }
+
+  func testGetAndUnknownDefaultToGet() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "get"), getMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "GET"), getMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "bogus"), getMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: "unknown"), getMethod)
+  }
+
+  func testNilAndEmptyDefaultToGet() {
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: nil), getMethod)
+    XCTAssertEqual(RNFBPerfHttpMethodMapper.httpMethodRawValue(forString: ""), getMethod)
+  }
+}