Merge branch 'release/5.37.0'

Author: CDRussell

app/build.gradle

@@ -111,19 +111,23 @@ ext {
     rxAndroid = "2.0.2"
     timber = "4.7.1"
     rxRelay = "2.0.0"
-    leakCanary = "1.6.2"
+    leakCanary = "2.0-beta-4"
     mockito = "2.18.3"
     mockitoKotlin = "2.0.0"
     commonsMath = "3.6.1"
+    referrerLibrary = "1.0"
 }
 
 
 dependencies {
     implementation "androidx.legacy:legacy-support-v4:$legacySupport"
     debugImplementation "com.squareup.leakcanary:leakcanary-android:$leakCanary"
-    releaseImplementation "com.squareup.leakcanary:leakcanary-android-no-op:$leakCanary"
 
     implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+    //noinspection GradleDependency - 1.1 has a bug which causes a crash
+    implementation "com.android.installreferrer:installreferrer:$referrerLibrary"
+
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
     implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines"
     androidTestImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:$coroutines"

app/src/androidTest/java/com/duckduckgo/app/TestApplication.kt

@@ -34,8 +34,4 @@ class TestApplication : DuckDuckGoApplication() {
             .build()
         daggerAppComponent.inject(this)
     }
-
-    // We don't need to actually use leak canary for tests
-    override fun installLeakCanary(): Boolean = true
-
 }

app/src/androidTest/java/com/duckduckgo/app/di/TestAppComponent.kt

@@ -68,7 +68,8 @@ import javax.inject.Singleton
         RatingModule::class,
         AppUsageModule::class,
         FileModule::class,
-        UncaughtExceptionModule::class
+        UncaughtExceptionModule::class,
+        PlayStoreReferralModule::class
     ]
 )
 interface TestAppComponent : AppComponent {

app/src/androidTest/java/com/duckduckgo/app/launch/LaunchViewModelTest.kt

@@ -21,6 +21,7 @@ import androidx.lifecycle.Observer
 import com.duckduckgo.app.launch.LaunchViewModel.Command.Home
 import com.duckduckgo.app.launch.LaunchViewModel.Command.Onboarding
 import com.duckduckgo.app.onboarding.store.OnboardingStore
+import com.duckduckgo.app.referral.AppInstallationReferrerStateListener
 import com.nhaarman.mockitokotlin2.mock
 import com.nhaarman.mockitokotlin2.verify
 import com.nhaarman.mockitokotlin2.whenever
@@ -37,10 +38,11 @@ class LaunchViewModelTest {
     var instantTaskExecutorRule = InstantTaskExecutorRule()
 
     private var onboardingStore: OnboardingStore = mock()
+    private var appInstallationReferrerStateListener: AppInstallationReferrerStateListener = mock()
     private var mockCommandObserver: Observer<LaunchViewModel.Command> = mock()
 
     private val testee: LaunchViewModel by lazy {
-        LaunchViewModel(onboardingStore)
+        LaunchViewModel(onboardingStore, appInstallationReferrerStateListener)
     }
 
     @After

app/src/androidTest/java/com/duckduckgo/app/referral/DurationBucketMapperTest.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2019 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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.
+ */
+
+package com.duckduckgo.app.referral
+
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+
+class DurationBucketMapperTest {
+
+    private lateinit var testee: DurationBucketMapper
+
+    @Before
+    fun setup() {
+        testee = DurationBucketMapper()
+    }
+
+    @Test
+    fun whenDurationOneBelowNextThresholdThenCurrentBucketReturned() {
+        assertEquals("0", testee.mapDurationToBucket(99))
+        assertEquals("1", testee.mapDurationToBucket(199))
+        assertEquals("2", testee.mapDurationToBucket(499))
+        assertEquals("3", testee.mapDurationToBucket(999))
+        assertEquals("4", testee.mapDurationToBucket(1_499))
+        assertEquals("5", testee.mapDurationToBucket(1_999))
+        assertEquals("6", testee.mapDurationToBucket(2_499))
+    }
+
+    @Test
+    fun whenDurationExactlyOnThresholdThenNextBucketReturned() {
+        assertEquals("0", testee.mapDurationToBucket(0))
+        assertEquals("1", testee.mapDurationToBucket(100))
+        assertEquals("2", testee.mapDurationToBucket(200))
+        assertEquals("3", testee.mapDurationToBucket(500))
+        assertEquals("4", testee.mapDurationToBucket(1_000))
+        assertEquals("5", testee.mapDurationToBucket(1_500))
+        assertEquals("6", testee.mapDurationToBucket(2_000))
+        assertEquals("7", testee.mapDurationToBucket(2_500))
+    }
+
+    @Test
+    fun whenDurationOneAboveThresholdThenNextBucketReturned() {
+        assertEquals("0", testee.mapDurationToBucket(1))
+        assertEquals("1", testee.mapDurationToBucket(101))
+        assertEquals("2", testee.mapDurationToBucket(201))
+        assertEquals("3", testee.mapDurationToBucket(501))
+        assertEquals("4", testee.mapDurationToBucket(1_001))
+        assertEquals("5", testee.mapDurationToBucket(1_501))
+        assertEquals("6", testee.mapDurationToBucket(2_001))
+        assertEquals("7", testee.mapDurationToBucket(2_501))
+    }
+
+}

app/src/androidTest/java/com/duckduckgo/app/referral/QueryParamReferrerParserTest.kt

@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2019 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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.
+ */
+
+package com.duckduckgo.app.referral
+
+import com.duckduckgo.app.referral.ParsedReferrerResult.ReferrerFound
+import com.duckduckgo.app.statistics.pixels.Pixel
+import com.nhaarman.mockitokotlin2.mock
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class QueryParamReferrerParserTest {
+
+    private val pixel: Pixel = mock()
+
+    private val testee: QueryParamReferrerParser = QueryParamReferrerParser(pixel)
+
+    @Test
+    fun whenReferrerDoesNotContainTargetThenNoReferrerFound() {
+        verifyReferrerNotFound(testee.parse("ABC"))
+    }
+
+    @Test
+    fun whenReferrerContainsTargetAndLongSuffixThenShortenedReferrerFound() {
+        val result = testee.parse("DDGRAABC")
+        verifyReferrerFound("AB", result)
+    }
+
+    @Test
+    fun whenReferrerContainsTargetAndTwoCharSuffixThenReferrerFound() {
+        val result = testee.parse("DDGRAXY")
+        verifyReferrerFound("XY", result)
+    }
+
+    @Test
+    fun whenReferrerContainsTargetAndOneCharSuffixThenNoReferrerFound() {
+        val result = testee.parse("DDGRAX")
+        verifyReferrerNotFound(result)
+    }
+
+    @Test
+    fun whenReferrerContainsTargetButNoSuffixThenNoReferrerFound() {
+        val result = testee.parse("DDGRAX")
+        verifyReferrerNotFound(result)
+    }
+
+    @Test
+    fun whenReferrerIsEmptyThenNoReferrerFound() {
+        verifyReferrerNotFound(testee.parse(""))
+    }
+
+    @Test
+    fun whenReferrerContainsTargetAsFirstParamThenReferrerFound() {
+        val result = testee.parse("key1=DDGRAAB&key2=foo&key3=bar")
+        verifyReferrerFound("AB", result)
+    }
+
+    @Test
+    fun whenReferrerContainsTargetAsLastParamThenReferrerFound() {
+        val result = testee.parse("key1=foo&key2=bar&key3=DDGRAAB")
+        verifyReferrerFound("AB", result)
+    }
+
+    @Test
+    fun whenReferrerContainsTargetWithDifferentCaseThenNoReferrerFound() {
+        verifyReferrerNotFound(testee.parse("ddgraAB"))
+    }
+
+    @Test
+    fun whenTypeAReferrerNotFoundButTypeBFoundThenReferrerFound() {
+        verifyReferrerFound("AB", testee.parse("key1=foo&key2=bar&key3=DDGRBAB"))
+    }
+
+    private fun verifyReferrerFound(expectedReferrer: String, result: ParsedReferrerResult) {
+        assertTrue(result is ReferrerFound)
+        val value = (result as ReferrerFound).campaignSuffix
+        assertEquals(expectedReferrer, value)
+    }
+
+    private fun verifyReferrerNotFound(result: ParsedReferrerResult) {
+        assertTrue(result is ParsedReferrerResult.ReferrerNotFound)
+    }
+}

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

@@ -16,50 +16,26 @@
 
 package com.duckduckgo.app.statistics
 
-import org.junit.Assert.*
+import org.junit.Assert.assertEquals
+import org.junit.Assert.fail
 import org.junit.Test
 
 class VariantManagerTest {
 
     private val variants = VariantManager.ACTIVE_VARIANTS
 
     @Test
-    fun serpAndSharedControlVariantInactive() {
+    fun serpAndSharedControlVariantActive() {
         val variant = variants.firstOrNull { it.key == "sc" }
-        assertEqualsDouble(0.0, variant!!.weight)
+        assertEqualsDouble(1.0, variant!!.weight)
         assertEquals(0, variant.features.size)
     }
 
     @Test
-    fun serpExperimentalVariantInactive() {
+    fun serpExperimentalVariantActive() {
         val variant = variants.firstOrNull { it.key == "se" }
-        assertEqualsDouble(0.0, variant!!.weight)
-        assertEquals(0, variant.features.size)
-    }
-
-    @Test
-    fun defaultLightThemeExperimentVariantActive() {
-        val variant = variants.firstOrNull { it.key == "mo" }
-        assertEqualsDouble(1.0, variant!!.weight)
-    }
-
-    @Test
-    fun defaultLightThemeExperimentVariantHasExperimentalFeatureForLightTheme() {
-        val variant = variants.firstOrNull { it.key == "mo" }
-        assertEquals(1, variant!!.features.size)
-        assertTrue(variant.hasFeature(VariantManager.VariantFeature.LightThemeExperiment))
-    }
-
-    @Test
-    fun defaultLightThemeControlGroupVariantActive() {
-        val variant = variants.firstOrNull { it.key == "mp" }
         assertEqualsDouble(1.0, variant!!.weight)
-    }
-
-    @Test
-    fun defaultLightThemeControlGroupVariantHasNoExperimentFeatures() {
-        val variant = variants.firstOrNull { it.key == "mp" }
-        assertEquals(0, variant!!.features.size)
+        assertEquals(0, variant.features.size)
     }
 
     @Suppress("SameParameterValue")

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

@@ -66,7 +66,8 @@ import javax.inject.Singleton
         RatingModule::class,
         AppUsageModule::class,
         FileModule::class,
-        UncaughtExceptionModule::class
+        UncaughtExceptionModule::class,
+        PlayStoreReferralModule::class
     ]
 )
 interface AppComponent : AndroidInjector<DuckDuckGoApplication> {

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2019 DuckDuckGo
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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.
+ */
+
+package com.duckduckgo.app.di
+
+import android.content.Context
+import android.content.pm.PackageManager
+import com.duckduckgo.app.referral.*
+import com.duckduckgo.app.statistics.pixels.Pixel
+import dagger.Module
+import dagger.Provides
+import javax.inject.Singleton
+
+@Module
+class PlayStoreReferralModule {
+
+    @Singleton
+    @Provides
+    fun packageManager(context: Context) = context.packageManager
+
+    @Provides
+    fun appInstallationReferrerParser(pixel: Pixel): AppInstallationReferrerParser {
+        return QueryParamReferrerParser(pixel)
+    }
+
+    @Provides
+    @Singleton
+    fun appInstallationReferrerStateListener(
+        context: Context,
+        packageManager: PackageManager,
+        appInstallationReferrerParser: AppInstallationReferrerParser,
+        appReferrerDataStore: AppReferrerDataStore
+    ): AppInstallationReferrerStateListener {
+        return PlayStoreAppReferrerStateListener(context, packageManager, appInstallationReferrerParser, appReferrerDataStore)
+    }
+
+    @Provides
+    fun durationMeasuringReferrerRetriever(
+        referrerStateListener: AppInstallationReferrerStateListener,
+        durationBucketMapper: DurationBucketMapper,
+        pixel: Pixel
+    ): ReferrerRetrievalTimer {
+        return ReferrerRetrievalTimer(referrerStateListener, durationBucketMapper, pixel)
+    }
+
+    @Provides
+    fun durationBucketMapper(): DurationBucketMapper {
+        return DurationBucketMapper()
+    }
+
+    @Provides
+    @Singleton
+    fun appReferrerDataStore(context: Context): AppReferrerDataStore {
+        return AppReferenceSharePreferences(context)
+    }
+}