react-native-notify-kit 9.5.0 → 9.6.0

package/android/src/test/java/app/notifee/core/ForegroundServiceTest.java

@@ -1,11 +1,26 @@
 package app.notifee.core;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
 import android.app.Service;
+import android.content.Context;
 import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.os.Bundle;
+import androidx.core.app.NotificationCompat;
+import app.notifee.core.event.NotificationEvent;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -26,12 +41,15 @@ public class ForegroundServiceTest {
   }
 
   @After
-  public void tearDown() {
-    // Reset all accessible static fields to prevent cross-test pollution.
-    // mCurrentNotificationBundle, mCurrentNotification, mCurrentHashCode are private static
-    // and can only be reset via onStartCommand (the STOP path clears them).
+  public void tearDown() throws Exception {
+    // Reset public and private static fields to prevent cross-test pollution. The three private
+    // statics are cleared via reflection here so that tests which seed them directly (to exercise
+    // onTimeout without running the full START path) cannot leak state into neighbouring tests.
     ForegroundService.mCurrentNotificationId = null;
     ForegroundService.mCurrentForegroundServiceType = -1;
+    setPrivateStatic("mCurrentNotificationBundle", null);
+    setPrivateStatic("mCurrentNotification", null);
+    setPrivateStatic("mCurrentHashCode", 0);
   }
 
   /**
@@ -179,4 +197,233 @@ public class ForegroundServiceTest {
     int result = service.onStartCommand(stopIntent, 0, 2);
     assertEquals(Service.START_STICKY_COMPATIBILITY, result);
   }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // START path and onTimeout event emission (regression guards for 9.1.13)
+  // ──────────────────────────────────────────────────────────────────────────
+
+  private static final String TEST_CHANNEL_ID = "fgs-test-channel";
+
+  /**
+   * START happy path: a valid intent with a notification payload must drive the service through
+   * {@code startForeground()} and leave {@code mCurrentNotificationId} populated so a subsequent
+   * STOP/onTimeout can reference it. Runs on SDK 33 to avoid the API 34+ manifest-type check, which
+   * would require a test-specific {@code foregroundServiceType} declaration.
+   */
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_startIntent_setsCurrentNotificationIdAndCallsStartForeground()
+      throws Exception {
+    createChannel();
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    String id = "fgs-start-happy";
+    int result =
+        service.onStartCommand(
+            buildStartIntent(id, id.hashCode()), /* flags= */ 0, /* startId= */ 1);
+
+    assertEquals(Service.START_NOT_STICKY, result);
+    assertEquals(id, ForegroundService.mCurrentNotificationId);
+    // Robolectric's ShadowService records the most recent Notification passed to
+    // startForeground(); a non-null result proves the 3-arg startForeground() overload on the
+    // API 33 branch of onStartCommand was exercised and Android's contract was satisfied.
+    Notification posted = org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification();
+    assertNotNull("startForeground() must have been called during the START path", posted);
+    // The private static mCurrentHashCode tracks the caller-supplied hash; verifying it via
+    // reflection proves the START branch fully ran (not just the early-return path).
+    Field hashField = ForegroundService.class.getDeclaredField("mCurrentHashCode");
+    hashField.setAccessible(true);
+    assertEquals(id.hashCode(), hashField.getInt(null));
+  }
+
+  /**
+   * Regression guard for the 9.1.13 {@code onTimeout(int)} fix (upstream invertase/notifee#703). On
+   * API 34, Android's single-argument {@code onTimeout} fires when a {@code shortService} FGS
+   * exceeds its 3-minute budget. The handler must:
+   *
+   * <ol>
+   *   <li>emit a {@link NotificationEvent} with type {@link NotificationEvent#TYPE_FG_TIMEOUT},
+   *   <li>carry the originating notification model so JS can correlate the event,
+   *   <li>populate {@code startId} and {@code fgsType} extras (the latter is {@code -1} as a
+   *       sentinel on the single-argument variant), and
+   *   <li>reset the service's static tracking state.
+   * </ol>
+   */
+  @Test
+  @Config(sdk = 34)
+  public void onTimeout_api34_emitsFgTimeoutEventWithStartIdAndSentinelFgsType() throws Exception {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    String id = "fgs-timeout-api34";
+    seedActiveForegroundServiceState(id);
+
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      int startId = 42;
+      service.onTimeout(startId);
+
+      assertEquals(
+          "exactly one NotificationEvent should be emitted on timeout", 1, capture.events.size());
+      NotificationEvent event = capture.events.get(0);
+      assertEquals(NotificationEvent.TYPE_FG_TIMEOUT, event.getType());
+      assertNotNull(
+          "timeout event must carry the originating notification", event.getNotification());
+      assertEquals(id, event.getNotification().getId());
+      assertNotNull("timeout event must carry startId/fgsType extras", event.getExtras());
+      assertEquals(startId, event.getExtras().getInt("startId"));
+      // handleTimeout is called with -1 as the fgsType sentinel from the single-argument overload.
+      assertEquals(-1, event.getExtras().getInt("fgsType"));
+    } finally {
+      EventBus.unregister(capture);
+    }
+
+    assertNull(
+        "mCurrentNotificationId must be cleared after onTimeout",
+        ForegroundService.mCurrentNotificationId);
+    assertEquals(-1, ForegroundService.mCurrentForegroundServiceType);
+  }
+
+  /**
+   * Regression guard for the API 35+ {@code onTimeout(int, int)} overload, which supersedes the
+   * single-argument variant and surfaces the type-specific timeout cause (e.g. {@code
+   * FOREGROUND_SERVICE_TYPE_DATA_SYNC}'s new Android 15 cumulative cap). The emitted event must
+   * carry the explicit {@code fgsType} value, not the sentinel.
+   */
+  @Test
+  @Config(sdk = 35)
+  public void onTimeout_api35_emitsFgTimeoutEventWithExplicitFgsType() throws Exception {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    String id = "fgs-timeout-api35";
+    seedActiveForegroundServiceState(id);
+
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      int startId = 7;
+      int fgsType = ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC;
+      service.onTimeout(startId, fgsType);
+
+      assertEquals(1, capture.events.size());
+      NotificationEvent event = capture.events.get(0);
+      assertEquals(NotificationEvent.TYPE_FG_TIMEOUT, event.getType());
+      assertEquals(id, event.getNotification().getId());
+      assertNotNull(event.getExtras());
+      assertEquals(startId, event.getExtras().getInt("startId"));
+      assertEquals(fgsType, event.getExtras().getInt("fgsType"));
+    } finally {
+      EventBus.unregister(capture);
+    }
+
+    assertNull(ForegroundService.mCurrentNotificationId);
+    assertEquals(-1, ForegroundService.mCurrentForegroundServiceType);
+  }
+
+  /**
+   * Defensive behaviour: if onTimeout fires on a service instance whose static state has already
+   * been cleared (a race between STOP and the Android system delivering a delayed timeout), the
+   * handler must not crash and must not post a stray event.
+   */
+  @Test
+  @Config(sdk = 34)
+  public void onTimeout_withNoActiveState_doesNotCrashOrEmitEvent() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      service.onTimeout(/* startId= */ 99);
+      assertEquals(0, capture.events.size());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  // ──────────────────────────────────────────────────────────────────────────
+  // Helpers
+  // ──────────────────────────────────────────────────────────────────────────
+
+  private static void createChannel() {
+    Context context = RuntimeEnvironment.getApplication();
+    NotificationManager nm =
+        (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    if (nm != null && nm.getNotificationChannel(TEST_CHANNEL_ID) == null) {
+      NotificationChannel channel =
+          new NotificationChannel(
+              TEST_CHANNEL_ID, "FGS test channel", NotificationManager.IMPORTANCE_LOW);
+      nm.createNotificationChannel(channel);
+    }
+  }
+
+  private static Bundle buildNotificationBundle(String id) {
+    Bundle bundle = new Bundle();
+    bundle.putString("id", id);
+    bundle.putString("title", "FGS test " + id);
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", TEST_CHANNEL_ID);
+    bundle.putBundle("android", androidBundle);
+    return bundle;
+  }
+
+  private static Notification buildNotification() {
+    Context context = RuntimeEnvironment.getApplication();
+    return new NotificationCompat.Builder(context, TEST_CHANNEL_ID)
+        .setSmallIcon(android.R.drawable.ic_dialog_info)
+        .setContentTitle("FGS test")
+        .build();
+  }
+
+  private static Intent buildStartIntent(String id, int hashCode) {
+    Intent intent = new Intent();
+    intent.setAction(ForegroundService.START_FOREGROUND_SERVICE_ACTION);
+    intent.putExtra("hashCode", hashCode);
+    intent.putExtra("notification", buildNotification());
+    intent.putExtra("notificationBundle", buildNotificationBundle(id));
+    return intent;
+  }
+
+  /**
+   * Populates the service's private static tracking fields directly, simulating the post-START
+   * state that onTimeout expects to observe. Using reflection here (rather than running a full
+   * START first) keeps the onTimeout tests SDK-independent — the START path would trip the API 34+
+   * manifest-type check, but onTimeout itself is sdk-agnostic because its body only uses pre-API-34
+   * primitives.
+   */
+  private static void seedActiveForegroundServiceState(String id) throws Exception {
+    ForegroundService.mCurrentNotificationId = id;
+    ForegroundService.mCurrentForegroundServiceType = 1;
+    setPrivateStatic("mCurrentNotificationBundle", buildNotificationBundle(id));
+    setPrivateStatic("mCurrentNotification", buildNotification());
+    setPrivateStatic("mCurrentHashCode", id.hashCode());
+  }
+
+  private static void setPrivateStatic(String name, Object value) throws Exception {
+    Field field = ForegroundService.class.getDeclaredField(name);
+    field.setAccessible(true);
+    field.set(null, value);
+  }
+
+  /**
+   * greenrobot EventBus subscriber that records every {@link NotificationEvent} posted during a
+   * test. {@link ThreadMode#POSTING} fires the subscriber synchronously on the caller thread, so
+   * the test can inspect {@code events} immediately after {@code post()} returns without any looper
+   * advancement.
+   */
+  public static class FgsEventCapture {
+    final List<NotificationEvent> events = new ArrayList<>();
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    public void onNotificationEvent(NotificationEvent event) {
+      events.add(event);
+    }
+  }
 }

package/android/src/test/java/app/notifee/core/InitProviderBootCheckTest.java

@@ -0,0 +1,81 @@
+package app.notifee.core;
+
+/*
+ * 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 static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+/**
+ * Unit tests for the BOOT_COUNT-based cold-start reschedule decision logic added for upstream
+ * invertase/notifee#734. Exhaustively covers the pure decision helper {@link
+ * InitProvider#shouldRescheduleAfterBoot}.
+ *
+ * <p>The integration path {@code runBootCheck → rescheduleNotifications} is intentionally not
+ * exercised here because {@code rescheduleNotifications} touches a real Room database via {@code
+ * WorkDataRepository.getInstance}, which is not set up in this unit-test environment. That path is
+ * covered by the instrumented {@code RebootRecoveryTest} and by the manual Step 4 smoke test.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class InitProviderBootCheckTest {
+
+  @Test
+  public void shouldRescheduleAfterBoot_firstRun_withValidBootCount_returnsFalse() {
+    // lastKnown == -1 means "no baseline recorded yet". We record the baseline
+    // and skip reschedule to avoid firing stale triggers on fresh installs.
+    assertFalse(InitProvider.shouldRescheduleAfterBoot(5, -1));
+  }
+
+  @Test
+  public void shouldRescheduleAfterBoot_sameBoot_returnsFalse() {
+    // Same app process, same device boot → nothing to recover.
+    assertFalse(InitProvider.shouldRescheduleAfterBoot(5, 5));
+  }
+
+  @Test
+  public void shouldRescheduleAfterBoot_newBoot_returnsTrue() {
+    // Reboot detected since last run → recover scheduled alarms.
+    assertTrue(InitProvider.shouldRescheduleAfterBoot(6, 5));
+  }
+
+  @Test
+  public void shouldRescheduleAfterBoot_bootCountDecreased_returnsTrue() {
+    // BOOT_COUNT decreasing is unexpected but possible (factory reset, counter
+    // rollover on exotic ROMs). Any change is treated as "unknown transition
+    // since last run" → conservative reschedule.
+    assertTrue(InitProvider.shouldRescheduleAfterBoot(3, 5));
+  }
+
+  @Test
+  public void shouldRescheduleAfterBoot_bootCountUnavailable_returnsTrue() {
+    // BOOT_COUNT couldn't be read → we can't tell if a reboot happened, so we
+    // reschedule conservatively. This also covers emulators and rooted ROMs
+    // where the Settings.Global row is missing or throws.
+    assertTrue(InitProvider.shouldRescheduleAfterBoot(-1, 5));
+  }
+
+  @Test
+  public void shouldRescheduleAfterBoot_bootCountUnavailable_andFirstRun_returnsTrue() {
+    // Degenerate case: first run AND BOOT_COUNT unavailable. The "unavailable"
+    // branch wins over the "first run" branch because we genuinely don't know
+    // if the device has rebooted since install.
+    assertTrue(InitProvider.shouldRescheduleAfterBoot(-1, -1));
+  }
+}

package/android/src/test/java/app/notifee/core/NotifeeAlarmManagerHandleStaleTest.java

@@ -0,0 +1,242 @@
+package app.notifee.core;
+
+/*
+ * 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 static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.os.Bundle;
+import app.notifee.core.database.WorkDataRepository;
+import app.notifee.core.model.NotificationModel;
+import app.notifee.core.model.TimestampTriggerModel;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+/**
+ * Regression guards for the {@code NotifeeAlarmManager.handleStaleNonRepeatingTrigger} resilience
+ * chain introduced for upstream invertase/notifee#734 and hardened in Step 7 after a post-Step-6
+ * code review flagged two latent holes:
+ *
+ * <ol>
+ *   <li><b>HIGH #1</b> — {@code Futures.catchingAsync(..., Throwable.class, ...)} was swallowing
+ *       {@link Error} subclasses including {@link OutOfMemoryError}. On a memory-pressured cold
+ *       boot (the exact target scenario of #734) this would mask a JVM-level failure and cause the
+ *       handler to proceed to a Room write seconds before process termination. Narrowed to {@link
+ *       Exception} so Errors propagate as batch failures.
+ *   <li><b>MEDIUM #1</b> — if {@code NotificationManager.displayNotification} threw a synchronous
+ *       exception before returning its {@link ListenableFuture} (e.g. NPE from {@code
+ *       NotificationModel.getAndroid()} upstream of the work Callable), the throw would bypass
+ *       {@code catchingAsync} entirely because the primary input future did not yet exist. Wrapping
+ *       the call in {@link Futures#submitAsync} converts any sync throw from the {@code
+ *       AsyncCallable} into a failed future the catching branch can observe.
+ * </ol>
+ *
+ * <p>Test strategy: {@link MockedStatic} intercepts both {@code NotificationManager} and {@code
+ * WorkDataRepository} static calls so the helper can be exercised in isolation without a real
+ * Android notification channel, a real notification post, or a real Room database. Each test stubs
+ * {@code displayNotification} with a specific failure shape and asserts whether {@code deleteById}
+ * is invoked.
+ *
+ * <p>Mockito 5.x's default {@link org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker}
+ * makes {@code mockStatic} available without an explicit {@code mockito-inline} dependency — the
+ * fork already uses {@code mockito-core:5.19.0} per {@code build.gradle:154}.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class NotifeeAlarmManagerHandleStaleTest {
+
+  /** 1 hour in the past — well inside the 24h STALE_TRIGGER_GRACE_PERIOD_MS window. */
+  private static final long STALE_WITHIN_GRACE_OFFSET_MS = 60L * 60 * 1000;
+
+  /**
+   * Same-thread executor. Required because Mockito {@link MockedStatic} stubs are thread-local to
+   * the thread that activated them — if the production code dispatched the {@code
+   * submitAsync}/{@code catchingAsync}/{@code transformAsync} chain to a worker thread pool, the
+   * real {@code NotificationManager.displayNotification} would be called instead of the stub,
+   * masking the exact regression this test is guarding against. Passing the directExecutor into the
+   * {@code handleStaleNonRepeatingTrigger(..., Executor)} overload keeps the whole chain on the
+   * test thread where the stubs are active.
+   */
+  private static final Executor DIRECT_EXECUTOR = MoreExecutors.directExecutor();
+
+  private MockedStatic<NotificationManager> notificationManagerMock;
+  private MockedStatic<WorkDataRepository> workDataRepositoryMock;
+  private WorkDataRepository mockRepo;
+
+  @Before
+  public void setUp() {
+    // ContextHolder is consulted inside handleStaleNonRepeatingTrigger via
+    // WorkDataRepository.getInstance(getApplicationContext()) — populate with Robolectric's
+    // application context so the static call does not NPE before our mock intercepts it.
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+
+    mockRepo = mock(WorkDataRepository.class);
+    // deleteById is the terminal step of the resilient chain. Default stub returns an immediate
+    // success so the outer future completes cleanly; individual tests can override.
+    when(mockRepo.deleteById(anyString())).thenReturn(Futures.immediateFuture(null));
+
+    workDataRepositoryMock = mockStatic(WorkDataRepository.class);
+    workDataRepositoryMock.when(() -> WorkDataRepository.getInstance(any())).thenReturn(mockRepo);
+
+    notificationManagerMock = mockStatic(NotificationManager.class);
+  }
+
+  @After
+  public void tearDown() {
+    if (notificationManagerMock != null) {
+      notificationManagerMock.close();
+    }
+    if (workDataRepositoryMock != null) {
+      workDataRepositoryMock.close();
+    }
+  }
+
+  // ─── Test 3.1: Exception in display → row deleted (happy-resilience path) ───
+
+  @Test
+  public void handleStaleNonRepeatingTrigger_displayFailsWithRuntimeException_rowIsDeleted()
+      throws Exception {
+    notificationManagerMock
+        .when(() -> NotificationManager.displayNotification(any(), any()))
+        .thenReturn(Futures.immediateFailedFuture(new RuntimeException("synthetic display fail")));
+
+    NotificationModel model = buildStaleModel("test-runtime-exception");
+    TimestampTriggerModel trigger = buildStaleWithinGraceTrigger();
+
+    ListenableFuture<Void> result =
+        NotifeeAlarmManager.handleStaleNonRepeatingTrigger(model, trigger, DIRECT_EXECUTOR);
+
+    assertNotNull("helper must return a non-null future for a stale trigger", result);
+    // Must complete without throwing — catchingAsync swallows the Exception and proceeds.
+    result.get(5, TimeUnit.SECONDS);
+    verify(mockRepo, times(1)).deleteById("test-runtime-exception");
+  }
+
+  // ─── Test 3.2: Error in display → row NOT deleted, Error propagates ──────────
+  //     This is the HIGH #1 regression guard. Before the fix, Throwable.class
+  //     would have caught the OOM and proceeded to deleteById. After the fix,
+  //     Exception.class lets Errors propagate so the per-entity catch in
+  //     rescheduleNotifications leaves the row in Room for a real retry.
+
+  @Test
+  public void handleStaleNonRepeatingTrigger_displayFailsWithError_rowIsNotDeleted_errorPropagates()
+      throws Exception {
+    OutOfMemoryError oom = new OutOfMemoryError("synthetic OOM");
+    notificationManagerMock
+        .when(() -> NotificationManager.displayNotification(any(), any()))
+        .thenReturn(Futures.immediateFailedFuture(oom));
+
+    NotificationModel model = buildStaleModel("test-oom");
+    TimestampTriggerModel trigger = buildStaleWithinGraceTrigger();
+
+    ListenableFuture<Void> result =
+        NotifeeAlarmManager.handleStaleNonRepeatingTrigger(model, trigger, DIRECT_EXECUTOR);
+
+    assertNotNull("helper must return a non-null future for a stale trigger", result);
+
+    ExecutionException thrown = null;
+    try {
+      result.get(5, TimeUnit.SECONDS);
+      fail("Error must propagate as ExecutionException — not be swallowed by catchingAsync");
+    } catch (ExecutionException e) {
+      thrown = e;
+    }
+    assertNotNull(thrown);
+    assertSame(
+        "underlying cause must be the original OutOfMemoryError, not a wrapped RuntimeException",
+        oom,
+        thrown.getCause());
+
+    verify(mockRepo, never()).deleteById(anyString());
+  }
+
+  // ─── Test 3.3: Sync throw in display → row deleted via submitAsync wrap ─────
+  //     This is the MEDIUM #1 regression guard. Before the fix, a sync throw
+  //     upstream of the Callable would bypass catchingAsync because the primary
+  //     future never existed. After the fix, Futures.submitAsync intercepts the
+  //     sync throw and converts it into a failed future catchingAsync can catch.
+
+  @Test
+  public void handleStaleNonRepeatingTrigger_syncThrowInDisplay_rowIsDeleted_viaSubmitAsyncWrap()
+      throws Exception {
+    notificationManagerMock
+        .when(() -> NotificationManager.displayNotification(any(), any()))
+        .thenThrow(new IllegalStateException("synthetic sync throw before future creation"));
+
+    NotificationModel model = buildStaleModel("test-sync-throw");
+    TimestampTriggerModel trigger = buildStaleWithinGraceTrigger();
+
+    ListenableFuture<Void> result =
+        NotifeeAlarmManager.handleStaleNonRepeatingTrigger(model, trigger, DIRECT_EXECUTOR);
+
+    assertNotNull("helper must return a non-null future for a stale trigger", result);
+    // Must complete without throwing — submitAsync converts the sync throw into a failed
+    // future, catchingAsync intercepts, and the chain proceeds to deleteById.
+    result.get(5, TimeUnit.SECONDS);
+    verify(mockRepo, times(1)).deleteById("test-sync-throw");
+  }
+
+  // ─── Builders ──────────────────────────────────────────────────────────────
+
+  private static NotificationModel buildStaleModel(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "HandleStaleTest " + id);
+
+    // A well-formed android sub-bundle is included so the path that the mock intercepts never
+    // touches a malformed NotificationModel — the test is exclusively about the resilient chain
+    // in handleStaleNonRepeatingTrigger, not about NotificationModel shape validation.
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", "handle-stale-test-channel");
+    notificationBundle.putBundle("android", androidBundle);
+
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static TimestampTriggerModel buildStaleWithinGraceTrigger() {
+    long anchorMs = System.currentTimeMillis() - STALE_WITHIN_GRACE_OFFSET_MS;
+
+    Bundle triggerBundle = new Bundle();
+    triggerBundle.putInt("type", 0); // TIMESTAMP
+    triggerBundle.putLong("timestamp", anchorMs);
+    triggerBundle.putInt("repeatFrequency", -1); // non-repeating
+    Bundle alarmManagerBundle = new Bundle();
+    alarmManagerBundle.putInt("type", 3); // SET_EXACT_AND_ALLOW_WHILE_IDLE
+    triggerBundle.putBundle("alarmManager", alarmManagerBundle);
+
+    return TimestampTriggerModel.fromBundle(triggerBundle);
+  }
+}