test(crashlytics, ios): cover JS fatal exit before context init and correct header limits

Author: Mastersam07

packages/crashlytics/ios/RNFBCrashlytics/RNFBCrashlyticsHelper.h

@@ -71,9 +71,10 @@ FOUNDATION_EXPORT const NSTimeInterval RNFBCrashlyticsFatalExitWatchdogTimeout;
  * is hung. The terminator runs at most once.
  *
  * Known limit: a JS fatal recorded before Crashlytics finished initialising queues its save as a
- * promise observer instead of a main-queue block, so it can still be lost (unchanged behaviour).
- * The FIFO ordering also relies on FBLPromise's default dispatch queue being the main queue; if
- * that changes, only the watchdog bounds the wait.
+ * promise observer instead of a main-queue block, so it can still be lost.
+ * The FIFO ordering also relies on FBLPromise's default dispatch queue being the main queue; if an
+ * app changes it, the save runs off the main queue and the terminator can run first, losing the
+ * report. The watchdog only covers a hung `terminateQueue`.
  */
 @interface RNFBCrashlyticsFatalExit : NSObject
 

packages/crashlytics/ios/RNFBCrashlyticsUnitTests/HostStubs/Firebase/FIRCrashlyticsHostStub.m

@@ -66,6 +66,8 @@ @implementation FIRCrashlytics
 static FIRExceptionModel *sLastRecordedExceptionModel;
 static NSMutableArray<FIRExceptionModel *> *sSavedExceptionModels;
 static void (^sOnExceptionModelSaved)(FIRExceptionModel *);
+static BOOL sContextInitPending;
+static NSMutableArray<dispatch_block_t> *sPendingSaves;
 // Bumped by resetTestState so saves enqueued by an earlier test are dropped.
 static atomic_uint_fast64_t sSaveGeneration;
 
@@ -74,6 +76,7 @@ + (void)initialize {
     sLoggedMessages = [NSMutableArray new];
     sCustomValues = [NSMutableDictionary new];
     sSavedExceptionModels = [NSMutableArray new];
+    sPendingSaves = [NSMutableArray new];
   }
 }
 
@@ -168,6 +171,24 @@ + (void)setOnExceptionModelSaved:(void (^)(FIRExceptionModel *))onExceptionModel
   sOnExceptionModelSaved = [onExceptionModelSaved copy];
 }
 
++ (void)holdContextInit {
+  @synchronized(sPendingSaves) {
+    sContextInitPending = YES;
+  }
+}
+
++ (void)fulfillContextInit {
+  NSArray<dispatch_block_t> *saves;
+  @synchronized(sPendingSaves) {
+    sContextInitPending = NO;
+    saves = [sPendingSaves copy];
+    [sPendingSaves removeAllObjects];
+  }
+  for (dispatch_block_t save in saves) {
+    dispatch_async(dispatch_get_main_queue(), save);
+  }
+}
+
 + (void)resetTestState {
   sDidCrashDuringPreviousExecutionValue = NO;
   sCheckForUnsentReportsValue = NO;
@@ -179,6 +200,10 @@ + (void)resetTestState {
   sLastRecordedExceptionModel = nil;
   [sSavedExceptionModels removeAllObjects];
   sOnExceptionModelSaved = nil;
+  @synchronized(sPendingSaves) {
+    sContextInitPending = NO;
+    [sPendingSaves removeAllObjects];
+  }
   atomic_fetch_add(&sSaveGeneration, 1);
 }
 
@@ -224,17 +249,25 @@ - (void)setUserID:(NSString *)userID {
 - (void)recordExceptionModel:(FIRExceptionModel *)exceptionModel {
   sLastRecordedExceptionModel = exceptionModel;
   // Mirrors FirebaseCrashlytics: once context init is fulfilled, the save block is dispatched to
-  // the main queue and writes synchronously when it runs.
+  // the main queue and writes synchronously when it runs. While init is pending, FBLPromise holds
+  // the block as an observer and dispatches it to the main queue only when the promise fulfills.
   uint_fast64_t generation = atomic_load(&sSaveGeneration);
-  dispatch_async(dispatch_get_main_queue(), ^{
+  dispatch_block_t save = ^{
     if (generation != atomic_load(&sSaveGeneration)) {
       return;
     }
     [sSavedExceptionModels addObject:exceptionModel];
     if (sOnExceptionModelSaved != nil) {
       sOnExceptionModelSaved(exceptionModel);
     }
-  });
+  };
+  @synchronized(sPendingSaves) {
+    if (sContextInitPending) {
+      [sPendingSaves addObject:save];
+      return;
+    }
+  }
+  dispatch_async(dispatch_get_main_queue(), save);
 }
 
 @end

packages/crashlytics/ios/RNFBCrashlyticsUnitTests/HostStubs/Firebase/Firebase.h

@@ -45,6 +45,11 @@
 @property(class, nonatomic, readonly, copy) NSArray<FIRExceptionModel *> *savedExceptionModels;
 /** Called on the main queue right after a save block runs. */
 @property(class, nonatomic, copy, nullable) void (^onExceptionModelSaved)(FIRExceptionModel *model);
+/** Holds later saves like observers of a pending context-init promise, until fulfillContextInit. */
++ (void)holdContextInit;
+
+/** Dispatches the held saves to the main queue and stops holding new ones. */
++ (void)fulfillContextInit;
 
 + (void)resetTestState;
 

packages/crashlytics/ios/RNFBCrashlyticsUnitTests/RNFBCrashlyticsFatalExitTests.m

@@ -123,6 +123,54 @@ - (void)testRecordThenTerminate_savesOnMainBeforeTerminatorRuns {
   XCTAssertEqualObjects(FIRCrashlytics.savedExceptionModels.firstObject.name, @"JavaScriptError");
 }
 
+- (void)testRecordThenTerminate_contextInitPending_terminatesBeforeSave {
+  [FIRCrashlytics holdContextInit];
+  FIRCrashlytics.onExceptionModelSaved = ^(FIRExceptionModel *model) {
+    [self appendEvent:[@"save:" stringByAppendingString:model.reason]];
+  };
+  XCTestExpectation *terminated = [self expectationWithDescription:@"terminated"];
+  __block NSUInteger terminations = 0;
+  __block NSUInteger savedAtExit = NSUIntegerMax;
+  __block BOOL recordedAtExit = NO;
+  dispatch_queue_t watchdogQueue =
+      dispatch_queue_create("rnfb.crashlytics.test.watchdog", DISPATCH_QUEUE_SERIAL);
+  dispatch_suspend(watchdogQueue);
+  RNFBCrashlyticsFatalExit *fatalExit = [[RNFBCrashlyticsFatalExit alloc]
+      initWithTerminator:^{
+        terminations += 1;
+        savedAtExit = FIRCrashlytics.savedExceptionModels.count;
+        recordedAtExit = FIRCrashlytics.lastRecordedExceptionModel != nil;
+        [self appendEvent:@"exit"];
+        [FIRCrashlytics fulfillContextInit];
+        [terminated fulfill];
+      }
+          terminateQueue:dispatch_get_main_queue()
+           watchdogQueue:watchdogQueue
+         watchdogTimeout:0.2];
+
+  __block BOOL started = NO;
+  dispatch_queue_t moduleQueue =
+      dispatch_queue_create("rnfb.crashlytics.test.module", DISPATCH_QUEUE_SERIAL);
+  dispatch_async(moduleQueue, ^{
+    started = [fatalExit recordThenTerminate:^{
+      [self recordFatal];
+    }];
+  });
+
+  [self waitForExpectations:@[ terminated ] timeout:5];
+  dispatch_resume(watchdogQueue);
+  [self drainFor:0.4];
+  [self drainQueue:watchdogQueue];
+  [self drainQueue:moduleQueue];
+
+  XCTAssertTrue(started);
+  XCTAssertEqual(terminations, 1u);
+  XCTAssertTrue(recordedAtExit);
+  XCTAssertEqual(savedAtExit, 0u);
+  NSArray *expected = @[ @"exit", @"save:fatal" ];
+  XCTAssertEqualObjects([self eventsSnapshot], expected);
+}
+
 - (void)testWatchdog_terminatesWhenTerminateQueueIsHung {
   dispatch_queue_t hungQueue = dispatch_queue_create("rnfb.crashlytics.test.hung", 0);
   dispatch_semaphore_t release = dispatch_semaphore_create(0);