Quick Search Notification Experiment

app/src/androidTest/java/com/duckduckgo/app/notification/NotificationSchedulerTest.kt

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-
 @file:Suppress("RemoveExplicitTypeArguments")
 
 package com.duckduckgo.app.notification
@@ -23,16 +22,17 @@ import androidx.test.platform.app.InstrumentationRegistry
 import androidx.work.WorkInfo
 import androidx.work.WorkManager
 import com.duckduckgo.app.CoroutineTestRule
-import com.duckduckgo.app.notification.NotificationScheduler.ClearDataNotificationWorker
-import com.duckduckgo.app.notification.NotificationScheduler.PrivacyNotificationWorker
+import com.duckduckgo.app.notification.AndroidNotificationScheduler.*
 import com.duckduckgo.app.notification.model.SchedulableNotification
+import com.duckduckgo.app.notification.model.SearchNotification
 import com.duckduckgo.app.statistics.VariantManager
 import com.duckduckgo.app.statistics.VariantManager.Companion.DEFAULT_VARIANT
 import com.nhaarman.mockitokotlin2.any
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.whenever
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.runBlocking
+import org.junit.After
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
@@ -48,6 +48,7 @@ class NotificationSchedulerTest {
     private val variantManager: VariantManager = mock()
     private val clearNotification: SchedulableNotification = mock()
     private val privacyNotification: SchedulableNotification = mock()
+    private val searchPromptNotification: SearchNotification = mock()
 
     private val context = InstrumentationRegistry.getInstrumentation().targetContext
     private var workManager = WorkManager.getInstance(context)
@@ -56,56 +57,137 @@ class NotificationSchedulerTest {
     @Before
     fun before() {
         whenever(variantManager.getVariant(any())).thenReturn(DEFAULT_VARIANT)
-        testee = NotificationScheduler(
+        testee = AndroidNotificationScheduler(
             workManager,
             clearNotification,
-            privacyNotification
+            privacyNotification,
+            searchPromptNotification
         )
     }
 
+    @After
+    fun resetWorkers() {
+        workManager.cancelAllWorkByTag(AndroidNotificationScheduler.CONTINUOUS_APP_USE_REQUEST_TAG)
+    }
+
+    @Test
+    fun whenPrivacyNotificationClearDataAndSearchPromptCanShowThenBothAreScheduled() = runBlocking<Unit> {
+        whenever(privacyNotification.canShow()).thenReturn(true)
+        whenever(clearNotification.canShow()).thenReturn(true)
+        whenever(searchPromptNotification.canShow()).thenReturn(true)
+        testee.scheduleNextNotification()
+
+        assertUnusedAppNotificationScheduled(PrivacyNotificationWorker::class.jvmName)
+        assertContinuousAppUseNotificationScheduled(SearchPromptNotificationWorker::class.jvmName)
+    }
+
     @Test
-    fun whenBothPrivacyNotificationAndCleatDataCanShowThenPrivacyNotificationScheduled() = runBlocking<Unit> {
+    fun whenPrivacyNotificationClearDataAndSearchPromptCanShowThenPrivacyNotificationScheduled() = runBlocking<Unit> {
         whenever(privacyNotification.canShow()).thenReturn(true)
         whenever(clearNotification.canShow()).thenReturn(true)
+        whenever(searchPromptNotification.canShow()).thenReturn(false)
         testee.scheduleNextNotification()
-        assertNotificationScheduled(PrivacyNotificationWorker::class.jvmName)
+
+        assertUnusedAppNotificationScheduled(PrivacyNotificationWorker::class.jvmName)
+        assertNoContinuousAppNotificationScheduled()
     }
 
     @Test
-    fun whenPrivacyNotificationCanShowAndCleatDataCannotThenPrivacyNotificationScheduled() = runBlocking<Unit> {
+    fun whenPrivacyNotificationAndSearchPromptCanShowButClearDataCannotThenThenBothAreScheduled() = runBlocking<Unit> {
         whenever(privacyNotification.canShow()).thenReturn(true)
         whenever(clearNotification.canShow()).thenReturn(false)
+        whenever(searchPromptNotification.canShow()).thenReturn(true)
         testee.scheduleNextNotification()
-        assertNotificationScheduled(PrivacyNotificationWorker::class.jvmName)
+
+        assertUnusedAppNotificationScheduled(PrivacyNotificationWorker::class.jvmName)
+        assertContinuousAppUseNotificationScheduled(SearchPromptNotificationWorker::class.jvmName)
     }
 
     @Test
-    fun whenPrivacyNotificationCannotShowAndClearNotificationCanShowThenNotificationScheduled() = runBlocking<Unit> {
+    fun whenPrivacyNotificationCanShowButClearDataAndSearchPromptCannotThenPrivacyNotificationScheduled() = runBlocking<Unit> {
+        whenever(privacyNotification.canShow()).thenReturn(true)
+        whenever(clearNotification.canShow()).thenReturn(false)
+        whenever(searchPromptNotification.canShow()).thenReturn(false)
+        testee.scheduleNextNotification()
+
+        assertUnusedAppNotificationScheduled(PrivacyNotificationWorker::class.jvmName)
+        assertNoContinuousAppNotificationScheduled()
+    }
+
+    @Test
+    fun whenPrivacyNotificationAndSearchPromptCannotShowAndClearNotificationCanShowThenBothAreScheduled() = runBlocking<Unit> {
         whenever(privacyNotification.canShow()).thenReturn(false)
         whenever(clearNotification.canShow()).thenReturn(true)
+        whenever(searchPromptNotification.canShow()).thenReturn(true)
+        testee.scheduleNextNotification()
+
+        assertUnusedAppNotificationScheduled(ClearDataNotificationWorker::class.jvmName)
+        assertContinuousAppUseNotificationScheduled(SearchPromptNotificationWorker::class.jvmName)
+    }
+
+    @Test
+    fun whenPrivacyNotificationAndClearNotificationCannotShowButSearchPromptCanShowThenNotificationScheduled() = runBlocking<Unit> {
+        whenever(privacyNotification.canShow()).thenReturn(false)
+        whenever(clearNotification.canShow()).thenReturn(false)
+        whenever(searchPromptNotification.canShow()).thenReturn(true)
+        testee.scheduleNextNotification()
+
+        assertContinuousAppUseNotificationScheduled(SearchPromptNotificationWorker::class.jvmName)
+        assertNoUnusedAppNotificationScheduled()
+    }
+
+    @Test
+    fun whenPrivacyNotificationAndClearNotificationCannotShowButSearchPromptCanThenSearchPromptNotificationScheduled() = runBlocking<Unit> {
+        whenever(privacyNotification.canShow()).thenReturn(false)
+        whenever(clearNotification.canShow()).thenReturn(false)
+        whenever(searchPromptNotification.canShow()).thenReturn(true)
         testee.scheduleNextNotification()
-        assertNotificationScheduled(ClearDataNotificationWorker::class.jvmName)
+
+        assertContinuousAppUseNotificationScheduled(SearchPromptNotificationWorker::class.jvmName)
+        assertNoUnusedAppNotificationScheduled()
     }
 
     @Test
     fun whenNoNotificationCanShowThenNoNotificationScheduled() = runBlocking<Unit> {
         whenever(privacyNotification.canShow()).thenReturn(false)
         whenever(clearNotification.canShow()).thenReturn(false)
+        whenever(searchPromptNotification.canShow()).thenReturn(false)
         testee.scheduleNextNotification()
+
         assertNoNotificationScheduled()
     }
 
-    private fun assertNotificationScheduled(workerName: String) {
-        assertTrue(getScheduledWorkers().any { it.tags.contains(workerName) })
+    private fun assertUnusedAppNotificationScheduled(workerName: String) {
+        assertTrue(getUnusedAppScheduledWorkers().any { it.tags.contains(workerName) })
+    }
+
+    private fun assertContinuousAppUseNotificationScheduled(workerName: String) {
+        assertTrue(getContinuousAppUseScheduledWorkers().any { it.tags.contains(workerName) })
+    }
+
+    private fun assertNoUnusedAppNotificationScheduled() {
+        assertTrue(getUnusedAppScheduledWorkers().isEmpty())
+    }
+
+    private fun assertNoContinuousAppNotificationScheduled() {
+        assertTrue(getContinuousAppUseScheduledWorkers().isEmpty())
     }
 
     private fun assertNoNotificationScheduled() {
-        assertTrue(getScheduledWorkers().isEmpty())
+        assertTrue(getUnusedAppScheduledWorkers().isEmpty())
+        assertTrue(getContinuousAppUseScheduledWorkers().isEmpty())
+    }
+
+    private fun getUnusedAppScheduledWorkers(): List<WorkInfo> {
+        return workManager
+            .getWorkInfosByTag(AndroidNotificationScheduler.UNUSED_APP_WORK_REQUEST_TAG)
+            .get()
+            .filter { it.state == WorkInfo.State.ENQUEUED }
     }
 
-    private fun getScheduledWorkers(): List<WorkInfo> {
+    private fun getContinuousAppUseScheduledWorkers(): List<WorkInfo> {
         return workManager
-            .getWorkInfosByTag(NotificationScheduler.WORK_REQUEST_TAG)
+            .getWorkInfosByTag(AndroidNotificationScheduler.CONTINUOUS_APP_USE_REQUEST_TAG)
             .get()
             .filter { it.state == WorkInfo.State.ENQUEUED }
     }

app/src/androidTest/java/com/duckduckgo/app/settings/SettingsViewModelTest.kt

@@ -25,14 +25,19 @@ import com.duckduckgo.app.browser.BuildConfig
 import com.duckduckgo.app.browser.defaultbrowsing.DefaultBrowserDetector
 import com.duckduckgo.app.global.DuckDuckGoTheme
 import com.duckduckgo.app.icon.api.AppIcon
+import com.duckduckgo.app.notification.NotificationScheduler
 import com.duckduckgo.app.settings.SettingsViewModel.Command
 import com.duckduckgo.app.settings.clear.ClearWhatOption.CLEAR_NONE
 import com.duckduckgo.app.settings.clear.ClearWhenOption.APP_EXIT_ONLY
 import com.duckduckgo.app.settings.db.SettingsDataStore
 import com.duckduckgo.app.statistics.Variant
 import com.duckduckgo.app.statistics.VariantManager
 import com.duckduckgo.app.statistics.pixels.Pixel
-import com.nhaarman.mockitokotlin2.*
+import com.nhaarman.mockitokotlin2.KArgumentCaptor
+import com.nhaarman.mockitokotlin2.argumentCaptor
+import com.nhaarman.mockitokotlin2.atLeastOnce
+import com.nhaarman.mockitokotlin2.verify
+import com.nhaarman.mockitokotlin2.whenever
 import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Rule
@@ -62,6 +67,9 @@ class SettingsViewModelTest {
     @Mock
     private lateinit var mockVariantManager: VariantManager
 
+    @Mock
+    private lateinit var notificationScheduler: NotificationScheduler
+
     @Mock
     private lateinit var mockPixel: Pixel
 
@@ -74,7 +82,7 @@ class SettingsViewModelTest {
         context = InstrumentationRegistry.getInstrumentation().targetContext
         commandCaptor = argumentCaptor()
 
-        testee = SettingsViewModel(mockAppSettingsDataStore, mockDefaultBrowserDetector, mockVariantManager, mockPixel)
+        testee = SettingsViewModel(mockAppSettingsDataStore, mockDefaultBrowserDetector, mockVariantManager, mockPixel, notificationScheduler)
         testee.command.observeForever(commandObserver)
 
         whenever(mockAppSettingsDataStore.automaticallyClearWhenOption).thenReturn(APP_EXIT_ONLY)
@@ -222,5 +230,32 @@ class SettingsViewModelTest {
         assertEquals(Command.LaunchAppIcon, commandCaptor.firstValue)
     }
 
+    @Test
+    fun whenSearchNotificationWasPreviouslyEnabledThenViewStateIndicatesIt() {
+        whenever(mockAppSettingsDataStore.searchNotificationEnabled).thenReturn(true)
+        testee.start()
+        assertTrue(latestViewState().searchNotificationEnabled)
+    }
+
+    @Test
+    fun whenSearchNotificationToggledOnThenDataStoreIsUpdatedAndNotificationShown() {
+        testee.onSearchNotificationSettingChanged(true)
+        verify(mockAppSettingsDataStore).searchNotificationEnabled = true
+        verify(notificationScheduler).launchStickySearchNotification()
+        verify(mockPixel).fire(Pixel.PixelName.QUICK_SEARCH_NOTIFICATION_ENABLED)
+
+        assertTrue(latestViewState().searchNotificationEnabled)
+    }
+
+    @Test
+    fun whenSearchNotificationToggledOffThenDataStoreIsUpdatedAndNotificationRemoved() {
+        testee.onSearchNotificationSettingChanged(false)
+        verify(mockAppSettingsDataStore).searchNotificationEnabled = false
+        verify(notificationScheduler).dismissStickySearchNotification()
+        verify(mockPixel).fire(Pixel.PixelName.QUICK_SEARCH_NOTIFICATION_DISABLED)
+
+        assertFalse(latestViewState().searchNotificationEnabled)
+    }
+
     private fun latestViewState() = testee.viewState.value!!
 }

app/src/androidTest/java/com/duckduckgo/app/statistics/VariantManagerTest.kt

@@ -17,7 +17,6 @@
 package com.duckduckgo.app.statistics
 
 import com.duckduckgo.app.statistics.VariantManager.Companion.DEFAULT_VARIANT
-import com.duckduckgo.app.statistics.VariantManager.Companion.RESERVED_EU_AUCTION_VARIANT
 import com.duckduckgo.app.statistics.VariantManager.VariantFeature.*
 import org.junit.Assert.*
 import org.junit.Test
@@ -33,14 +32,14 @@ class VariantManagerTest {
     @Test
     fun serpControlVariantIsInactiveAndHasNoFeatures() {
         val variant = variants.first { it.key == "sc" }
-        assertEqualsDouble(1.0, variant.weight)
+        assertEqualsDouble(0.0, variant.weight)
         assertEquals(0, variant.features.size)
     }
 
     @Test
     fun serpExperimentalVariantIsInactiveAndHasNoFeatures() {
         val variant = variants.first { it.key == "se" }
-        assertEqualsDouble(1.0, variant.weight)
+        assertEqualsDouble(0.0, variant.weight)
         assertEquals(0, variant.features.size)
     }
 
@@ -75,18 +74,18 @@ class VariantManagerTest {
     // CTA on Concept Test experiments
 
     @Test
-    fun insertCtaConceptTestControlVariantIsActiveAndHasConceptTestAndHasExpectedFeatures() {
+    fun insertCtaConceptTestControlVariantIsInactiveAndHasConceptTestAndHasExpectedFeatures() {
         val variant = variants.first { it.key == "mj" }
-        assertEqualsDouble(1.0, variant.weight)
+        assertEqualsDouble(0.0, variant.weight)
         assertEquals(2, variant.features.size)
         assertTrue(variant.hasFeature(ConceptTest))
         assertTrue(variant.hasFeature(SuppressOnboardingDefaultBrowserContinueScreen))
     }
 
     @Test
-    fun insertCtaConceptTestWithCtasAsDaxDialogsExperimentalVariantIsActiveAndHasExpectedFeatures() {
+    fun insertCtaConceptTestWithCtasAsDaxDialogsExperimentalVariantIsInactiveAndHasExpectedFeatures() {
         val variant = variants.first { it.key == "mh" }
-        assertEqualsDouble(1.0, variant.weight)
+        assertEqualsDouble(0.0, variant.weight)
         assertEquals(5, variant.features.size)
         assertTrue(variant.hasFeature(ConceptTest))
         assertTrue(variant.hasFeature(SuppressHomeTabWidgetCta))
@@ -95,6 +94,23 @@ class VariantManagerTest {
         assertTrue(variant.hasFeature(SearchWidgetDaxCta))
     }
 
+    // Search Notification Experiment
+
+    @Test
+    fun searchNotificationControlVariantIsActiveAndHasNoFeatures() {
+        val variant = variants.first { it.key == "mf" }
+        assertEqualsDouble(1.0, variant.weight)
+        assertEquals(0, variant.features.size)
+    }
+
+    @Test
+    fun searchNotificationVariantIsActiveAndHasStickySearchNotificationFeature() {
+        val variant = variants.first { it.key == "mg" }
+        assertEqualsDouble(1.0, variant.weight)
+        assertEquals(1, variant.features.size)
+        assertTrue(variant.hasFeature(StickySearchNotification))
+    }
+
     @Test
     fun verifyNoDuplicateVariantNames() {
         val existingNames = mutableSetOf<String>()

app/src/main/java/com/duckduckgo/app/di/DaggerWorkerFactory.kt

@@ -23,12 +23,13 @@ import androidx.work.WorkerFactory
 import androidx.work.WorkerParameters
 import com.duckduckgo.app.fire.DataClearingWorker
 import com.duckduckgo.app.global.view.ClearDataAction
+import com.duckduckgo.app.notification.AndroidNotificationScheduler.*
 import com.duckduckgo.app.notification.NotificationFactory
-import com.duckduckgo.app.notification.NotificationScheduler.ClearDataNotificationWorker
-import com.duckduckgo.app.notification.NotificationScheduler.PrivacyNotificationWorker
 import com.duckduckgo.app.notification.db.NotificationDao
 import com.duckduckgo.app.notification.model.ClearDataNotification
 import com.duckduckgo.app.notification.model.PrivacyProtectionNotification
+import com.duckduckgo.app.notification.model.SearchPromptNotification
+import com.duckduckgo.app.notification.model.StickySearchNotification
 import com.duckduckgo.app.settings.db.SettingsDataStore
 import com.duckduckgo.app.statistics.api.OfflinePixelScheduler
 import com.duckduckgo.app.statistics.api.OfflinePixelSender
@@ -44,6 +45,8 @@ class DaggerWorkerFactory(
     private val notificationFactory: NotificationFactory,
     private val clearDataNotification: ClearDataNotification,
     private val privacyProtectionNotification: PrivacyProtectionNotification,
+    private val stickySearchPromptNotification: SearchPromptNotification,
+    private val stickySearchNotification: StickySearchNotification,
     private val pixel: Pixel
 ) : WorkerFactory() {
 
@@ -58,6 +61,9 @@ class DaggerWorkerFactory(
             is DataClearingWorker -> injectDataClearWorker(instance)
             is ClearDataNotificationWorker -> injectClearDataNotificationWorker(instance)
             is PrivacyNotificationWorker -> injectPrivacyNotificationWorker(instance)
+            is SearchPromptNotificationWorker -> injectSearchPromptNotificationWorker(instance)
+            is StickySearchNotificationWorker -> injectStickySearchNotificationWorker(instance)
+            is DismissSearchNotificationWorker -> injectDismissSearchNotificationWorker(instance)
             else -> Timber.i("No injection required for worker $workerClassName")
         }
 
@@ -89,4 +95,25 @@ class DaggerWorkerFactory(
         worker.notification = privacyProtectionNotification
     }
 
+    private fun injectSearchPromptNotificationWorker(worker: SearchPromptNotificationWorker) {
+        worker.manager = notificationManager
+        worker.notificationDao = notificationDao
+        worker.factory = notificationFactory
+        worker.pixel = pixel
+        worker.notification = stickySearchPromptNotification
+    }
+
+    private fun injectStickySearchNotificationWorker(worker: StickySearchNotificationWorker) {
+        worker.manager = notificationManager
+        worker.notificationDao = notificationDao
+        worker.factory = notificationFactory
+        worker.pixel = pixel
+        worker.notification = stickySearchNotification
+    }
+
+    private fun injectDismissSearchNotificationWorker(worker: DismissSearchNotificationWorker) {
+        worker.manager = notificationManager
+        worker.notificationDao = notificationDao
+        worker.notification = stickySearchNotification
+    }
 }