@aws-amplify/rtn-push-notification 1.0.1-push-notification-dryrun.7810

package/android/src/test/kotlin/PushNotificationAWSPinpointUtilsTest.kt

@@ -0,0 +1,326 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Bundle
+import com.amazonaws.amplify.rtnpushnotification.*
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationContentProvider
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.amplifyframework.pushnotifications.pinpoint.PushNotificationsConstants
+import com.amplifyframework.pushnotifications.pinpoint.PushNotificationsUtils
+import com.amplifyframework.pushnotifications.pinpoint.permissions.PermissionRequestResult
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import io.mockk.*
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+import kotlin.random.Random
+import com.amplifyframework.pushnotifications.pinpoint.permissions.PushNotificationPermission as CommonPushNotificationPermission
+
+@InternalAmplifyApi
+@ExperimentalCoroutinesApi
+@RunWith(RobolectricTestRunner::class)
+class PushNotificationAWSPinpointUtilsTest {
+    private object TestConst {
+        const val ADHOC_KEY = "foo"
+        const val ADHOC_VAL = "bar"
+        const val BODY = "body"
+        const val CAMPAIGN_ID = "campaign-id"
+        const val CAMPAIGN_ACTIVITY_ID = "campaign-activity-id"
+        const val DEEPLINK_URL = "deeplink://url"
+        const val IMAGE_URL = "http://image.fakeurl/avocado.png"
+        const val JOURNEY_ID = "journey-id"
+        const val JOURNEY_ACTIVITY_ID = "journey-id"
+        const val RANDOM_INT = 123
+        const val TITLE = "title"
+        const val URL = "https://goto.fakeurl"
+    }
+
+    private fun getTestPayload(data: Map<String, String> = mapOf()): NotificationPayload {
+        return NotificationPayload.Builder(
+            NotificationContentProvider.FCM(
+                mapOf(PushNotificationsConstants.PINPOINT_PREFIX to "").plus(data)
+            )
+        ).build()
+    }
+
+    private val launchIntentFilter = IntentFilter(Intent.ACTION_MAIN).apply {
+        addCategory(Intent.CATEGORY_LAUNCHER)
+    }
+    private val mockMap = mockk<WritableMap>()
+    private lateinit var context: Context
+
+    @Before
+    fun setup() {
+        context = RuntimeEnvironment.getApplication().applicationContext
+        mockkConstructor(CommonPushNotificationPermission::class)
+        mockkConstructor(PushNotificationsUtils::class)
+        mockkObject(Random)
+        mockkStatic(Arguments::class)
+        justRun {
+            mockMap.putMap(any(), any())
+            mockMap.putString(any(), any())
+            anyConstructed<PushNotificationsUtils>().showNotification(any(), any(), any())
+        }
+        every { Random.nextInt() } returns TestConst.RANDOM_INT
+        every { anyConstructed<PushNotificationsUtils>().areNotificationsEnabled() } returns true
+        every { Arguments.createMap() } returns mockMap
+        val component = ComponentName(context.packageName, "TestMainActivity")
+        shadowOf(context.packageManager).apply {
+            addActivityIfNotPresent(component)
+            addIntentFilterForActivity(component, launchIntentFilter)
+        }
+    }
+
+    @Test
+    fun `returns permission status`() {
+        every {
+            anyConstructed<CommonPushNotificationPermission>().hasRequiredPermission
+        } returns true
+        assertTrue(PushNotificationPermission(context).hasRequiredPermission)
+
+        every {
+            anyConstructed<CommonPushNotificationPermission>().hasRequiredPermission
+        } returns false
+        assertFalse(PushNotificationPermission(context).hasRequiredPermission)
+    }
+
+    @Test
+    fun `requests permission`() = runTest {
+        coEvery {
+            anyConstructed<CommonPushNotificationPermission>().requestPermission()
+        } returns PermissionRequestResult.Granted
+        assertTrue(PushNotificationPermission(context).requestPermission())
+
+        coEvery {
+            anyConstructed<CommonPushNotificationPermission>().requestPermission()
+        } returns PermissionRequestResult.NotGranted(
+            true
+        )
+        assertFalse(PushNotificationPermission(context).requestPermission())
+    }
+
+    @Test
+    fun `shows notification if enabled`() {
+        PushNotificationUtils(context).showNotification(getTestPayload())
+        verify {
+            anyConstructed<PushNotificationsUtils>().showNotification(
+                TestConst.RANDOM_INT,
+                any(),
+                PushNotificationLaunchActivity::class.java
+            )
+        }
+    }
+
+    @Test
+    fun `does not show notification if not enabled`() {
+        every { anyConstructed<PushNotificationsUtils>().areNotificationsEnabled() } returns false
+        PushNotificationUtils(context).showNotification(getTestPayload())
+        verify(exactly = 0) {
+            anyConstructed<PushNotificationsUtils>().showNotification(
+                any(), any(), any()
+            )
+        }
+    }
+
+    @Test
+    fun `does not show notification if explicitly silent`() {
+        PushNotificationUtils(context).showNotification(
+            getTestPayload(
+                mapOf(
+                    PushNotificationsConstants.PINPOINT_NOTIFICATION_SILENTPUSH to "1"
+                )
+            )
+        )
+        verify(exactly = 0) {
+            anyConstructed<PushNotificationsUtils>().showNotification(
+                any(), any(), any()
+            )
+        }
+    }
+
+    @Test
+    fun `builds a notificationId based on campaign attributes`() {
+        PushNotificationUtils(context).showNotification(
+            getTestPayload(
+                mapOf(
+                    PushNotificationsConstants.PINPOINT_CAMPAIGN_CAMPAIGN_ID to TestConst.CAMPAIGN_ID,
+                    PushNotificationsConstants.PINPOINT_CAMPAIGN_CAMPAIGN_ACTIVITY_ID to TestConst.CAMPAIGN_ACTIVITY_ID
+                )
+            )
+        )
+        verify {
+            anyConstructed<PushNotificationsUtils>().showNotification(
+                "${TestConst.CAMPAIGN_ID}:${TestConst.CAMPAIGN_ACTIVITY_ID}".hashCode(),
+                any(),
+                any()
+            )
+        }
+    }
+
+    @Test
+    fun `builds a notificationId based on journey attributes`() {
+        PushNotificationUtils(context).showNotification(
+            getTestPayload(
+                mapOf(
+                    PushNotificationsConstants.PINPOINT_PREFIX to Json.encodeToString(
+                        mapOf(
+                            PushNotificationsConstants.JOURNEY to mapOf(
+                                PushNotificationsConstants.JOURNEY_ID to TestConst.JOURNEY_ID,
+                                PushNotificationsConstants.JOURNEY_ACTIVITY_ID to TestConst.JOURNEY_ACTIVITY_ID
+                            )
+                        )
+                    )
+                )
+            )
+        )
+        verify {
+            anyConstructed<PushNotificationsUtils>().showNotification(
+                "${TestConst.JOURNEY_ID}:${TestConst.JOURNEY_ACTIVITY_ID}".hashCode(), any(), any()
+            )
+        }
+    }
+
+    @Test
+    fun `builds a random notificationId if only campaign id is present`() {
+        PushNotificationUtils(context).showNotification(
+            getTestPayload(
+                mapOf(
+                    PushNotificationsConstants.PINPOINT_CAMPAIGN_CAMPAIGN_ID to TestConst.CAMPAIGN_ID
+                )
+            )
+        )
+        verify {
+            anyConstructed<PushNotificationsUtils>().showNotification(
+                TestConst.RANDOM_INT, any(), any()
+            )
+        }
+    }
+
+    @Test
+    fun `returns if app is in foreground`() {
+        every { anyConstructed<PushNotificationsUtils>().isAppInForeground() } returns true
+        assertTrue(PushNotificationUtils(context).isAppInForeground())
+        every { anyConstructed<PushNotificationsUtils>().isAppInForeground() } returns false
+        assertFalse(PushNotificationUtils(context).isAppInForeground())
+    }
+
+    @Test
+    fun `can create a payload from bundle`() {
+        val bundle = Bundle().apply {
+            putString(PushNotificationsConstants.PINPOINT_NOTIFICATION_TITLE, TestConst.TITLE)
+            putString(PushNotificationsConstants.PINPOINT_NOTIFICATION_BODY, TestConst.BODY)
+        }
+        val payload = bundle.getNotificationPayload()
+        assertEquals(
+            TestConst.TITLE,
+            payload?.rawData?.get(PushNotificationsConstants.PINPOINT_NOTIFICATION_TITLE)
+        )
+        assertEquals(
+            TestConst.BODY,
+            payload?.rawData?.get(PushNotificationsConstants.PINPOINT_NOTIFICATION_BODY)
+        )
+    }
+
+    @Test
+    fun `can create a writable map from payload`() {
+        val payload = NotificationPayload.Builder(
+            NotificationContentProvider.FCM(
+                mapOf(
+                    PushNotificationsConstants.PINPOINT_NOTIFICATION_TITLE to TestConst.TITLE,
+                    PushNotificationsConstants.PINPOINT_NOTIFICATION_BODY to TestConst.BODY,
+                    PushNotificationsConstants.PINPOINT_NOTIFICATION_IMAGEURL to TestConst.IMAGE_URL,
+                    TestConst.ADHOC_KEY to TestConst.ADHOC_VAL
+                )
+            )
+        ).build()
+        payload.toWritableMap()
+        verify {
+            mockMap.putString("title", TestConst.TITLE)
+            mockMap.putString("body", TestConst.BODY)
+            mockMap.putString("imageUrl", TestConst.IMAGE_URL)
+            mockMap.putString(
+                "channelId",
+                PushNotificationsConstants.DEFAULT_NOTIFICATION_CHANNEL_ID
+            )
+            mockMap.putString(TestConst.ADHOC_KEY, TestConst.ADHOC_VAL)
+        }
+    }
+
+    @Test
+    fun `writable map from payload can contain url action`() {
+        val payload = NotificationPayload.Builder(
+            NotificationContentProvider.FCM(mapOf(PushNotificationsConstants.PINPOINT_URL to TestConst.URL))
+        ).build()
+        payload.toWritableMap()
+        verify {
+            mockMap.putString(PushNotificationsConstants.URL, TestConst.URL)
+            mockMap.putMap("action", mockMap)
+        }
+    }
+
+    @Test
+    fun `writable map from payload can contain deeplink action`() {
+        val payload = NotificationPayload.Builder(
+            NotificationContentProvider.FCM(mapOf(PushNotificationsConstants.PINPOINT_DEEPLINK to TestConst.DEEPLINK_URL))
+        ).build()
+        payload.toWritableMap()
+        verify {
+            mockMap.putString(
+                PushNotificationsConstants.PINPOINT_DEEPLINK,
+                TestConst.DEEPLINK_URL
+            )
+            mockMap.putMap("action", mockMap)
+        }
+    }
+
+    @Test
+    fun `writable map from payload always has rawData`() {
+        val payload = NotificationPayload.Builder(
+            NotificationContentProvider.FCM(emptyMap())
+        ).build()
+        payload.toWritableMap()
+        verify(exactly = 0) {
+            mockMap.putString(any(), any())
+            mockMap.putMap("action", any())
+        }
+        verify { mockMap.putMap("rawData", mockMap) }
+    }
+
+    @Test
+    fun `processes payload`() {
+        val payload = getTestPayload()
+        assertNotNull(payload.getProcessedIntent(context))
+    }
+
+    @Test
+    fun `adds url action and starts launch activity`() {
+        val payload =
+            getTestPayload(mapOf(PushNotificationsConstants.PINPOINT_URL to TestConst.URL))
+        val intent = payload.getProcessedIntent(context)
+        assertEquals(Intent.ACTION_VIEW, intent?.action)
+        assertEquals(TestConst.URL, intent?.data.toString())
+    }
+
+    @Test
+    fun `adds deeplink action and starts launch activity`() {
+        val payload =
+            getTestPayload(mapOf(PushNotificationsConstants.PINPOINT_DEEPLINK to TestConst.DEEPLINK_URL))
+        val intent = payload.getProcessedIntent(context)
+        assertEquals(Intent.ACTION_VIEW, intent?.action)
+        assertEquals(TestConst.DEEPLINK_URL, intent?.data.toString())
+    }
+}

package/android/src/test/kotlin/PushNotificationEventManagerTest.kt

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import com.amazonaws.amplify.rtnpushnotification.PushNotificationEventManager
+import com.amazonaws.amplify.rtnpushnotification.PushNotificationEventType
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+import io.mockk.*
+import org.junit.Before
+import org.junit.Test
+
+class PushNotificationEventManagerTest {
+    private val mockContext = mockk<ReactApplicationContext>()
+    private val mockEmitter = mockk<RCTDeviceEventEmitter>()
+    private val mockMap = mockk<WritableMap>()
+
+    @Before
+    fun setup() {
+        justRun { mockEmitter.emit(any(), any()) }
+        every { mockContext.getJSModule(RCTDeviceEventEmitter::class.java) } returns mockEmitter
+    }
+
+    @Test
+    fun `queues events and sends when initialized`() {
+        PushNotificationEventManager.sendEvent(
+            PushNotificationEventType.NOTIFICATION_OPENED, mockMap
+        )
+        PushNotificationEventManager.sendEvent(
+            PushNotificationEventType.NOTIFICATION_OPENED, mockMap
+        )
+        verify(exactly = 0) {
+            mockEmitter.emit(
+                PushNotificationEventType.NOTIFICATION_OPENED.value, mockMap
+            )
+        }
+
+        PushNotificationEventManager.init(mockContext)
+        verify(exactly = 2) {
+            mockEmitter.emit(
+                PushNotificationEventType.NOTIFICATION_OPENED.value, mockMap
+            )
+        }
+    }
+}

package/android/src/test/kotlin/PushNotificationFirebaseMessagingServiceTest.kt

@@ -0,0 +1,92 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import android.content.Intent
+import android.os.Bundle
+import com.amazonaws.amplify.rtnpushnotification.*
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationContentProvider
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import com.facebook.react.HeadlessJsTaskService
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import io.mockk.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric.buildService
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.android.controller.ServiceController
+
+@InternalAmplifyApi
+@RunWith(RobolectricTestRunner::class)
+class PushNotificationFirebaseMessagingServiceTest {
+    private object TestConst {
+        const val TOKEN = "foo-bar"
+    }
+
+    private val mockMap = mockk<WritableMap>()
+    private val testPayload = NotificationPayload.Builder(
+        NotificationContentProvider.FCM(
+            content = mapOf()
+        )
+    ).build()
+    private lateinit var controller: ServiceController<PushNotificationFirebaseMessagingService>
+
+    @Before
+    fun setup() {
+        mockkConstructor(PushNotificationUtils::class)
+        mockkObject(PushNotificationEventManager)
+        mockkStatic(Arguments::class)
+        mockkStatic(Bundle::getNotificationPayload)
+        mockkStatic(HeadlessJsTaskService::class)
+        mockkStatic(NotificationPayload::toWritableMap)
+        justRun {
+            PushNotificationEventManager.sendEvent(any(), any())
+            mockMap.putString(any(), any())
+            HeadlessJsTaskService.acquireWakeLockNow(any())
+            anyConstructed<PushNotificationUtils>().showNotification(any())
+        }
+        every { any<NotificationPayload>().toWritableMap() } returns mockMap
+        every { Arguments.createMap() } returns mockMap
+        every { any<Bundle>().getNotificationPayload() } returns testPayload
+        controller = buildService(PushNotificationFirebaseMessagingService::class.java, Intent())
+    }
+
+    @Test
+    fun `sends token received event on new token`() {
+        controller.create().get().onNewToken(TestConst.TOKEN)
+
+        verify {
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.TOKEN_RECEIVED,
+                mockMap
+            )
+        }
+    }
+
+    @Test
+    fun `handles message in foreground`() {
+        every { anyConstructed<PushNotificationUtils>().isAppInForeground() } returns true
+        controller.create().get().handleIntent(Intent())
+
+        verify {
+            PushNotificationEventManager.sendEvent(
+                PushNotificationEventType.FOREGROUND_MESSAGE_RECEIVED,
+                mockMap
+            )
+        }
+    }
+
+    @Test
+    fun `handles message in background`() {
+        every { anyConstructed<PushNotificationUtils>().isAppInForeground() } returns false
+        controller.create().get().handleIntent(Intent())
+
+        verify {
+            anyConstructed<PushNotificationUtils>().showNotification(testPayload)
+            HeadlessJsTaskService.acquireWakeLockNow(RuntimeEnvironment.getApplication().baseContext)
+        }
+    }
+}

package/android/src/test/kotlin/PushNotificationLaunchActivityTest.kt

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import android.content.Intent
+import com.amazonaws.amplify.rtnpushnotification.PushNotificationLaunchActivity
+import com.amazonaws.amplify.rtnpushnotification.getProcessedIntent
+import com.amplifyframework.annotations.InternalAmplifyApi
+import com.amplifyframework.notifications.pushnotifications.NotificationPayload
+import io.mockk.*
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric.buildActivity
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+
+@InternalAmplifyApi
+@RunWith(RobolectricTestRunner::class)
+class PushNotificationLaunchActivityTest {
+    private object TestConst {
+        const val EXTRAS_KEY = "foo"
+        const val EXTRAS_VAL = "bar"
+    }
+
+    @Before
+    fun setup() {
+        mockkStatic(NotificationPayload::getProcessedIntent)
+        every { any<NotificationPayload>().getProcessedIntent(any()) } returns Intent()
+    }
+
+    @Test
+    fun `adds launch intent with extras and starts launch activity`() {
+        val intent = Intent().apply {
+            putExtra(TestConst.EXTRAS_KEY, TestConst.EXTRAS_VAL)
+        }
+        buildActivity(PushNotificationLaunchActivity::class.java, intent).use {
+            val activity = it.setup().get()
+            val notificationIntent = shadowOf(activity).nextStartedActivity
+
+            assertEquals(TestConst.EXTRAS_VAL, notificationIntent.extras?.get(TestConst.EXTRAS_KEY))
+            it.pause().stop().destroy()
+        }
+    }
+}