@react-native-firebase/perf 26.3.3 → 27.0.0

package/ios/RNFBPerfUnitTests/RNFBPerfHttpMetricStopApplierTests.swift

@@ -0,0 +1,201 @@
+/**
+ * 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
+
+private enum HttpMetricApplyCall: Equatable {
+  case attribute(name: String, value: String)
+  case responseCode(Int)
+  case requestPayloadSize(Int)
+  case responsePayloadSize(Int)
+  case responseContentType(String)
+}
+
+private final class StubHttpMetric: NSObject, RNFBPerfHttpMetricApplying {
+  private(set) var calls: [HttpMetricApplyCall] = []
+
+  func setValue(_ value: String, forAttribute attributeName: String) {
+    calls.append(.attribute(name: attributeName, value: value))
+  }
+
+  func setResponseCode(_ responseCode: Int) {
+    calls.append(.responseCode(responseCode))
+  }
+
+  func setRequestPayloadSize(_ bytes: Int) {
+    calls.append(.requestPayloadSize(bytes))
+  }
+
+  func setResponsePayloadSize(_ bytes: Int) {
+    calls.append(.responsePayloadSize(bytes))
+  }
+
+  func setResponseContentType(_ contentType: String) {
+    calls.append(.responseContentType(contentType))
+  }
+}
+
+final class RNFBPerfHttpMetricStopApplierTests: XCTestCase {
+  func testAppliesAttributesThenOptionalFieldsInOrder() {
+    let metric = StubHttpMetric()
+    let attributes: NSDictionary = [
+      "attr_a": "alpha",
+      "attr_b": "beta",
+    ]
+
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: attributes,
+      httpResponseCode: NSNumber(value: 200),
+      requestPayloadSize: NSNumber(value: 128),
+      responsePayloadSize: NSNumber(value: 256),
+      responseContentType: "application/json",
+      to: metric
+    )
+
+    let attributeCalls = metric.calls.compactMap { call -> (String, String)? in
+      if case let .attribute(name, value) = call { return (name, value) }
+      return nil
+    }
+    XCTAssertEqual(attributeCalls.count, 2)
+    XCTAssertEqual(Dictionary(uniqueKeysWithValues: attributeCalls)["attr_a"], "alpha")
+    XCTAssertEqual(Dictionary(uniqueKeysWithValues: attributeCalls)["attr_b"], "beta")
+
+    let nonAttributeCalls = metric.calls.filter {
+      if case .attribute = $0 { return false }
+      return true
+    }
+    XCTAssertEqual(
+      nonAttributeCalls,
+      [
+        .responseCode(200),
+        .requestPayloadSize(128),
+        .responsePayloadSize(256),
+        .responseContentType("application/json"),
+      ]
+    )
+
+    let lastAttributeIndex = metric.calls.lastIndex {
+      if case .attribute = $0 { return true }
+      return false
+    }
+    let firstOptionalIndex = metric.calls.firstIndex {
+      if case .attribute = $0 { return false }
+      return true
+    }
+    XCTAssertNotNil(lastAttributeIndex)
+    XCTAssertNotNil(firstOptionalIndex)
+    XCTAssertLessThan(lastAttributeIndex!, firstOptionalIndex!)
+  }
+
+  func testNilAttributesAndNilOptionalsAreNoOps() {
+    let metric = StubHttpMetric()
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: nil,
+      httpResponseCode: nil,
+      requestPayloadSize: nil,
+      responsePayloadSize: nil,
+      responseContentType: nil,
+      to: metric
+    )
+    XCTAssertTrue(metric.calls.isEmpty)
+  }
+
+  func testEmptyAttributesDictionaryIsNoOp() {
+    let metric = StubHttpMetric()
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: [:],
+      httpResponseCode: nil,
+      requestPayloadSize: nil,
+      responsePayloadSize: nil,
+      responseContentType: nil,
+      to: metric
+    )
+    XCTAssertTrue(metric.calls.isEmpty)
+  }
+
+  func testAttributesOnly() {
+    let metric = StubHttpMetric()
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: ["region": "us"],
+      httpResponseCode: nil,
+      requestPayloadSize: nil,
+      responsePayloadSize: nil,
+      responseContentType: nil,
+      to: metric
+    )
+    XCTAssertEqual(metric.calls, [.attribute(name: "region", value: "us")])
+  }
+
+  func testOptionalsOnlySkipsMissingFields() {
+    let metric = StubHttpMetric()
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: nil,
+      httpResponseCode: NSNumber(value: 404),
+      requestPayloadSize: nil,
+      responsePayloadSize: NSNumber(value: 10),
+      responseContentType: nil,
+      to: metric
+    )
+    XCTAssertEqual(
+      metric.calls,
+      [
+        .responseCode(404),
+        .responsePayloadSize(10),
+      ]
+    )
+  }
+
+  func testSkipsNonStringAttributeValues() {
+    let metric = StubHttpMetric()
+    let attributes: NSDictionary = [
+      "ok": "yes",
+      "bad": NSNumber(value: 9),
+    ]
+
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: attributes,
+      httpResponseCode: nil,
+      requestPayloadSize: nil,
+      responsePayloadSize: nil,
+      responseContentType: nil,
+      to: metric
+    )
+
+    XCTAssertEqual(metric.calls, [.attribute(name: "ok", value: "yes")])
+  }
+
+  func testNSNumberIntValuesPassedThrough() {
+    let metric = StubHttpMetric()
+    RNFBPerfHttpMetricStopApplier.apply(
+      attributes: nil,
+      httpResponseCode: NSNumber(value: Int32.max),
+      requestPayloadSize: NSNumber(value: 0),
+      responsePayloadSize: NSNumber(value: -1),
+      responseContentType: "text/plain",
+      to: metric
+    )
+    XCTAssertEqual(
+      metric.calls,
+      [
+        .responseCode(Int(Int32.max)),
+        .requestPayloadSize(0),
+        .responsePayloadSize(-1),
+        .responseContentType("text/plain"),
+      ]
+    )
+  }
+}

package/ios/RNFBPerfUnitTests/RNFBPerfTraceStopApplierFacadeTests.m

@@ -0,0 +1,75 @@
+/**
+ * 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 RNFBPerfTraceStopApplierFacadeStub : NSObject <RNFBPerfTraceApplying>
+@property(nonatomic, strong) NSMutableArray<NSDictionary *> *calls;
+@end
+
+@implementation RNFBPerfTraceStopApplierFacadeStub
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _calls = [NSMutableArray array];
+  }
+  return self;
+}
+
+- (void)setIntValue:(int64_t)value forMetric:(NSString *)metricName {
+  [self.calls addObject:@{@"kind" : @"metric", @"name" : metricName, @"value" : @(value)}];
+}
+
+- (void)setValue:(NSString *)value forAttribute:(NSString *)attributeName {
+  [self.calls addObject:@{@"kind" : @"attribute", @"name" : attributeName, @"value" : value}];
+}
+@end
+
+@interface RNFBPerfTraceStopApplierFacadeTests : XCTestCase
+@end
+
+@implementation RNFBPerfTraceStopApplierFacadeTests
+
+- (void)testObjCSelectorAppliesMetricsThenAttributes {
+  RNFBPerfTraceStopApplierFacadeStub *stub = [[RNFBPerfTraceStopApplierFacadeStub alloc] init];
+  NSDictionary *metrics = @{@"m1" : @11};
+  NSDictionary *attributes = @{@"a1" : @"v1"};
+
+  [RNFBPerfTraceStopApplier applyMetrics:metrics attributes:attributes to:stub];
+
+  XCTAssertEqual(stub.calls.count, 2u);
+  XCTAssertEqualObjects(stub.calls[0][@"kind"], @"metric");
+  XCTAssertEqualObjects(stub.calls[0][@"name"], @"m1");
+  XCTAssertEqualObjects(stub.calls[0][@"value"], @11);
+  XCTAssertEqualObjects(stub.calls[1][@"kind"], @"attribute");
+  XCTAssertEqualObjects(stub.calls[1][@"name"], @"a1");
+  XCTAssertEqualObjects(stub.calls[1][@"value"], @"v1");
+}
+
+- (void)testObjCSelectorNilDictionariesAreNoOps {
+  RNFBPerfTraceStopApplierFacadeStub *stub = [[RNFBPerfTraceStopApplierFacadeStub alloc] init];
+  [RNFBPerfTraceStopApplier applyMetrics:nil attributes:nil to:stub];
+  XCTAssertEqual(stub.calls.count, 0u);
+}
+
+- (void)testFacadePublicSelectorUnchanged {
+  XCTAssertTrue([RNFBPerfTraceStopApplier respondsToSelector:@selector(applyMetrics:
+                                                                         attributes:to:)]);
+}
+
+@end

package/ios/RNFBPerfUnitTests/RNFBPerfTraceStopApplierTests.swift

@@ -0,0 +1,142 @@
+/**
+ * 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
+
+private enum TraceApplyCall: Equatable {
+  case metric(name: String, value: Int64)
+  case attribute(name: String, value: String)
+}
+
+private final class StubTrace: NSObject, RNFBPerfTraceApplying {
+  private(set) var calls: [TraceApplyCall] = []
+
+  func setIntValue(_ value: Int64, forMetric metricName: String) {
+    calls.append(.metric(name: metricName, value: value))
+  }
+
+  func setValue(_ value: String, forAttribute attributeName: String) {
+    calls.append(.attribute(name: attributeName, value: value))
+  }
+}
+
+final class RNFBPerfTraceStopApplierTests: XCTestCase {
+  func testAppliesMetricsThenAttributes() {
+    let trace = StubTrace()
+    let metrics: NSDictionary = [
+      "metric_a": NSNumber(value: 42),
+      "metric_b": NSNumber(value: Int64(-7)),
+    ]
+    let attributes: NSDictionary = [
+      "attr_a": "alpha",
+      "attr_b": "beta",
+    ]
+
+    RNFBPerfTraceStopApplier.apply(metrics: metrics, attributes: attributes, to: trace)
+
+    let metricCalls = trace.calls.compactMap { call -> (String, Int64)? in
+      if case let .metric(name, value) = call { return (name, value) }
+      return nil
+    }
+    let attributeCalls = trace.calls.compactMap { call -> (String, String)? in
+      if case let .attribute(name, value) = call { return (name, value) }
+      return nil
+    }
+
+    XCTAssertEqual(metricCalls.count, 2)
+    XCTAssertEqual(attributeCalls.count, 2)
+    XCTAssertEqual(Dictionary(uniqueKeysWithValues: metricCalls)["metric_a"], 42)
+    XCTAssertEqual(Dictionary(uniqueKeysWithValues: metricCalls)["metric_b"], -7)
+    XCTAssertEqual(Dictionary(uniqueKeysWithValues: attributeCalls)["attr_a"], "alpha")
+    XCTAssertEqual(Dictionary(uniqueKeysWithValues: attributeCalls)["attr_b"], "beta")
+
+    // Metrics finish before any attribute (pre-port order).
+    let firstAttributeIndex = trace.calls.firstIndex { call in
+      if case .attribute = call { return true }
+      return false
+    }
+    let lastMetricIndex = trace.calls.lastIndex { call in
+      if case .metric = call { return true }
+      return false
+    }
+    XCTAssertNotNil(firstAttributeIndex)
+    XCTAssertNotNil(lastMetricIndex)
+    XCTAssertLessThan(lastMetricIndex!, firstAttributeIndex!)
+  }
+
+  func testNilDictionariesAreNoOps() {
+    let trace = StubTrace()
+    RNFBPerfTraceStopApplier.apply(metrics: nil, attributes: nil, to: trace)
+    XCTAssertTrue(trace.calls.isEmpty)
+  }
+
+  func testEmptyDictionariesAreNoOps() {
+    let trace = StubTrace()
+    RNFBPerfTraceStopApplier.apply(metrics: [:], attributes: [:], to: trace)
+    XCTAssertTrue(trace.calls.isEmpty)
+  }
+
+  func testMetricsOnly() {
+    let trace = StubTrace()
+    RNFBPerfTraceStopApplier.apply(
+      metrics: ["bytes": NSNumber(value: Int64(1_024))],
+      attributes: nil,
+      to: trace
+    )
+    XCTAssertEqual(trace.calls, [.metric(name: "bytes", value: 1024)])
+  }
+
+  func testAttributesOnly() {
+    let trace = StubTrace()
+    RNFBPerfTraceStopApplier.apply(
+      metrics: nil,
+      attributes: ["region": "us"],
+      to: trace
+    )
+    XCTAssertEqual(trace.calls, [.attribute(name: "region", value: "us")])
+  }
+
+  func testSkipsNonNumberMetricValuesAndNonStringAttributeValues() {
+    let trace = StubTrace()
+    let metrics: NSDictionary = [
+      "ok": NSNumber(value: 1),
+      "bad": "not-a-number",
+    ]
+    let attributes: NSDictionary = [
+      "ok": "yes",
+      "bad": NSNumber(value: 9),
+    ]
+
+    RNFBPerfTraceStopApplier.apply(metrics: metrics, attributes: attributes, to: trace)
+
+    XCTAssertEqual(trace.calls, [
+      .metric(name: "ok", value: 1),
+      .attribute(name: "ok", value: "yes"),
+    ])
+  }
+
+  func testLongLongMetricValues() {
+    let trace = StubTrace()
+    let big = Int64.max
+    RNFBPerfTraceStopApplier.apply(
+      metrics: ["max": NSNumber(value: big)],
+      attributes: nil,
+      to: trace
+    )
+    XCTAssertEqual(trace.calls, [.metric(name: "max", value: big)])
+  }
+}