[User Model] Notifications Unit Tests

* Added various unit tests for notifications module
* removed high level unittest module from solution

Author: brismithers

OneSignalSDK/onesignal/notifications/src/main/java/com/onesignal/notifications/internal/NotificationReceivedEvent.kt

@@ -10,6 +10,6 @@ internal class NotificationReceivedEvent(
     var effectiveNotification: Notification? = notification
 
     override fun complete(notification: INotification?) {
-        effectiveNotification = notification as Notification
+        effectiveNotification = notification as Notification?
     }
 }

OneSignalSDK/onesignal/notifications/src/main/java/com/onesignal/notifications/internal/generation/impl/NotificationGenerationProcessor.kt

@@ -2,6 +2,7 @@ package com.onesignal.notifications.internal.generation.impl
 
 import android.content.Context
 import com.onesignal.common.AndroidUtils
+import com.onesignal.common.safeString
 import com.onesignal.core.internal.application.IApplicationService
 import com.onesignal.core.internal.config.ConfigModelStore
 import com.onesignal.core.internal.time.ITime
@@ -15,7 +16,6 @@ import com.onesignal.notifications.internal.display.INotificationDisplayer
 import com.onesignal.notifications.internal.generation.INotificationGenerationProcessor
 import com.onesignal.notifications.internal.lifecycle.INotificationLifecycleService
 import com.onesignal.notifications.internal.summary.INotificationSummaryManager
-import com.onesignal.session.internal.session.ISessionService
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.withTimeout
 import org.json.JSONException
@@ -32,7 +32,6 @@ internal class NotificationGenerationProcessor(
     private val _dataController: INotificationRepository,
     private val _notificationSummaryManager: INotificationSummaryManager,
     private val _lifecycleService: INotificationLifecycleService,
-    private val _sessionService: ISessionService,
     private val _time: ITime
 ) : INotificationGenerationProcessor {
 
@@ -229,7 +228,7 @@ internal class NotificationGenerationProcessor(
 
             _dataController.createNotification(
                 customJSON.optString("i"),
-                jsonPayload.optString("grp"),
+                jsonPayload.safeString("grp"),
                 collapseKey,
                 notificationJob.isNotificationToDisplay, // When notification was displayed, count any notifications with duplicated android notification ids as dismissed.
                 opened,

OneSignalSDK/onesignal/notifications/src/main/java/com/onesignal/notifications/internal/pushtoken/PushTokenManager.kt

@@ -37,7 +37,7 @@ internal class PushTokenManager(
                     // runtime error
                     if (pushToken == null &&
                         (
-                            pushTokenStatus == SubscriptionStatus.SUBSCRIBED ||
+                            pushTokenStatus == SubscriptionStatus.NO_PERMISSION ||
                                 pushStatusRuntimeError(pushTokenStatus)
                             )
                     ) {

OneSignalSDK/onesignal/notifications/src/test/java/com/onesignal/notifications/ExampleUnitTest.kt

@@ -0,0 +1,67 @@
+/**
+ * Code taken from https://github.com/kotest/kotest-extensions-robolectric with no changes.
+ *
+ * LICENSE: https://github.com/kotest/kotest-extensions-robolectric/blob/master/LICENSE
+ */
+package com.onesignal.notifications.extensions
+
+import org.junit.runners.model.FrameworkMethod
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import org.robolectric.internal.bytecode.InstrumentationConfiguration
+import org.robolectric.pluginapi.config.ConfigurationStrategy
+import org.robolectric.plugins.ConfigConfigurer
+import java.lang.reflect.Method
+
+internal class ContainedRobolectricRunner(
+    private val config: Config?
+) : RobolectricTestRunner(PlaceholderTest::class.java, injector) {
+    private val placeHolderMethod: FrameworkMethod = children[0]
+    val sdkEnvironment = getSandbox(placeHolderMethod).also {
+        configureSandbox(it, placeHolderMethod)
+    }
+    private val bootStrapMethod = sdkEnvironment.bootstrappedClass<Any>(testClass.javaClass)
+        .getMethod(PlaceholderTest::bootStrapMethod.name)
+
+    fun containedBefore() {
+        Thread.currentThread().contextClassLoader = sdkEnvironment.robolectricClassLoader
+        super.beforeTest(sdkEnvironment, placeHolderMethod, bootStrapMethod)
+    }
+
+    fun containedAfter() {
+        super.afterTest(placeHolderMethod, bootStrapMethod)
+        super.finallyAfterTest(placeHolderMethod)
+        Thread.currentThread().contextClassLoader = ContainedRobolectricRunner::class.java.classLoader
+    }
+
+    override fun createClassLoaderConfig(method: FrameworkMethod?): InstrumentationConfiguration {
+        return InstrumentationConfiguration.Builder(super.createClassLoaderConfig(method))
+            .doNotAcquirePackage("io.kotest")
+            .build()
+    }
+
+    override fun getConfig(method: Method?): Config {
+        val defaultConfiguration = injector.getInstance(ConfigurationStrategy::class.java)
+            .getConfig(testClass.javaClass, method)
+
+        if (config != null) {
+            val configConfigurer = injector.getInstance(ConfigConfigurer::class.java)
+            return configConfigurer.merge(defaultConfiguration[Config::class.java], config)
+        }
+
+        return super.getConfig(method)
+    }
+
+    class PlaceholderTest {
+        @org.junit.Test
+        fun testPlaceholder() {
+        }
+
+        fun bootStrapMethod() {
+        }
+    }
+
+    companion object {
+        private val injector = defaultInjector().build()
+    }
+}

OneSignalSDK/onesignal/notifications/src/test/java/com/onesignal/notifications/extensions/ContainedRobolectricRunner.kt

@@ -0,0 +1,96 @@
+/**
+ * Code taken from https://github.com/kotest/kotest-extensions-robolectric with a
+ * fix in the intercept method.
+ *
+ * LICENSE: https://github.com/kotest/kotest-extensions-robolectric/blob/master/LICENSE
+ */
+package com.onesignal.notifications.extensions
+
+import android.app.Application
+import io.kotest.core.extensions.ConstructorExtension
+import io.kotest.core.extensions.TestCaseExtension
+import io.kotest.core.spec.AutoScan
+import io.kotest.core.spec.Spec
+import io.kotest.core.test.TestCase
+import io.kotest.core.test.TestResult
+import org.robolectric.annotation.Config
+import kotlin.reflect.KClass
+import kotlin.reflect.full.findAnnotation
+
+/**
+ * We override TestCaseExtension to configure the Robolectric environment because TestCase intercept
+ * occurs on the same thread the test is run.  This is unfortunate because it is run for every test,
+ * rather than every spec. But the SpecExtension intercept is run on a different thread.
+ */
+@AutoScan
+internal class RobolectricExtension : ConstructorExtension, TestCaseExtension {
+    private fun Class<*>.getParentClass(): List<Class<*>> {
+        if (superclass == null) return listOf()
+        return listOf(superclass) + superclass.getParentClass()
+    }
+
+    private fun KClass<*>.getConfig(): Config {
+        val configAnnotations = listOf(this.java).plus(this.java.getParentClass())
+            .mapNotNull { it.kotlin.findAnnotation<Config>() }
+            .asSequence()
+
+        val configAnnotation = configAnnotations.firstOrNull()
+
+        if (configAnnotation != null) {
+            return Config.Builder(configAnnotation).build()
+        }
+
+        val robolectricTestAnnotations = listOf(this.java).plus(this.java.getParentClass())
+            .mapNotNull { it.kotlin.findAnnotation<RobolectricTest>() }
+            .asSequence()
+
+        val application: KClass<out Application>? = robolectricTestAnnotations
+            .firstOrNull { it.application != KotestDefaultApplication::class }?.application
+        val sdk: Int? = robolectricTestAnnotations.firstOrNull { it.sdk != -1 }?.takeUnless { it.sdk == -1 }?.sdk
+
+        return Config.Builder()
+            .also { builder ->
+                if (application != null) {
+                    builder.setApplication(application.java)
+                }
+
+                if (sdk != null) {
+                    builder.setSdk(sdk)
+                }
+            }.build()
+    }
+
+    override fun <T : Spec> instantiate(clazz: KClass<T>): Spec? {
+        clazz.findAnnotation<RobolectricTest>() ?: return null
+
+        return ContainedRobolectricRunner(clazz.getConfig())
+            .sdkEnvironment.bootstrappedClass<Spec>(clazz.java).newInstance()
+    }
+
+    override suspend fun intercept(
+        testCase: TestCase,
+        execute: suspend (TestCase) -> TestResult
+    ): TestResult {
+        // FIXED: Updated code based on https://github.com/kotest/kotest/issues/2717
+        val hasRobolectricAnnotation = testCase.spec::class.annotations.any { annotation ->
+            annotation.annotationClass.qualifiedName == RobolectricTest::class.qualifiedName
+        }
+
+        if (!hasRobolectricAnnotation) {
+            return execute(testCase)
+        }
+
+        val containedRobolectricRunner = ContainedRobolectricRunner(testCase.spec::class.getConfig())
+        containedRobolectricRunner.containedBefore()
+        val result = execute(testCase)
+        containedRobolectricRunner.containedAfter()
+        return result
+    }
+}
+
+internal class KotestDefaultApplication : Application()
+
+annotation class RobolectricTest(
+    val application: KClass<out Application> = KotestDefaultApplication::class,
+    val sdk: Int = -1
+)