react-native-notify-kit 10.2.1 → 10.3.0

package/android/src/main/kotlin/io/invertase/notifee/NotifeeInitProvider.kt

@@ -6,7 +6,6 @@ package io.invertase.notifee
 
 import app.notifee.core.InitProvider
 import app.notifee.core.Notifee
-import com.facebook.react.modules.systeminfo.ReactNativeVersion
 
 class NotifeeInitProvider : InitProvider() {
 
@@ -15,29 +14,4 @@ class NotifeeInitProvider : InitProvider() {
         Notifee.initialize(NotifeeEventSubscriber())
         return result
     }
-
-    private fun getApplicationVersionString(): String {
-        val context = this.context ?: return "unknown"
-        return try {
-            val pInfo = context.packageManager.getPackageInfo(context.packageName, 0)
-            pInfo.versionName ?: "unknown"
-        } catch (e: Exception) {
-            "unknown"
-        }
-    }
-
-    private fun getReactNativeVersionString(): String {
-        val versionMap = ReactNativeVersion.VERSION
-        val major = versionMap["major"] as Int
-        val minor = versionMap["minor"] as Int
-        val patch = versionMap["patch"] as Int
-        val prerelease = versionMap["prerelease"] as? String
-
-        return buildString {
-            append("$major.$minor.$patch")
-            if (prerelease != null) {
-                append(".$prerelease")
-            }
-        }
-    }
 }

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

@@ -0,0 +1,446 @@
+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.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.timeout;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.AlarmManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.os.Bundle;
+import androidx.core.app.NotificationChannelCompat;
+import androidx.core.app.NotificationManagerCompat;
+import app.notifee.core.database.WorkDataEntity;
+import app.notifee.core.database.WorkDataRepository;
+import app.notifee.core.utility.AlarmUtils;
+import app.notifee.core.utility.ObjectUtils;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.List;
+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.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 28)
+public class NotifeeAlarmManagerCurrentBehaviorTest {
+  private static final String CHANNEL_ID = "manager-current-behavior-channel";
+  private static final long OLD_ANCHOR_OFFSET_MS = TimeUnit.HOURS.toMillis(2);
+
+  private Context context;
+  private WorkDataRepository repo;
+
+  @Before
+  public void setUp() throws Exception {
+    context = RuntimeEnvironment.getApplication();
+    ContextHolder.setApplicationContext(context);
+    repo = WorkDataRepository.getInstance(context);
+    repo.deleteAll().get(5, TimeUnit.SECONDS);
+
+    NotificationChannelCompat channel =
+        new NotificationChannelCompat.Builder(
+                CHANNEL_ID, NotificationManagerCompat.IMPORTANCE_DEFAULT)
+            .setName("Manager Current Behavior")
+            .build();
+    NotificationManagerCompat.from(context).createNotificationChannel(channel);
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    if (repo != null) {
+      repo.deleteAll().get(5, TimeUnit.SECONDS);
+    }
+    if (context != null) {
+      NotificationManagerCompat.from(context).cancelAll();
+    }
+  }
+
+  @Test
+  public void displayScheduledNotification_missingRepeatFrequency_deletesRoomRow()
+      throws Exception {
+    String id = "am-repeat-missing";
+    long oldAnchor = oldAnchor();
+    seedDisplayRow(id, timestampTriggerWithRepeatValue(null, false, oldAnchor));
+
+    runDisplayScheduledNotification(id);
+
+    assertNull(
+        "missing repeatFrequency must take the one-shot delete branch",
+        repo.getWorkDataById(id).get(5, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void displayScheduledNotification_explicitNullRepeatFrequency_updatesRoomRow()
+      throws Exception {
+    String id = "am-repeat-null";
+    long oldAnchor = oldAnchor();
+    seedDisplayRow(id, timestampTriggerWithRepeatValue(null, true, oldAnchor));
+
+    long minExpectedAnchor = System.currentTimeMillis();
+    runDisplayScheduledNotification(id);
+
+    assertRowUpdatedToFuture(id, oldAnchor, minExpectedAnchor);
+  }
+
+  @Test
+  public void displayScheduledNotification_minusOneRepeatFrequency_deletesRoomRow()
+      throws Exception {
+    String id = "am-repeat-minus-one";
+    long oldAnchor = oldAnchor();
+    seedDisplayRow(id, timestampTriggerWithRepeatValue(Integer.valueOf(-1), true, oldAnchor));
+
+    runDisplayScheduledNotification(id);
+
+    assertNull(
+        "repeatFrequency -1 must take the one-shot delete branch",
+        repo.getWorkDataById(id).get(5, TimeUnit.SECONDS));
+  }
+
+  @Test
+  public void displayScheduledNotification_integerRepeatFrequencies_updateRoomRow()
+      throws Exception {
+    for (int repeatFrequency = 0; repeatFrequency <= 3; repeatFrequency++) {
+      String id = "am-repeat-int-" + repeatFrequency;
+      long oldAnchor = oldAnchor();
+      seedDisplayRow(id, timestampTriggerWithRepeatValue(repeatFrequency, true, oldAnchor));
+
+      long minExpectedAnchor = System.currentTimeMillis();
+      runDisplayScheduledNotification(id);
+
+      assertRowUpdatedToFuture(id, oldAnchor, minExpectedAnchor);
+    }
+  }
+
+  @Test
+  public void displayScheduledNotification_doubleRepeatFrequency_truncatesAndUpdatesRoomRow()
+      throws Exception {
+    String id = "am-repeat-double";
+    long oldAnchor = oldAnchor();
+    seedDisplayRow(id, timestampTriggerWithRepeatValue(Double.valueOf(0.9d), true, oldAnchor));
+
+    long minExpectedAnchor = System.currentTimeMillis();
+    runDisplayScheduledNotification(id);
+
+    assertRowUpdatedToFuture(id, oldAnchor, minExpectedAnchor);
+  }
+
+  @Test
+  public void displayScheduledNotification_unsupportedRepeatFrequency_keepsRoomRowUnchanged()
+      throws Exception {
+    assertUnsupportedRepeatFrequencyKeepsRow(Long.valueOf(0L), "long");
+    assertUnsupportedRepeatFrequencyKeepsRow(Float.valueOf(0.5f), "float");
+    assertUnsupportedRepeatFrequencyKeepsRow("0", "string");
+  }
+
+  @Test
+  public void rescheduleNotification_missingType_dispatchesTimestampAndUpdatesRoomRow()
+      throws Exception {
+    WorkDataEntity updated =
+        runRescheduleNotificationExpectingUpdate(rescheduleTriggerWithType(null, false));
+
+    assertEquals("am-type", updated.getId());
+  }
+
+  @Test
+  public void rescheduleNotification_explicitNullType_dispatchesTimestampAndUpdatesRoomRow()
+      throws Exception {
+    WorkDataEntity updated =
+        runRescheduleNotificationExpectingUpdate(rescheduleTriggerWithType(null, true));
+
+    assertEquals("am-type", updated.getId());
+  }
+
+  @Test
+  public void rescheduleNotification_integerZero_dispatchesTimestampAndUpdatesRoomRow()
+      throws Exception {
+    WorkDataEntity updated =
+        runRescheduleNotificationExpectingUpdate(
+            rescheduleTriggerWithType(Integer.valueOf(0), true));
+
+    assertEquals("am-type", updated.getId());
+  }
+
+  @Test
+  public void rescheduleNotification_integerOne_completesWithoutRoomUpdate() throws Exception {
+    runRescheduleNotificationExpectingNoUpdate(rescheduleTriggerWithType(Integer.valueOf(1), true));
+  }
+
+  @Test
+  public void rescheduleNotification_otherInteger_completesWithoutRoomUpdate() throws Exception {
+    runRescheduleNotificationExpectingNoUpdate(rescheduleTriggerWithType(Integer.valueOf(99), true));
+  }
+
+  @Test
+  public void rescheduleNotification_doubleType_truncatesToTimestampBranch() throws Exception {
+    WorkDataEntity updated =
+        runRescheduleNotificationExpectingUpdate(
+            rescheduleTriggerWithType(Double.valueOf(0.9d), true));
+
+    assertEquals("am-type", updated.getId());
+  }
+
+  @Test
+  public void rescheduleNotification_unsupportedType_preservesClassCastException() {
+    assertUnsupportedTypeThrows(Long.valueOf(0L));
+    assertUnsupportedTypeThrows(Float.valueOf(0.5f));
+    assertUnsupportedTypeThrows("0");
+  }
+
+  @Test
+  public void rescheduleNotifications_intervalAndDefaultType_keepRoomRowsUnchanged()
+      throws Exception {
+    assertRescheduleNotificationsKeepsRowUnchanged(Integer.valueOf(1), "interval");
+    assertRescheduleNotificationsKeepsRowUnchanged(Integer.valueOf(99), "default");
+  }
+
+  @Test
+  public void rescheduleNotifications_unsupportedType_keepsRoomRowAfterPerEntityCatch()
+      throws Exception {
+    assertRescheduleNotificationsKeepsRowUnchanged(Long.valueOf(0L), "long");
+    assertRescheduleNotificationsKeepsRowUnchanged(Float.valueOf(0.5f), "float");
+    assertRescheduleNotificationsKeepsRowUnchanged("0", "string");
+  }
+
+  private void assertUnsupportedRepeatFrequencyKeepsRow(Object repeatFrequency, String suffix)
+      throws Exception {
+    String id = "am-repeat-" + suffix;
+    long oldAnchor = oldAnchor();
+    seedDisplayRow(id, timestampTriggerWithRepeatValue(repeatFrequency, true, oldAnchor));
+
+    runDisplayScheduledNotification(id);
+
+    WorkDataEntity row = repo.getWorkDataById(id).get(5, TimeUnit.SECONDS);
+    assertNotNull(
+        "unsupported repeatFrequency must fail before update/delete and leave the row", row);
+    assertEquals(
+        "unsupported repeatFrequency must not rewrite the persisted timestamp",
+        oldAnchor,
+        triggerTimestamp(row));
+  }
+
+  private void assertRescheduleNotificationsKeepsRowUnchanged(Object typeValue, String suffix)
+      throws Exception {
+    repo.deleteAll().get(5, TimeUnit.SECONDS);
+    String id = "am-type-reboot-" + suffix;
+    Bundle triggerBundle = rescheduleTriggerWithType(typeValue, true);
+    seedDisplayRow(id, triggerBundle);
+    long originalTimestamp =
+        triggerTimestamp(repo.getWorkDataById(id).get(5, TimeUnit.SECONDS));
+
+    runRescheduleNotificationsFromRoom();
+
+    WorkDataEntity row = repo.getWorkDataById(id).get(5, TimeUnit.SECONDS);
+    assertNotNull("reboot recovery must leave no-op/wrong-type rows in Room", row);
+    assertEquals(
+        "reboot recovery must not rewrite no-op/wrong-type trigger rows",
+        originalTimestamp,
+        triggerTimestamp(row));
+  }
+
+  private WorkDataEntity runRescheduleNotificationExpectingUpdate(Bundle triggerBundle)
+      throws Exception {
+    WorkDataRepository mockRepo = mock(WorkDataRepository.class);
+    when(mockRepo.update(any())).thenReturn(Futures.immediateFuture(null));
+    AlarmManager mockAlarmManager = mock(AlarmManager.class);
+    ArgumentCaptor<WorkDataEntity> updateCaptor = ArgumentCaptor.forClass(WorkDataEntity.class);
+
+    try (MockedStatic<WorkDataRepository> repoMock = mockStatic(WorkDataRepository.class);
+        MockedStatic<AlarmUtils> alarmUtilsMock = mockStatic(AlarmUtils.class)) {
+      repoMock.when(() -> WorkDataRepository.getInstance(any())).thenReturn(mockRepo);
+      alarmUtilsMock.when(AlarmUtils::getAlarmManager).thenReturn(mockAlarmManager);
+
+      new NotifeeAlarmManager()
+          .rescheduleNotification(buildEntity("am-type", triggerBundle))
+          .get(5, TimeUnit.SECONDS);
+
+      verify(mockRepo).update(updateCaptor.capture());
+      return updateCaptor.getValue();
+    }
+  }
+
+  private void runRescheduleNotificationExpectingNoUpdate(Bundle triggerBundle) throws Exception {
+    WorkDataRepository mockRepo = mock(WorkDataRepository.class);
+    AlarmManager mockAlarmManager = mock(AlarmManager.class);
+
+    try (MockedStatic<WorkDataRepository> repoMock = mockStatic(WorkDataRepository.class);
+        MockedStatic<AlarmUtils> alarmUtilsMock = mockStatic(AlarmUtils.class)) {
+      repoMock.when(() -> WorkDataRepository.getInstance(any())).thenReturn(mockRepo);
+      alarmUtilsMock.when(AlarmUtils::getAlarmManager).thenReturn(mockAlarmManager);
+
+      new NotifeeAlarmManager()
+          .rescheduleNotification(buildEntity("am-type", triggerBundle))
+          .get(5, TimeUnit.SECONDS);
+
+      verify(mockRepo, never()).update(any());
+    }
+  }
+
+  private void assertUnsupportedTypeThrows(Object typeValue) {
+    WorkDataRepository mockRepo = mock(WorkDataRepository.class);
+
+    try (MockedStatic<WorkDataRepository> repoMock = mockStatic(WorkDataRepository.class)) {
+      repoMock.when(() -> WorkDataRepository.getInstance(any())).thenReturn(mockRepo);
+
+      assertThrows(
+          ClassCastException.class,
+          () ->
+              new NotifeeAlarmManager()
+                  .rescheduleNotification(
+                      buildEntity("am-type", rescheduleTriggerWithType(typeValue, true))));
+
+      verify(mockRepo, never()).update(any());
+    }
+  }
+
+  private void runDisplayScheduledNotification(String id) {
+    BroadcastReceiver.PendingResult pendingResult = mock(BroadcastReceiver.PendingResult.class);
+    Bundle alarmManagerNotification = new Bundle();
+    alarmManagerNotification.putString("notificationId", id);
+
+    NotifeeAlarmManager.displayScheduledNotification(alarmManagerNotification, pendingResult);
+
+    verify(pendingResult, timeout(10_000)).finish();
+  }
+
+  private void runRescheduleNotificationsFromRoom() {
+    BroadcastReceiver.PendingResult pendingResult = mock(BroadcastReceiver.PendingResult.class);
+
+    new RoomBackedAlarmManager().rescheduleNotifications(pendingResult);
+
+    verify(pendingResult, timeout(10_000)).finish();
+  }
+
+  private void seedDisplayRow(String id, Bundle triggerBundle) throws Exception {
+    repo.insert(buildEntity(id, triggerBundle)).get(5, TimeUnit.SECONDS);
+  }
+
+  private WorkDataEntity buildEntity(String id, Bundle triggerBundle) {
+    return new WorkDataEntity(
+        id,
+        ObjectUtils.bundleToBytes(notificationBundle(id)),
+        ObjectUtils.bundleToBytes(triggerBundle),
+        true);
+  }
+
+  private void assertRowUpdatedToFuture(String id, long oldAnchor, long minExpectedAnchor)
+      throws Exception {
+    WorkDataEntity row = repo.getWorkDataById(id).get(5, TimeUnit.SECONDS);
+    assertNotNull("repeating trigger row must survive after update branch", row);
+
+    long updatedAnchor = triggerTimestamp(row);
+    assertTrue(
+        "repeating trigger timestamp must be advanced by the update branch",
+        updatedAnchor > oldAnchor);
+    assertTrue(
+        "repeating trigger timestamp must be advanced to the future",
+        updatedAnchor >= minExpectedAnchor);
+  }
+
+  private static long triggerTimestamp(WorkDataEntity row) {
+    return ObjectUtils.getLong(ObjectUtils.bytesToBundle(row.getTrigger()).get("timestamp"));
+  }
+
+  private static long oldAnchor() {
+    return System.currentTimeMillis() - OLD_ANCHOR_OFFSET_MS;
+  }
+
+  private static Bundle notificationBundle(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "Manager Current Behavior " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", CHANNEL_ID);
+    notificationBundle.putBundle("android", androidBundle);
+
+    return notificationBundle;
+  }
+
+  private static Bundle timestampTriggerWithRepeatValue(
+      Object repeatFrequency, boolean includeRepeatFrequency, long timestamp) {
+    Bundle triggerBundle = new Bundle();
+    triggerBundle.putInt("type", 0);
+    triggerBundle.putLong("timestamp", timestamp);
+    if (includeRepeatFrequency) {
+      putBundleValue(triggerBundle, "repeatFrequency", repeatFrequency);
+    }
+
+    Bundle alarmManagerBundle = new Bundle();
+    alarmManagerBundle.putInt("type", 3);
+    triggerBundle.putBundle("alarmManager", alarmManagerBundle);
+
+    return triggerBundle;
+  }
+
+  private static Bundle rescheduleTriggerWithType(Object typeValue, boolean includeType) {
+    Bundle triggerBundle = new Bundle();
+    if (includeType) {
+      putBundleValue(triggerBundle, "type", typeValue);
+    }
+    triggerBundle.putLong("timestamp", System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(10));
+    triggerBundle.putInt("repeatFrequency", 0);
+
+    Bundle alarmManagerBundle = new Bundle();
+    alarmManagerBundle.putInt("type", 3);
+    triggerBundle.putBundle("alarmManager", alarmManagerBundle);
+
+    return triggerBundle;
+  }
+
+  private static void putBundleValue(Bundle bundle, String key, Object value) {
+    if (value == null) {
+      bundle.putString(key, null);
+    } else if (value instanceof Integer) {
+      bundle.putInt(key, (Integer) value);
+    } else if (value instanceof Double) {
+      bundle.putDouble(key, (Double) value);
+    } else if (value instanceof Long) {
+      bundle.putLong(key, (Long) value);
+    } else if (value instanceof Float) {
+      bundle.putFloat(key, (Float) value);
+    } else if (value instanceof String) {
+      bundle.putString(key, (String) value);
+    } else {
+      throw new IllegalArgumentException("Unsupported test value: " + value);
+    }
+  }
+
+  private class RoomBackedAlarmManager extends NotifeeAlarmManager {
+    @Override
+    ListenableFuture<List<WorkDataEntity>> getScheduledNotifications() {
+      return repo.getAllWithAlarmManager(true);
+    }
+  }
+}

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

@@ -0,0 +1,203 @@
+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.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+
+import android.os.Bundle;
+import app.notifee.core.model.NotificationModel;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+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;
+
+@RunWith(RobolectricTestRunner.class)
+public class NotificationManagerCreateTriggerNotificationCurrentBehaviorTest {
+  private MockedStatic<NotificationManager> notificationManagerMock;
+  private NotificationModel notificationModel;
+
+  @Before
+  public void setUp() {
+    notificationModel = buildNotificationModel("create-trigger-current-behavior");
+    notificationManagerMock = mockStatic(NotificationManager.class, CALLS_REAL_METHODS);
+    notificationManagerMock
+        .when(() -> NotificationManager.createTimestampTriggerNotification(any(), any()))
+        .thenReturn(Futures.immediateFuture(null));
+    notificationManagerMock
+        .when(() -> NotificationManager.createIntervalTriggerNotification(any(), any()))
+        .thenReturn(Futures.immediateFuture(null));
+  }
+
+  @After
+  public void tearDown() {
+    if (notificationManagerMock != null) {
+      notificationManagerMock.close();
+    }
+  }
+
+  @Test
+  public void createTriggerNotification_missingType_dispatchesTimestampBranch() throws Exception {
+    Bundle triggerBundle = new Bundle();
+
+    assertCompletes(NotificationManager.createTriggerNotification(notificationModel, triggerBundle));
+
+    verifyTimestampBranch(triggerBundle);
+    verifyIntervalBranchNeverCalled();
+  }
+
+  @Test
+  public void createTriggerNotification_explicitNullType_dispatchesTimestampBranch()
+      throws Exception {
+    Bundle triggerBundle = new Bundle();
+    triggerBundle.putString("type", null);
+
+    assertCompletes(NotificationManager.createTriggerNotification(notificationModel, triggerBundle));
+
+    verifyTimestampBranch(triggerBundle);
+    verifyIntervalBranchNeverCalled();
+  }
+
+  @Test
+  public void createTriggerNotification_integerZero_dispatchesTimestampBranch() throws Exception {
+    Bundle triggerBundle = triggerBundleWithType(Integer.valueOf(0));
+
+    assertCompletes(NotificationManager.createTriggerNotification(notificationModel, triggerBundle));
+
+    verifyTimestampBranch(triggerBundle);
+    verifyIntervalBranchNeverCalled();
+  }
+
+  @Test
+  public void createTriggerNotification_integerOne_dispatchesIntervalBranch() throws Exception {
+    Bundle triggerBundle = triggerBundleWithType(Integer.valueOf(1));
+
+    assertCompletes(NotificationManager.createTriggerNotification(notificationModel, triggerBundle));
+
+    verifyIntervalBranch(triggerBundle);
+    verifyTimestampBranchNeverCalled();
+  }
+
+  @Test
+  public void createTriggerNotification_otherInteger_completesWithoutScheduling() throws Exception {
+    Bundle triggerBundle = triggerBundleWithType(Integer.valueOf(99));
+
+    assertCompletes(NotificationManager.createTriggerNotification(notificationModel, triggerBundle));
+
+    verifyTimestampBranchNeverCalled();
+    verifyIntervalBranchNeverCalled();
+  }
+
+  @Test
+  public void createTriggerNotification_doubleType_truncatesBeforeDispatch() throws Exception {
+    Bundle triggerBundle = triggerBundleWithType(Double.valueOf(1.9d));
+
+    assertCompletes(NotificationManager.createTriggerNotification(notificationModel, triggerBundle));
+
+    verifyIntervalBranch(triggerBundle);
+    verifyTimestampBranchNeverCalled();
+  }
+
+  @Test
+  public void createTriggerNotification_unsupportedType_preservesClassCastException() {
+    assertThrows(
+        ClassCastException.class,
+        () ->
+            NotificationManager.createTriggerNotification(
+                notificationModel, triggerBundleWithType(Long.valueOf(1L))));
+    assertThrows(
+        ClassCastException.class,
+        () ->
+            NotificationManager.createTriggerNotification(
+                notificationModel, triggerBundleWithType(Float.valueOf(1.5f))));
+    assertThrows(
+        ClassCastException.class,
+        () ->
+            NotificationManager.createTriggerNotification(
+                notificationModel, triggerBundleWithType("1")));
+
+    verifyTimestampBranchNeverCalled();
+    verifyIntervalBranchNeverCalled();
+  }
+
+  private void verifyTimestampBranch(Bundle triggerBundle) {
+    notificationManagerMock.verify(
+        () ->
+            NotificationManager.createTimestampTriggerNotification(
+                same(notificationModel), same(triggerBundle)));
+  }
+
+  private void verifyIntervalBranch(Bundle triggerBundle) {
+    notificationManagerMock.verify(
+        () ->
+            NotificationManager.createIntervalTriggerNotification(
+                same(notificationModel), same(triggerBundle)));
+  }
+
+  private void verifyTimestampBranchNeverCalled() {
+    notificationManagerMock.verify(
+        () -> NotificationManager.createTimestampTriggerNotification(any(), any()), never());
+  }
+
+  private void verifyIntervalBranchNeverCalled() {
+    notificationManagerMock.verify(
+        () -> NotificationManager.createIntervalTriggerNotification(any(), any()), never());
+  }
+
+  private static void assertCompletes(ListenableFuture<Void> future) throws Exception {
+    future.get(5, TimeUnit.SECONDS);
+  }
+
+  private static NotificationModel buildNotificationModel(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static Bundle triggerBundleWithType(Object type) {
+    Bundle triggerBundle = new Bundle();
+    putBundleValue(triggerBundle, "type", type);
+    return triggerBundle;
+  }
+
+  private static void putBundleValue(Bundle bundle, String key, Object value) {
+    if (value == null) {
+      bundle.putString(key, null);
+    } else if (value instanceof Integer) {
+      bundle.putInt(key, (Integer) value);
+    } else if (value instanceof Double) {
+      bundle.putDouble(key, (Double) value);
+    } else if (value instanceof Long) {
+      bundle.putLong(key, (Long) value);
+    } else if (value instanceof Float) {
+      bundle.putFloat(key, (Float) value);
+    } else if (value instanceof String) {
+      bundle.putString(key, (String) value);
+    } else {
+      throw new IllegalArgumentException("Unsupported test value: " + value);
+    }
+  }
+}