Merge branch 'release/4.0.4'

subsymbolic · subsymbolic · commit 06c25b2624db · 2018-01-21T22:54:20.000Z
diff --git a/app/build.gradle b/app/build.gradle
@@ -6,7 +6,7 @@ apply plugin: 'kotlin-kapt'
 apply from: '../versioning.gradle'
 
 ext {
-    VERSION_NAME = "4.0.3"
+    VERSION_NAME = "4.0.4"
 }
 
 android {
diff --git a/app/src/androidTest/java/com/duckduckgo/app/browser/BrowserViewModelTest.kt b/app/src/androidTest/java/com/duckduckgo/app/browser/BrowserViewModelTest.kt
@@ -305,9 +305,11 @@ class BrowserViewModelTest {
     }
 
     @Test
-    fun whenTrackerDetectedThenPrivacyGradeIsUpdated() {
+    fun whenEnoughTrackersDetectedThenPrivacyGradeIsUpdated() {
         testee.urlChanged("https://example.com")
-        testee.trackerDetected(TrackingEvent("https://example.com", "", null, false))
+        for (i in 1..10) {
+            testee.trackerDetected(TrackingEvent("https://example.com", "", null, false))
+        }
         assertEquals(PrivacyGrade.C, testee.privacyGrade.value)
     }
 
diff --git a/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/model/PrivacyGradeTest.kt b/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/model/PrivacyGradeTest.kt
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018 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.privacymonitor.model
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class PrivacyGradeTest {
+
+    @Test
+    fun whenScoreIs0ThenGradeIsA() {
+        assertEquals(PrivacyGrade.A, PrivacyGrade.gradeForScore(0))
+    }
+
+    @Test
+    fun whenScoreIs1ThenGradeIsB() {
+        assertEquals(PrivacyGrade.B, PrivacyGrade.gradeForScore(1))
+    }
+
+    @Test
+    fun whenScoreIs2ThenGradeIsC() {
+        assertEquals(PrivacyGrade.C, PrivacyGrade.gradeForScore(2))
+    }
+
+    @Test
+    fun whenScoreIs3ThenGradeIsD() {
+        assertEquals(PrivacyGrade.D, PrivacyGrade.gradeForScore(3))
+    }
+
+    @Test
+    fun whenScoreIsAbove3ThenGradeIsD() {
+        assertEquals(PrivacyGrade.D, PrivacyGrade.gradeForScore(4))
+    }
+}
diff --git a/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/model/PrivacyMonitorGradeExtensionTest.kt b/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/model/PrivacyMonitorGradeExtensionTest.kt
@@ -85,9 +85,16 @@ class PrivacyMonitorGradeExtensionTest {
     }
 
     @Test
-    fun whenTermsScoreIsNegativeThenScoreIsDecrementedByOne() {
+    fun whenTermsScoreIsNegativeThenScoreGreaterThanOneIsDecrementedByOne() {
+        // http adds +1 and tos score removes 1 so we expect default score
+        val privacyMonitor = monitor(terms = TermsOfService(score = -5), https = NONE)
+        assertEquals(defaultScore, privacyMonitor.score)
+    }
+
+    @Test
+    fun whenTermsScoreIsNegativeThenScoreOfOneIsUnchanged() {
         val privacyMonitor = monitor(terms = TermsOfService(score = -5))
-        assertEquals(defaultScore - 1, privacyMonitor.score)
+        assertEquals(defaultScore, privacyMonitor.score)
     }
 
     @Test
@@ -103,14 +110,20 @@ class PrivacyMonitorGradeExtensionTest {
     }
 
     @Test
-    fun whenOneTrackerThenScoreIsIncrementedByOne() {
+    fun whenOneTrackerThenScoreNotIncremented() {
         val privacyMonitor = monitor(trackerCount = 1)
+        assertEquals(defaultScore, privacyMonitor.score)
+    }
+
+    @Test
+    fun whenTenTrackersThenScoreIsIncrementedByOne() {
+        val privacyMonitor = monitor(trackerCount = 10)
         assertEquals(defaultScore + 1, privacyMonitor.score)
     }
 
     @Test
-    fun whenElevenTrackersThenScoreIsIncrementedByTwo() {
-        val privacyMonitor = monitor(trackerCount = 11)
+    fun whenTwentyTrackersThenScoreIsIncrementedByTwo() {
+        val privacyMonitor = monitor(trackerCount = 20)
         assertEquals(defaultScore + 2, privacyMonitor.score)
     }
 
@@ -138,7 +151,7 @@ class PrivacyMonitorGradeExtensionTest {
                 TrackerNetwork("", "", "", 5, true),
                 TermsOfService(classification = "D"),
                 NONE,
-                5,
+                11,
                 true,
                 true)
         assertEquals(defaultScore + 6, privacyMonitor.score)
diff --git a/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/renderer/HttpsStatusRendererExtensionTest.kt b/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/renderer/HttpsStatusRendererExtensionTest.kt
@@ -23,7 +23,7 @@ import com.duckduckgo.app.privacymonitor.model.HttpsStatus
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
-class HttpsStatusRendererExtenstionTest {
+class HttpsStatusRendererExtensionTest {
 
     private val context: Context = InstrumentationRegistry.getTargetContext()
 
diff --git a/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/ui/PrivacyDashboardViewModelTest.kt b/app/src/androidTest/java/com/duckduckgo/app/privacymonitor/ui/PrivacyDashboardViewModelTest.kt
@@ -109,27 +109,27 @@ class PrivacyDashboardViewModelTest {
         whenever(settingStore.privacyOn)
                 .thenReturn(true)
                 .thenReturn(false)
-        assertTrue(testee.shouldReloadPage)
+        assertTrue(testee.viewState.value!!.shouldReloadPage)
     }
 
     @Test
     fun whenPrivacyInitiallyOnAndUnchangedThenShouldReloadIsFalse() {
         whenever(settingStore.privacyOn).thenReturn(true)
-        assertFalse(testee.shouldReloadPage)
+        assertFalse(testee.viewState.value!!.shouldReloadPage)
     }
 
     @Test
     fun whenPrivacyInitiallyOffAndSwitchedOnThenShouldReloadIsTrue() {
         whenever(settingStore.privacyOn)
                 .thenReturn(false)
                 .thenReturn(true)
-        assertTrue(testee.shouldReloadPage)
+        assertTrue(testee.viewState.value!!.shouldReloadPage)
     }
 
     @Test
     fun whenPrivacyInitiallyOffAndUnchangedThenShouldReloadIsFalse() {
         whenever(settingStore.privacyOn).thenReturn(false)
-        assertFalse(testee.shouldReloadPage)
+        assertFalse(testee.viewState.value!!.shouldReloadPage)
     }
 
     @Test
diff --git a/app/src/main/java/com/duckduckgo/app/global/view/StringHtmlExtension.kt b/app/src/main/java/com/duckduckgo/app/global/view/StringHtmlExtension.kt
diff --git a/app/src/main/java/com/duckduckgo/app/privacymonitor/model/PrivacyGrade.kt b/app/src/main/java/com/duckduckgo/app/privacymonitor/model/PrivacyGrade.kt
@@ -22,5 +22,18 @@ enum class PrivacyGrade {
     B,
     C,
     D,
-    UNKNOWN
+    UNKNOWN;
+
+    companion object {
+
+        fun gradeForScore(score: Int): PrivacyGrade {
+            return when (score) {
+                0 -> PrivacyGrade.A
+                1 -> PrivacyGrade.B
+                2 -> PrivacyGrade.C
+                else -> PrivacyGrade.D
+            }
+        }
+
+    }
 }
diff --git a/app/src/main/java/com/duckduckgo/app/privacymonitor/model/PrivacyMonitorGradeExtension.kt b/app/src/main/java/com/duckduckgo/app/privacymonitor/model/PrivacyMonitorGradeExtension.kt
@@ -17,23 +17,42 @@
 package com.duckduckgo.app.privacymonitor.model
 
 import com.duckduckgo.app.privacymonitor.PrivacyMonitor
+import timber.log.Timber
 
 
 val PrivacyMonitor.score: Int
     get() {
         var score = baseScore
-        score += Math.ceil(trackerCount / 10.0).toInt()
+        score += trackerCount / 10
         if (hasTrackerFromMajorNetwork) {
             score += 1
         }
         if (hasObscureTracker) {
             score += 1
         }
+        if (score == 0 && termsOfService.classification != "A") {
+            score = 1
+        }
+        Timber.v("""Calculating score {
+            memberMajorNetworkPercentage: ${memberNetwork?.percentageOfPages}
+            https: ${https}
+            termsScore: ${termsOfService.gradingScore}
+            trackerCount: $trackerCount
+            hasTrackerFromMajorNetwork: $hasTrackerFromMajorNetwork
+            hasObscureTracker: $hasObscureTracker
+            score: $score
+            """)
         return score
     }
 
 val PrivacyMonitor.potentialScore: Int
-    get() = baseScore
+    get() {
+        var score = baseScore
+        if (score == 0 && termsOfService.classification != "A") {
+            score = 1
+        }
+        return score
+    }
 
 
 private val PrivacyMonitor.baseScore: Int
@@ -56,20 +75,10 @@ val PrivacyMonitor.improvedScore: Int
     }
 
 val PrivacyMonitor.grade: PrivacyGrade
-    get() = calculateGrade(score)
+    get() = PrivacyGrade.gradeForScore(score)
 
 val PrivacyMonitor.improvedGrade: PrivacyGrade
-    get() = calculateGrade(improvedScore)
-
-
-private fun calculateGrade(score: Int): PrivacyGrade {
-    return when {
-        score <= 0 -> PrivacyGrade.A
-        score == 1 -> PrivacyGrade.B
-        score == 2 -> PrivacyGrade.C
-        else -> PrivacyGrade.D
-    }
-}
+    get() = PrivacyGrade.gradeForScore(improvedScore)
 
 val TermsOfService.gradingScore: Int
     get() {
diff --git a/app/src/main/java/com/duckduckgo/app/privacymonitor/ui/PrivacyDashboardActivity.kt b/app/src/main/java/com/duckduckgo/app/privacymonitor/ui/PrivacyDashboardActivity.kt
@@ -16,6 +16,7 @@
 
 package com.duckduckgo.app.privacymonitor.ui
 
+import android.app.Activity
 import android.arch.lifecycle.Observer
 import android.arch.lifecycle.ViewModelProviders
 import android.content.Context
@@ -43,6 +44,10 @@ class PrivacyDashboardActivity : DuckDuckGoActivity() {
     private val trackersRenderer = TrackersRenderer()
     private val upgradeRenderer = PrivacyUpgradeRenderer()
 
+    private val viewModel: PrivacyDashboardViewModel by lazy {
+        ViewModelProviders.of(this, viewModelFactory).get(PrivacyDashboardViewModel::class.java)
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_privacy_dashboard)
@@ -65,22 +70,11 @@ class PrivacyDashboardActivity : DuckDuckGoActivity() {
         }
     }
 
-    private val viewModel: PrivacyDashboardViewModel by lazy {
-        ViewModelProviders.of(this, viewModelFactory).get(PrivacyDashboardViewModel::class.java)
-    }
-
     private fun configureToolbar() {
         setSupportActionBar(toolbar)
         supportActionBar?.setDisplayHomeAsUpEnabled(true)
     }
 
-    override fun onBackPressed() {
-        if (viewModel.shouldReloadPage) {
-            setResult(RELOAD_RESULT_CODE)
-        }
-        super.onBackPressed()
-    }
-
     private fun render(viewState: ViewState) {
         if (isFinishing) {
             return
@@ -103,6 +97,7 @@ class PrivacyDashboardActivity : DuckDuckGoActivity() {
         networkTrackerSummaryPill1.render(viewState.networkTrackerSummaryName1, viewState.networkTrackerSummaryPercent1)
         networkTrackerSummaryPill2.render(viewState.networkTrackerSummaryName2, viewState.networkTrackerSummaryPercent2)
         networkTrackerSummaryPill3.render(viewState.networkTrackerSummaryName3, viewState.networkTrackerSummaryPercent3)
+        updateActivityResult(viewState.shouldReloadPage)
     }
 
     private fun renderToggle(enabled: Boolean) {
@@ -131,6 +126,14 @@ class PrivacyDashboardActivity : DuckDuckGoActivity() {
         }
     }
 
+    private fun updateActivityResult(shouldReload: Boolean) {
+        if (shouldReload) {
+            setResult(RELOAD_RESULT_CODE)
+        } else {
+            setResult(Activity.RESULT_OK)
+        }
+    }
+
     companion object {
 
         private const val REQUEST_CODE_PRIVACY_PRACTICES = 100
diff --git a/app/src/main/java/com/duckduckgo/app/privacymonitor/ui/PrivacyDashboardViewModel.kt b/app/src/main/java/com/duckduckgo/app/privacymonitor/ui/PrivacyDashboardViewModel.kt
@@ -45,16 +45,20 @@ class PrivacyDashboardViewModel(private val settingsStore: PrivacySettingsStore,
             val networkTrackerSummaryName3: String?,
             val networkTrackerSummaryPercent1: Float,
             val networkTrackerSummaryPercent2: Float,
-            val networkTrackerSummaryPercent3: Float
+            val networkTrackerSummaryPercent3: Float,
+            val shouldReloadPage: Boolean
     )
 
     val viewState: MutableLiveData<ViewState> = MutableLiveData()
+    private var monitor: PrivacyMonitor? = null
 
     private val networkPercentsData: LiveData<Array<NetworkPercent>> = networkLeaderboardDao.networkPercents()
     private val networkPercentsObserver = Observer<Array<NetworkPercent>> { onNetworkPercentsChanged(it!!) }
+
     private val privacyInitiallyOn = settingsStore.privacyOn
 
-    private var monitor: PrivacyMonitor? = null
+    private val shouldReloadPage: Boolean
+        get() = privacyInitiallyOn != settingsStore.privacyOn
 
     init {
         resetViewState()
@@ -67,9 +71,6 @@ class PrivacyDashboardViewModel(private val settingsStore: PrivacySettingsStore,
         networkPercentsData.removeObserver(networkPercentsObserver)
     }
 
-    val shouldReloadPage: Boolean
-        get() = privacyInitiallyOn != settingsStore.privacyOn
-
     fun onNetworkPercentsChanged(networkPercents: Array<NetworkPercent>) {
 
         val enoughNetworksDetected = networkPercents.size >= 3
@@ -85,7 +86,6 @@ class PrivacyDashboardViewModel(private val settingsStore: PrivacySettingsStore,
                 networkTrackerSummaryPercent2 = if (showSummary) networkPercents[1].percent else 0.0f,
                 networkTrackerSummaryPercent3 = if (showSummary) networkPercents[2].percent else 0.0f
         )
-
     }
 
     fun onPrivacyMonitorChanged(monitor: PrivacyMonitor?) {
@@ -113,7 +113,8 @@ class PrivacyDashboardViewModel(private val settingsStore: PrivacySettingsStore,
                 networkTrackerSummaryName3 = null,
                 networkTrackerSummaryPercent1 = 0f,
                 networkTrackerSummaryPercent2 = 0f,
-                networkTrackerSummaryPercent3 = 0f
+                networkTrackerSummaryPercent3 = 0f,
+                shouldReloadPage = shouldReloadPage
         )
     }
 
@@ -133,7 +134,8 @@ class PrivacyDashboardViewModel(private val settingsStore: PrivacySettingsStore,
         if (enabled != viewState.value?.toggleEnabled) {
             settingsStore.privacyOn = enabled
             viewState.value = viewState.value?.copy(
-                    toggleEnabled = enabled
+                    toggleEnabled = enabled,
+                    shouldReloadPage = shouldReloadPage
             )
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ apply plugin: 'kotlin-kapt'`
`6`	`6`	`apply from: '../versioning.gradle'`
`7`	`7`
`8`	`8`	`ext {`
`9`		`- VERSION_NAME = "4.0.3"`
	`9`	`+ VERSION_NAME = "4.0.4"`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`android {`
Original file line number	Diff line number	Diff line change
`@@ -305,9 +305,11 @@ class BrowserViewModelTest {`
`305`	`305`	`}`
`306`	`306`
`307`	`307`	`@Test`
`308`		`- fun whenTrackerDetectedThenPrivacyGradeIsUpdated() {`
	`308`	`+ fun whenEnoughTrackersDetectedThenPrivacyGradeIsUpdated() {`
`309`	`309`	`testee.urlChanged("https://example.com")`
`310`		`- testee.trackerDetected(TrackingEvent("https://example.com", "", null, false))`
	`310`	`+ for (i in 1..10) {`
	`311`	`+ testee.trackerDetected(TrackingEvent("https://example.com", "", null, false))`
	`312`	`+ }`
`311`	`313`	`assertEquals(PrivacyGrade.C, testee.privacyGrade.value)`
`312`	`314`	`}`
`313`	`315`