@react-native-firebase/perf 26.3.3 → 27.0.0

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

@@ -0,0 +1,169 @@
+/**
+ * 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 "RNFBHandleMap.h"
+#import "RNFBPerfHandleRegistry.h"
+
+@interface FakePerfHandle : NSObject
+@property(nonatomic, assign) NSInteger stopCount;
+- (void)stop;
+@end
+
+@implementation FakePerfHandle
+- (void)stop {
+  self.stopCount += 1;
+}
+@end
+
+@interface RNFBPerfHandleRegistryTests : XCTestCase
+@property(nonatomic, strong) RNFBPerfHandleRegistry *registry;
+@end
+
+@implementation RNFBPerfHandleRegistryTests
+
+- (void)setUp {
+  [super setUp];
+  self.registry = [[RNFBPerfHandleRegistry alloc] init];
+}
+
+- (void)testPutGetTake_happyPath {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  NSError *error = nil;
+  XCTAssertTrue([self.registry put:@1 value:handle error:&error]);
+  XCTAssertNil(error);
+  XCTAssertEqual(handle, [self.registry get:@1]);
+  XCTAssertEqual(handle, [self.registry take:@1]);
+  XCTAssertNil([self.registry get:@1]);
+  XCTAssertEqual(handle.stopCount, 0);
+}
+
+- (void)testPut_occupiedId_returnsCollision {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@1 value:first error:nil]);
+
+  NSError *error = nil;
+  XCTAssertFalse([self.registry put:@1 value:[[FakePerfHandle alloc] init] error:&error]);
+  XCTAssertNotNil(error);
+  XCTAssertEqualObjects(error.domain, RNFBHandleMapErrorDomain);
+  XCTAssertEqual(error.code, RNFBHandleMapErrorCollision);
+  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];
+  XCTAssertTrue([self.registry put:@1 value:first error:nil]);
+  XCTAssertFalse([self.registry putOrDiscard:@1 value:duplicate]);
+  XCTAssertEqual(duplicate.stopCount, 0);
+  XCTAssertEqual(first.stopCount, 0);
+  XCTAssertEqual(first, [self.registry get:@1]);
+}
+
+- (void)testPutOrDiscard_storesWhenFree {
+  FakePerfHandle *handle = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry putOrDiscard:@2 value:handle]);
+  XCTAssertEqual(handle, [self.registry get:@2]);
+  XCTAssertEqual(handle.stopCount, 0);
+}
+
+- (void)testPutReplacing_whenOccupied_returnsDisplaced {
+  FakePerfHandle *first = [[FakePerfHandle alloc] init];
+  FakePerfHandle *second = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@3 value:first error:nil]);
+  XCTAssertEqual(first, [self.registry putReplacing:@3 value:second]);
+  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];
+  XCTAssertTrue([self.registry put:@6 value:first error:nil]);
+  FakePerfHandle *displaced = [self.registry putReplacing:@6 value:second];
+  if (displaced != nil) {
+    [displaced stop];
+  }
+  XCTAssertEqual(first.stopCount, 1);
+  XCTAssertEqual(second.stopCount, 0);
+  XCTAssertEqual(second, [self.registry get:@6]);
+}
+
+- (void)testTakeAll_returnsSnapshotAndLeavesEmpty {
+  FakePerfHandle *a = [[FakePerfHandle alloc] init];
+  FakePerfHandle *b = [[FakePerfHandle alloc] init];
+  XCTAssertTrue([self.registry put:@4 value:a error:nil]);
+  XCTAssertTrue([self.registry put:@5 value:b error:nil]);
+  NSArray *remaining = [self.registry takeAll];
+  XCTAssertEqual(remaining.count, 2);
+  XCTAssertNil([self.registry get:@4]);
+  XCTAssertNil([self.registry get:@5]);
+  XCTAssertEqual(a.stopCount, 0);
+  XCTAssertEqual(b.stopCount, 0);
+}
+
+- (void)testGet_whenFree_isNil {
+  XCTAssertNil([self.registry get:@99]);
+}
+
+@end

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)
+  }
+}

package/ios/RNFBPerfUnitTests/RNFBPerfHttpMetricStopApplierFacadeTests.m

@@ -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 <XCTest/XCTest.h>
+
+#import "RNFBHandleMapStorage-Swift.inc"
+
+@interface RNFBPerfHttpMetricStopApplierFacadeStub : NSObject <RNFBPerfHttpMetricApplying>
+@property(nonatomic, strong) NSMutableArray<NSDictionary *> *calls;
+@end
+
+@implementation RNFBPerfHttpMetricStopApplierFacadeStub
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _calls = [NSMutableArray array];
+  }
+  return self;
+}
+
+- (void)setValue:(NSString *)value forAttribute:(NSString *)attributeName {
+  [self.calls addObject:@{@"kind" : @"attribute", @"name" : attributeName, @"value" : value}];
+}
+
+- (void)setResponseCode:(NSInteger)responseCode {
+  [self.calls addObject:@{@"kind" : @"responseCode", @"value" : @(responseCode)}];
+}
+
+- (void)setRequestPayloadSize:(NSInteger)bytes {
+  [self.calls addObject:@{@"kind" : @"requestPayloadSize", @"value" : @(bytes)}];
+}
+
+- (void)setResponsePayloadSize:(NSInteger)bytes {
+  [self.calls addObject:@{@"kind" : @"responsePayloadSize", @"value" : @(bytes)}];
+}
+
+- (void)setResponseContentType:(NSString *)contentType {
+  [self.calls addObject:@{@"kind" : @"responseContentType", @"value" : contentType}];
+}
+@end
+
+@interface RNFBPerfHttpMetricStopApplierFacadeTests : XCTestCase
+@end
+
+@implementation RNFBPerfHttpMetricStopApplierFacadeTests
+
+- (void)testObjCSelectorAppliesAttributesThenOptionals {
+  RNFBPerfHttpMetricStopApplierFacadeStub *stub =
+      [[RNFBPerfHttpMetricStopApplierFacadeStub alloc] init];
+  NSDictionary *attributes = @{@"a1" : @"v1"};
+
+  [RNFBPerfHttpMetricStopApplier applyAttributes:attributes
+                                httpResponseCode:@200
+                              requestPayloadSize:@11
+                             responsePayloadSize:@22
+                             responseContentType:@"application/json"
+                                              to:stub];
+
+  XCTAssertEqual(stub.calls.count, 5u);
+  XCTAssertEqualObjects(stub.calls[0][@"kind"], @"attribute");
+  XCTAssertEqualObjects(stub.calls[0][@"name"], @"a1");
+  XCTAssertEqualObjects(stub.calls[0][@"value"], @"v1");
+  XCTAssertEqualObjects(stub.calls[1][@"kind"], @"responseCode");
+  XCTAssertEqualObjects(stub.calls[1][@"value"], @200);
+  XCTAssertEqualObjects(stub.calls[2][@"kind"], @"requestPayloadSize");
+  XCTAssertEqualObjects(stub.calls[2][@"value"], @11);
+  XCTAssertEqualObjects(stub.calls[3][@"kind"], @"responsePayloadSize");
+  XCTAssertEqualObjects(stub.calls[3][@"value"], @22);
+  XCTAssertEqualObjects(stub.calls[4][@"kind"], @"responseContentType");
+  XCTAssertEqualObjects(stub.calls[4][@"value"], @"application/json");
+}
+
+- (void)testObjCSelectorNilFieldsAreNoOps {
+  RNFBPerfHttpMetricStopApplierFacadeStub *stub =
+      [[RNFBPerfHttpMetricStopApplierFacadeStub alloc] init];
+  [RNFBPerfHttpMetricStopApplier applyAttributes:nil
+                                httpResponseCode:nil
+                              requestPayloadSize:nil
+                             responsePayloadSize:nil
+                             responseContentType:nil
+                                              to:stub];
+  XCTAssertEqual(stub.calls.count, 0u);
+}
+
+- (void)testFacadePublicSelectorUnchanged {
+  XCTAssertTrue([RNFBPerfHttpMetricStopApplier
+      respondsToSelector:@selector
+      (applyAttributes:
+          httpResponseCode:requestPayloadSize:responsePayloadSize:responseContentType:to:)]);
+}
+
+@end