test(e2e): Add auto init from JS tests for Android

Implements Android E2E testing infrastructure to verify both manual native initialization and auto initialization from JavaScript, matching the iOS implementation and resolving issue #4912.

Key additions:
- Jest configs for android.auto and android.manual test modes
- Build scripts that toggle SENTRY_DISABLE_NATIVE_START at compile time
- Test scripts to run auto and manual test suites separately
- App start crash testing via flag file mechanism
- TestControlModule to enable/disable crash-on-start from JS
- Comprehensive E2E test documentation

Unlike iOS which uses launch arguments at runtime, Android requires separate builds with different build configurations to control native initialization.

Closes #4912

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: antonis

samples/react-native/android/app/src/main/java/io/sentry/reactnative/sample/MainApplication.kt

@@ -41,10 +41,21 @@ class MainApplication :
             RNSentrySDK.init(this)
         }
 
+        // Check for crash-on-start intent for testing
+        if (shouldCrashOnStart()) {
+            throw RuntimeException("This was intentional test crash before JS started.")
+        }
+
         SoLoader.init(this, OpenSourceMergedSoMapping)
         if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
             // If you opted-in for the New Architecture, we load the native entry point for this app.
             load()
         }
     }
+
+    private fun shouldCrashOnStart(): Boolean {
+        // Check if crash flag file exists (for E2E testing)
+        val crashFile = getFileStreamPath(".sentry_crash_on_start")
+        return crashFile.exists()
+    }
 }

samples/react-native/android/app/src/main/java/io/sentry/reactnative/sample/SamplePackage.java

@@ -77,6 +77,38 @@ private void crashNow() {
           }
         });
 
+    modules.add(
+        new ReactContextBaseJavaModule(reactContext) {
+          @Override
+          public String getName() {
+            return "TestControlModule";
+          }
+
+          @ReactMethod
+          public void enableCrashOnStart(Promise promise) {
+            try {
+              // Create flag file to trigger crash on next app start
+              getReactApplicationContext()
+                  .openFileOutput(".sentry_crash_on_start", ReactApplicationContext.MODE_PRIVATE)
+                  .close();
+              promise.resolve(true);
+            } catch (Exception e) {
+              promise.reject("ERROR", "Failed to enable crash on start", e);
+            }
+          }
+
+          @ReactMethod
+          public void disableCrashOnStart(Promise promise) {
+            try {
+              // Delete flag file
+              getReactApplicationContext().deleteFile(".sentry_crash_on_start");
+              promise.resolve(true);
+            } catch (Exception e) {
+              promise.reject("ERROR", "Failed to disable crash on start", e);
+            }
+          }
+        });
+
     return modules;
   }
 }

samples/react-native/e2e/README.md

@@ -0,0 +1,136 @@
+# E2E Testing Guide
+
+This directory contains end-to-end tests for the React Native sample app, testing both **manual native init** and **auto init from JS** modes.
+
+## Test Modes
+
+### Manual Native Init Mode
+Native SDK is initialized **before** JavaScript loads, allowing capture of app start crashes.
+- **iOS**: Native init via `RNSentrySDK.start()` in AppDelegate
+- **Android**: Native init via `RNSentrySDK.init(this)` in MainApplication
+
+### Auto Init from JS Mode
+SDK is initialized **from JavaScript** after app loads (traditional behavior).
+- **iOS**: Native init is skipped via launch argument `sentryDisableNativeStart`
+- **Android**: Native init is disabled at build time via `SENTRY_DISABLE_NATIVE_START=true`
+
+## Running Tests
+
+### Android
+
+#### Manual Native Init Tests
+```bash
+# Build with native init enabled
+yarn build-android-debug-manual
+
+# Run manual mode tests
+yarn test-android-manual
+```
+
+#### Auto Init from JS Tests
+```bash
+# Build with native init disabled
+yarn build-android-debug-auto
+
+# Run auto mode tests
+yarn test-android-auto
+```
+
+### iOS
+
+#### Manual Native Init Tests
+```bash
+# Build
+yarn build-ios-debug
+
+# Run manual mode tests
+yarn test-ios-manual
+```
+
+#### Auto Init from JS Tests
+```bash
+# Build (same build works for both modes)
+yarn build-ios-debug
+
+# Run auto mode tests (uses launch argument to disable native init)
+yarn test-ios-auto
+```
+
+## Test Structure
+
+```
+e2e/
+├── jest.config.{platform}.{mode}.js  # Test configurations
+├── setup.{platform}.{mode}.ts        # Test setup files
+└── tests/
+    ├── captureMessage/              # Basic message capture tests
+    │   ├── *.test.{platform}.{mode}.ts
+    │   └── *.test.yml               # Maestro flows
+    ├── captureAppStartCrash/        # App start crash tests (manual mode only)
+    │   ├── *.test.{platform}.manual.ts
+    │   └── *.test.{platform}.manual.yml
+    └── ...
+```
+
+## Platform Differences
+
+### iOS
+- Uses **launch arguments** to control native init at runtime
+- Same build can test both modes
+- Launch argument: `sentryDisableNativeStart: true/false`
+
+### Android
+- Uses **build configuration** to control native init at compile time
+- Requires separate builds for each mode
+- Build config: `SENTRY_DISABLE_NATIVE_START=true/false`
+- Environment variable set by build scripts
+
+## Adding New Tests
+
+### Dual-Mode Tests (runs in both auto and manual)
+1. Create test file: `myTest.test.{platform}.{mode}.ts`
+2. Create Maestro flow: `myTest.test.yml` (Android) or `myTest.test.{platform}.{mode}.yml` (iOS)
+3. Test should work regardless of init mode
+
+### Manual-Only Tests (app start crashes)
+1. Create test file: `myTest.test.{platform}.manual.ts`
+2. These tests verify native-only features before JS loads
+3. Cannot test in auto mode (JS not loaded yet)
+
+## App Start Crash Testing
+
+### Android
+Uses a flag file mechanism:
+1. Call `TestControlModule.enableCrashOnStart()` from JS
+2. Restart app → native crash before JS loads
+3. Restart again → crash event is sent
+4. Call `TestControlModule.disableCrashOnStart()` to clean up
+
+### iOS
+Uses launch arguments:
+1. Launch with `sentryCrashOnStart: true`
+2. App crashes in `application:didFinishLaunchingWithOptions`
+3. Restart → crash event is sent
+
+## Debugging
+
+### View test output
+```bash
+# Android
+adb logcat | grep -i sentry
+
+# iOS
+xcrun simctl spawn booted log stream --predicate 'processImagePath contains "sentryreactnativesample"'
+```
+
+### Manual testing
+```bash
+# Android - Install specific build
+adb install -r app-manual.apk  # or app-auto.apk
+adb shell am start -n io.sentry.reactnative.sample/.MainActivity
+
+# iOS - Use Xcode or simulator
+open -a Simulator
+xcrun simctl install booted sentryreactnativesample.app
+xcrun simctl launch booted io.sentry.reactnative.sample
+```

samples/react-native/e2e/jest.config.android.auto.js

@@ -0,0 +1,13 @@
+const path = require('path');
+const baseConfig = require('./jest.config.base');
+
+/** @type {import('@jest/types').Config.InitialOptions} */
+module.exports = {
+  ...baseConfig,
+  globalSetup: path.resolve(__dirname, 'setup.android.auto.ts'),
+  testMatch: [
+    ...baseConfig.testMatch,
+    '<rootDir>/e2e/**/*.test.android.ts',
+    '<rootDir>/e2e/**/*.test.android.auto.ts',
+  ],
+};

samples/react-native/e2e/setup.android.auto.ts

@@ -0,0 +1,7 @@
+import { setAutoInitTest } from './utils/environment';
+
+function setupAuto() {
+  setAutoInitTest();
+}
+
+export default setupAuto;

samples/react-native/e2e/tests/captureAppStartCrash/captureAppStartCrash.test.android.manual.ts

@@ -0,0 +1,115 @@
+import { describe, it, beforeAll, expect, afterAll } from '@jest/globals';
+import { Envelope, EventItem } from '@sentry/core';
+
+import {
+  createSentryServer,
+  containingEvent,
+} from '../../utils/mockedSentryServer';
+import { getItemOfTypeFrom } from '../../utils/event';
+import { maestro } from '../../utils/maestro';
+
+describe('Capture app start crash (Android)', () => {
+  let sentryServer = createSentryServer();
+
+  let envelope: Envelope;
+
+  beforeAll(async () => {
+    await sentryServer.start();
+
+    const envelopePromise = sentryServer.waitForEnvelope(containingEvent);
+
+    await maestro('tests/captureAppStartCrash/captureAppStartCrash.test.android.manual.yml');
+
+    envelope = await envelopePromise;
+  }, 300000); // 5 minutes timeout for crash handling
+
+  afterAll(async () => {
+    await sentryServer.close();
+  });
+
+  it('envelope contains sdk metadata', async () => {
+    const item = getItemOfTypeFrom<EventItem>(envelope, 'event');
+
+    expect(item).toEqual([
+      {
+        content_type: 'application/json',
+        length: expect.any(Number),
+        type: 'event',
+      },
+      expect.objectContaining({
+        platform: 'java',
+        sdk: expect.objectContaining({
+          name: 'sentry.java.android.react-native',
+          packages: expect.arrayContaining([
+            expect.objectContaining({
+              name: 'maven:io.sentry:sentry-android-core',
+            }),
+            expect.objectContaining({
+              name: 'npm:@sentry/react-native',
+            }),
+          ]),
+        }),
+      }),
+    ]);
+  });
+
+  it('captures app start crash exception', async () => {
+    const item = getItemOfTypeFrom<EventItem>(envelope, 'event');
+
+    expect(item?.[1]).toEqual(
+      expect.objectContaining({
+        exception: expect.objectContaining({
+          values: expect.arrayContaining([
+            expect.objectContaining({
+              type: 'RuntimeException',
+              value: 'This was intentional test crash before JS started.',
+              mechanism: expect.objectContaining({
+                handled: false,
+                type: 'UncaughtExceptionHandler',
+              }),
+            }),
+          ]),
+        }),
+      }),
+    );
+  });
+
+  it('crash happened before JS was loaded', async () => {
+    const item = getItemOfTypeFrom<EventItem>(envelope, 'event');
+
+    // Verify this is a native crash, not from JavaScript
+    expect(item?.[1]).toEqual(
+      expect.objectContaining({
+        platform: 'java',
+      }),
+    );
+
+    // Should not have JavaScript context since JS wasn't loaded yet
+    expect(item?.[1]?.contexts?.react_native_context).toBeUndefined();
+  });
+
+  it('contains device and app context', async () => {
+    const item = getItemOfTypeFrom<EventItem>(envelope, 'event');
+
+    expect(item?.[1]).toEqual(
+      expect.objectContaining({
+        contexts: expect.objectContaining({
+          device: expect.objectContaining({
+            brand: expect.any(String),
+            manufacturer: expect.any(String),
+            model: expect.any(String),
+          }),
+          app: expect.objectContaining({
+            app_identifier: 'io.sentry.reactnative.sample',
+            app_name: expect.any(String),
+            app_version: expect.any(String),
+          }),
+          os: expect.objectContaining({
+            name: 'Android',
+            version: expect.any(String),
+          }),
+        }),
+      }),
+    );
+  });
+});

samples/react-native/e2e/tests/captureAppStartCrash/captureAppStartCrash.test.android.manual.yml

@@ -0,0 +1,28 @@
+appId: io.sentry.reactnative.sample
+---
+# First launch: Enable crash flag and exit gracefully
+- launchApp:
+    clearState: true
+    stopApp: true
+
+- tapOn: "Errors"
+- tapOn: "Enable Crash on Start"
+- stopApp
+
+# Second launch: App will crash on start due to flag file
+- launchApp:
+    clearState: false
+    stopApp: false
+
+# Third launch: Crash event is sent before crashing again
+- launchApp:
+    clearState: false
+    stopApp: false
+
+# Fourth launch: Disable the crash flag so app can run normally
+- launchApp:
+    clearState: false
+    stopApp: false
+
+- tapOn: "Errors"
+- tapOn: "Disable Crash on Start"