react-native-notify-kit 9.5.0 → 9.7.0

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

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

@@ -0,0 +1,264 @@
+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.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doThrow;
+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.app.AlarmManager;
+import android.app.PendingIntent;
+import android.os.Bundle;
+import app.notifee.core.model.NotificationModel;
+import app.notifee.core.model.TimestampTriggerModel;
+import app.notifee.core.utility.AlarmUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+/**
+ * Unit coverage for the {@link TimestampTriggerModel.AlarmType#SET_ALARM_CLOCK} branch of {@link
+ * NotifeeAlarmManager#scheduleTimestampTriggerNotification} and its supporting helper {@link
+ * NotifeeAlarmManager#buildShowIntentPressActionBundle}. This branch was added in upstream {@code
+ * invertase/notifee#749} (closing {@code #655}) and refactored in this fork to reuse the {@code
+ * pressAction} path that the 9.1.19 / 9.3.0 fixes rely on — see the commit that introduces this
+ * file for the full rationale.
+ *
+ * <p>Three scenarios are guarded:
+ *
+ * <ol>
+ *   <li><b>Happy path</b> — a non-repeating TIMESTAMP trigger with {@code
+ *       AlarmType.SET_ALARM_CLOCK} results in exactly one {@link
+ *       AlarmManager#setAlarmClock(AlarmManager.AlarmClockInfo, PendingIntent)} call, the captured
+ *       {@link AlarmManager.AlarmClockInfo} carries a non-null show intent, and the inexact
+ *       fallback path is not exercised.
+ *   <li><b>SecurityException fallback</b> — if {@code setAlarmClock} throws (Android 12+ can reject
+ *       even after {@code canScheduleExactAlarms()} returns true, e.g. when the permission is
+ *       revoked between the pre-check and the schedule call), the catch in {@code
+ *       scheduleTimestampTriggerNotification} must route to {@code setAndAllowWhileIdle} so the
+ *       notification still fires as an inexact alarm rather than disappearing silently.
+ *   <li><b>Show-intent pressAction resolution</b> — a regression guard for the refactor that
+ *       replaced the ad-hoc {@code getLaunchIntentForPackage} with a call into {@link
+ *       NotificationPendingIntent#createIntent}. The helper must (a) synthesize the {@code {
+ *       id:'default', launchActivity:'default' }} bundle when the notification has no {@code
+ *       pressAction} (typical for triggers rehydrated from Room after an app kill), (b) synthesize
+ *       the same default when the user opted out via {@link
+ *       NotificationPendingIntent#PRESS_ACTION_OPT_OUT_ID} (the alarm-clock icon in the status bar
+ *       has no non-tappable mode, so we still need a valid show intent), and (c) pass a custom
+ *       pressAction through unchanged so {@code launchActivity} / {@code mainComponent} routing is
+ *       honoured end-to-end.
+ * </ol>
+ *
+ * <p>Test strategy: {@link MockedStatic} intercepts {@link AlarmUtils#getAlarmManager()} so the
+ * production code receives a Mockito-controlled {@link AlarmManager} instead of Robolectric's
+ * shadow. This lets the tests stub {@code canScheduleExactAlarms()} to skip the Android S+
+ * pre-check, stub {@code setAlarmClock} to either succeed or throw, and capture the {@link
+ * AlarmManager.AlarmClockInfo} that reached the platform. Everything else — {@link ContextHolder},
+ * {@link NotificationPendingIntent#createIntent}, the Intent/PendingIntent plumbing — runs against
+ * Robolectric's real application context.
+ */
+@RunWith(RobolectricTestRunner.class)
+// Robolectric's default SDK is too low for AlarmManager#canScheduleExactAlarms() (API 31+).
+// Pin to API 34 — matches ForegroundServiceTest and exercises the Android S+ pre-check branch
+// that the production code in scheduleTimestampTriggerNotification guards against.
+@Config(sdk = 34)
+public class NotifeeAlarmManagerSetAlarmClockTest {
+
+  /** A trigger timestamp comfortably in the future so {@code setNextTimestamp} is a no-op. */
+  private static final long FUTURE_OFFSET_MS = 60_000L;
+
+  private MockedStatic<AlarmUtils> alarmUtilsMock;
+  private AlarmManager mockAlarmManager;
+
+  @Before
+  public void setUp() {
+    // NotificationPendingIntent.createIntent, getAlarmManagerIntentForNotification, and the
+    // trigger-rescheduling path all call ContextHolder.getApplicationContext(). Robolectric's
+    // application context exposes a real PackageManager so the launch-intent fallback inside
+    // NotificationPendingIntent.createLaunchActivityIntent succeeds without mocking.
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+
+    mockAlarmManager = mock(AlarmManager.class);
+    // Skip the Android S+ pre-check — we explicitly want the switch to reach the SET_ALARM_CLOCK
+    // branch. If canScheduleExactAlarms() returned Mockito's default (false), the pre-check would
+    // fall back to setAndAllowWhileIdle before the switch and the tests would never exercise the
+    // production path under scrutiny.
+    when(mockAlarmManager.canScheduleExactAlarms()).thenReturn(true);
+
+    alarmUtilsMock = mockStatic(AlarmUtils.class);
+    alarmUtilsMock.when(AlarmUtils::getAlarmManager).thenReturn(mockAlarmManager);
+  }
+
+  @After
+  public void tearDown() {
+    if (alarmUtilsMock != null) {
+      alarmUtilsMock.close();
+    }
+  }
+
+  // ─── Test 1: Happy path — setAlarmClock called with a non-null show intent ──
+
+  @Test
+  public void setAlarmClock_happyPath_usesAlarmClockInfoWithShowIntent() {
+    NotificationModel model = buildModel("happy-path");
+    TimestampTriggerModel trigger = buildSetAlarmClockTrigger();
+
+    NotifeeAlarmManager.scheduleTimestampTriggerNotification(model, trigger);
+
+    ArgumentCaptor<AlarmManager.AlarmClockInfo> infoCaptor =
+        ArgumentCaptor.forClass(AlarmManager.AlarmClockInfo.class);
+    ArgumentCaptor<PendingIntent> operationCaptor = ArgumentCaptor.forClass(PendingIntent.class);
+    verify(mockAlarmManager, times(1))
+        .setAlarmClock(infoCaptor.capture(), operationCaptor.capture());
+
+    AlarmManager.AlarmClockInfo info = infoCaptor.getValue();
+    assertNotNull("AlarmClockInfo must be non-null", info);
+    assertNotNull(
+        "AlarmClockInfo.showIntent must be non-null — AlarmManager requires a tap target for"
+            + " the status-bar alarm-clock icon",
+        info.getShowIntent());
+    assertNotNull(
+        "operation PendingIntent (alarm fire target) must be non-null", operationCaptor.getValue());
+
+    // The happy path must never touch the inexact fallback.
+    verify(mockAlarmManager, never())
+        .setAndAllowWhileIdle(anyInt(), anyLong(), any(PendingIntent.class));
+  }
+
+  // ─── Test 2: SecurityException → fallback to setAndAllowWhileIdle ──────────
+
+  @Test
+  public void setAlarmClock_securityException_fallsBackToInexact() {
+    // canScheduleExactAlarms() can race with permission revocation on Android 12+: the pre-check
+    // passes, but the subsequent setAlarmClock call still throws. The production code's
+    // try/catch inside scheduleTimestampTriggerNotification must route that throw to
+    // setAndAllowWhileIdle so the notification degrades gracefully instead of disappearing.
+    doThrow(new SecurityException("synthetic SCHEDULE_EXACT_ALARM denied at fire time"))
+        .when(mockAlarmManager)
+        .setAlarmClock(any(AlarmManager.AlarmClockInfo.class), any(PendingIntent.class));
+
+    NotificationModel model = buildModel("security-exception");
+    TimestampTriggerModel trigger = buildSetAlarmClockTrigger();
+
+    NotifeeAlarmManager.scheduleTimestampTriggerNotification(model, trigger);
+
+    // Primary attempt happened.
+    verify(mockAlarmManager, times(1))
+        .setAlarmClock(any(AlarmManager.AlarmClockInfo.class), any(PendingIntent.class));
+    // Fallback fired with RTC_WAKEUP — matches the other AlarmType branches' wake semantics.
+    verify(mockAlarmManager, times(1))
+        .setAndAllowWhileIdle(eq(AlarmManager.RTC_WAKEUP), anyLong(), any(PendingIntent.class));
+  }
+
+  // ─── Test 3: show-intent reuses the pressAction path (refactor guard) ─────
+
+  @Test
+  public void setAlarmClock_showIntentReusesPressActionPath() {
+    // Case 1: notification has no pressAction at all (e.g. rehydrated from Room after app kill).
+    // buildShowIntentPressActionBundle must synthesize the default so the status-bar icon opens
+    // the app via the same route as a normal tap.
+    Bundle absent = NotifeeAlarmManager.buildShowIntentPressActionBundle(buildModel("absent"));
+    assertNotNull("default pressAction must be synthesized when absent", absent);
+    assertEquals("default", absent.getString("id"));
+    assertEquals("default", absent.getString("launchActivity"));
+
+    // Case 2: notification was built with pressAction:null in JS, which surfaces in the native
+    // layer as PRESS_ACTION_OPT_OUT_ID. Unlike the content intent (where null means "non-tappable
+    // notification"), AlarmClockInfo demands a non-null show intent, so the helper must still
+    // synthesize the default instead of returning null and crashing the schedule call.
+    Bundle optOut =
+        NotifeeAlarmManager.buildShowIntentPressActionBundle(
+            buildModelWithPressAction(
+                "opt-out", NotificationPendingIntent.PRESS_ACTION_OPT_OUT_ID, null));
+    assertNotNull("default pressAction must be synthesized on opt-out sentinel", optOut);
+    assertEquals("default", optOut.getString("id"));
+    assertEquals("default", optOut.getString("launchActivity"));
+
+    // Case 3: a real custom pressAction must pass through untouched so custom launchActivity
+    // routing reaches NotificationPendingIntent.createLaunchActivityIntent.
+    Bundle custom =
+        NotifeeAlarmManager.buildShowIntentPressActionBundle(
+            buildModelWithPressAction("custom", "my-action", "com.example.CustomActivity"));
+    assertNotNull("custom pressAction must pass through", custom);
+    assertEquals("my-action", custom.getString("id"));
+    assertEquals("com.example.CustomActivity", custom.getString("launchActivity"));
+  }
+
+  // ─── Builders ──────────────────────────────────────────────────────────────
+
+  private static NotificationModel buildModel(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "SetAlarmClockTest " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", "set-alarm-clock-test-channel");
+    notificationBundle.putBundle("android", androidBundle);
+
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static NotificationModel buildModelWithPressAction(
+      String id, String pressActionId, String launchActivity) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "SetAlarmClockTest " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", "set-alarm-clock-test-channel");
+
+    Bundle pressAction = new Bundle();
+    pressAction.putString("id", pressActionId);
+    if (launchActivity != null) {
+      pressAction.putString("launchActivity", launchActivity);
+    }
+    androidBundle.putBundle("pressAction", pressAction);
+
+    notificationBundle.putBundle("android", androidBundle);
+
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static TimestampTriggerModel buildSetAlarmClockTrigger() {
+    Bundle triggerBundle = new Bundle();
+    triggerBundle.putInt("type", 0); // TIMESTAMP
+    triggerBundle.putLong("timestamp", System.currentTimeMillis() + FUTURE_OFFSET_MS);
+    triggerBundle.putInt("repeatFrequency", -1); // non-repeating
+
+    Bundle alarmManagerBundle = new Bundle();
+    alarmManagerBundle.putInt("type", 4); // SET_ALARM_CLOCK (TimestampTriggerModel switch case 4)
+    triggerBundle.putBundle("alarmManager", alarmManagerBundle);
+
+    return TimestampTriggerModel.fromBundle(triggerBundle);
+  }
+}