Live content updates for Privacy Dashboard

* Add live content updates to the Privacy Dashboard
* Refactor tracking event to include network information and remove repeated lookups which are slow
* Update outdated gradle dependencies

Author: subsymbolic

app/build.gradle

@@ -74,7 +74,7 @@ android {
 }
 
 ext {
-    supportLibrary = "27.0.1"
+    supportLibrary = "27.0.2"
     architectureComponents = "1.0.0"
     dagger = "2.13"
     retrofit = "2.3.0"
@@ -103,14 +103,14 @@ dependencies {
     kapt "com.google.dagger:dagger-android-processor:$dagger"
     kapt "com.google.dagger:dagger-compiler:$dagger"
 
-    testImplementation "org.mockito:mockito-core:2.12.0"
+    testImplementation "org.mockito:mockito-core:2.13.0"
     testImplementation "com.nhaarman:mockito-kotlin-kt1.1:1.5.0"
     testImplementation "junit:junit:4.12"
     testImplementation "android.arch.core:core-testing:$architectureComponents"
 
     androidTestImplementation "com.android.support.test:runner:1.0.1"
     androidTestImplementation "com.android.support.test.espresso:espresso-core:3.0.1"
-    androidTestImplementation "org.mockito:mockito-android:2.12.0"
+    androidTestImplementation "org.mockito:mockito-android:2.13.0"
     androidTestImplementation "com.nhaarman:mockito-kotlin-kt1.1:1.5.0"
     androidTestImplementation "android.arch.core:core-testing:$architectureComponents"
 }

app/src/androidTest/java/com/duckduckgo/app/browser/BrowserViewModelTest.kt

@@ -22,15 +22,14 @@ import android.net.Uri
 import com.duckduckgo.app.browser.BrowserViewModel.NavigationCommand
 import com.duckduckgo.app.browser.BrowserViewModel.ViewState
 import com.duckduckgo.app.browser.omnibar.OmnibarEntryConverter
-import com.duckduckgo.app.trackerdetection.model.NetworkTrackers
+import com.duckduckgo.app.privacymonitor.store.PrivacyMonitorRepository
 import com.nhaarman.mockito_kotlin.mock
 import org.junit.After
 import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
 import org.mockito.ArgumentMatchers
-import org.mockito.Mock
 import org.mockito.Mockito.never
 import org.mockito.Mockito.verify
 
@@ -40,26 +39,23 @@ class BrowserViewModelTest {
     @Suppress("unused")
     var instantTaskExecutorRule = InstantTaskExecutorRule()
 
-    @Mock
-    private val viewStateObserver: Observer<ViewState> = mock()
-
-    @Mock
-    private val queryObserver: Observer<String> = mock()
-
-    @Mock
-    private val navigationObserver: Observer<NavigationCommand> = mock()
+    private lateinit var viewStateObserver: Observer<ViewState>
+    private lateinit var queryObserver: Observer<String>
+    private lateinit var navigationObserver: Observer<NavigationCommand>
+    private lateinit var testee: BrowserViewModel
 
     private val testOmnibarConverter: OmnibarEntryConverter = object : OmnibarEntryConverter {
         override fun convertUri(input: String): String = "duckduckgo.com"
         override fun isWebUrl(inputQuery: String): Boolean = true
         override fun convertQueryToUri(inputQuery: String): Uri = Uri.parse("duckduckgo.com")
     }
 
-    private lateinit var testee: BrowserViewModel
-
     @Before
     fun before() {
-        testee = BrowserViewModel(testOmnibarConverter, DuckDuckGoUrlDetector(), NetworkTrackers())
+        viewStateObserver = mock()
+        queryObserver = mock()
+        navigationObserver = mock()
+        testee = BrowserViewModel(testOmnibarConverter, DuckDuckGoUrlDetector(), PrivacyMonitorRepository())
         testee.query.observeForever(queryObserver)
         testee.viewState.observeForever(viewStateObserver)
         testee.navigation.observeForever(navigationObserver)

app/src/androidTest/java/com/duckduckgo/app/privacydashboard/PrivacyDashboardViewModelTest.kt

@@ -29,24 +29,21 @@ import org.junit.Assert.assertEquals
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import org.mockito.Mock
 
 class PrivacyDashboardViewModelTest {
 
     @get:Rule
     @Suppress("unused")
     var instantTaskExecutorRule = InstantTaskExecutorRule()
 
-    @Mock
-    private val viewStateObserver: Observer<PrivacyDashboardViewModel.ViewState> = mock()
-
-    @Mock
-    private val monitor: PrivacyMonitor = mock()
-
+    private lateinit var viewStateObserver: Observer<PrivacyDashboardViewModel.ViewState>
+    private lateinit var monitor: PrivacyMonitor
     private lateinit var testee: PrivacyDashboardViewModel
 
     @Before
     fun before() {
+        viewStateObserver = mock()
+        monitor = mock()
         testee = PrivacyDashboardViewModel(InstrumentationRegistry.getTargetContext())
         testee.viewState.observeForever(viewStateObserver)
         whenever(monitor.https).thenReturn(HttpsStatus.SECURE)
@@ -60,52 +57,52 @@ class PrivacyDashboardViewModelTest {
     @Test
     fun whenHttpsStatusIsSecureThenTextAndIconReflectSame() {
         whenever(monitor.https).thenReturn(HttpsStatus.SECURE)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals(getStringResource(R.string.httpsGood), testee.viewState.value?.httpsText)
         assertEquals(R.drawable.dashboard_https_good, testee.viewState.value?.httpsIcon)
     }
 
     @Test
     fun whenHttpsStatusIsMixedThenTextAndIconReflectSame() {
         whenever(monitor.https).thenReturn(HttpsStatus.MIXED)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals(getStringResource(R.string.httpsMixed), testee.viewState.value?.httpsText)
         assertEquals(R.drawable.dashboard_https_neutral, testee.viewState.value?.httpsIcon)
     }
 
     @Test
     fun whenHttpsStatusIsNoneThenTextAndIconReflectSame() {
         whenever(monitor.https).thenReturn(HttpsStatus.NONE)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals(getStringResource(R.string.httpsBad), testee.viewState.value?.httpsText)
         assertEquals(R.drawable.dashboard_https_bad, testee.viewState.value?.httpsIcon)
     }
 
     @Test
     fun whenNoTrackersNetworksThenNetworkTextShowsZero() {
         whenever(monitor.networkCount).thenReturn(0)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals("0 Tracker Networks Blocked", testee.viewState.value?.networksText)
     }
 
     @Test
     fun whenTenTrackersNetworksThenNetworkTextShowsTen() {
         whenever(monitor.networkCount).thenReturn(10)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals("10 Tracker Networks Blocked", testee.viewState.value?.networksText)
     }
 
     @Test
     fun whenNoMajorTrackersNetworksThenMajorNetworkTextShowsZero() {
         whenever(monitor.majorNetworkCount).thenReturn(0)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals("0 Major Tracker Networks Blocked", testee.viewState.value?.majorNetworksText)
     }
 
     @Test
     fun whenTenMajorTrackersNetworksThenMajorNetworkTextShowsTen() {
         whenever(monitor.majorNetworkCount).thenReturn(10)
-        testee.updatePrivacyMonitor(monitor)
+        testee.onPrivacyMonitorChanged(monitor)
         assertEquals("10 Major Tracker Networks Blocked", testee.viewState.value?.majorNetworksText)
     }
 

app/src/androidTest/java/com/duckduckgo/app/privacymonitor/SiteMonitorInstrumentationTests.kt

@@ -16,7 +16,6 @@
 
 package com.duckduckgo.app.privacymonitor
 
-import com.duckduckgo.app.trackerdetection.model.NetworkTrackers
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
@@ -30,26 +29,26 @@ class SiteMonitorInstrumentationTests {
 
     @Test
     fun whenUrlIsHttpsThenHttpsStatusIsSecure() {
-        val testee = SiteMonitor(httpsDocument, NetworkTrackers())
+        val testee = SiteMonitor(httpsDocument)
         assertEquals(HttpsStatus.SECURE, testee.https)
     }
 
     @Test
     fun whenUrlIsHttpThenHttpsStatusIsNone() {
-        val testee = SiteMonitor(httpDocument, NetworkTrackers())
+        val testee = SiteMonitor(httpDocument)
         assertEquals(HttpsStatus.NONE, testee.https)
     }
 
     @Test
     fun whenUrlIsHttpsWithHttpResourcesThenHttpsStatusIsMixed() {
-        val testee = SiteMonitor(httpsDocument, NetworkTrackers())
+        val testee = SiteMonitor(httpsDocument)
         testee.hasHttpResources = true
         assertEquals(HttpsStatus.MIXED, testee.https)
     }
 
     @Test
     fun whenUrlIsMalformedThenHttpsStatusIsNone() {
-        val testee = SiteMonitor(malformesDocument, NetworkTrackers())
+        val testee = SiteMonitor(malformesDocument)
         assertEquals(HttpsStatus.NONE, testee.https)
     }
 }

app/src/androidTest/java/com/duckduckgo/app/trackerdetection/TrackerDetectorInstrumentationTest.kt

@@ -16,22 +16,19 @@
 
 package com.duckduckgo.app.trackerdetection
 
-import com.duckduckgo.app.trackerdetection.model.DisconnectTracker
-import com.duckduckgo.app.trackerdetection.model.NetworkTrackers
-import com.duckduckgo.app.trackerdetection.model.ResourceType
+import com.duckduckgo.app.trackerdetection.model.*
 import com.nhaarman.mockito_kotlin.any
 import com.nhaarman.mockito_kotlin.mock
 import com.nhaarman.mockito_kotlin.whenever
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
 import org.junit.Test
 import org.mockito.ArgumentMatchers.anyString
-import java.util.*
 
 
 class TrackerDetectorInstrumentationTest {
 
-    private val networkTrackers = NetworkTrackers()
+    private val networkTrackers = TrackerNetworks()
     private val trackerDetector = TrackerDetector(networkTrackers)
 
     companion object {
@@ -40,71 +37,89 @@ class TrackerDetectorInstrumentationTest {
     }
 
     @Test
-    fun whenThereAreNoClientsThenShouldBlockIsFalse() {
-        assertFalse(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+    fun whenThereAreNoClientsThenEvaluateReturnsNull() {
+        assertNull(trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenAllClientsFailToMatchThenShouldBlockIsFalse() {
+    fun whenAllClientsFailToMatchThenEvaluateReturnsNull() {
         trackerDetector.addClient(neverMatchingClient())
         trackerDetector.addClient(neverMatchingClient())
-        assertFalse(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenAllClientsMatchThenShouldBlockIsTrue() {
+    fun whenAllClientsMatchThenEvaluateReturnsTrackingEvent() {
         trackerDetector.addClient(alwaysMatchingClient())
         trackerDetector.addClient(alwaysMatchingClient())
-        assertTrue(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+        val expected = TrackingEvent("http://example.com/index.com", "http://thirdparty.com/update.js", null, true)
+        val actual = trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType)
+        assertEquals(expected, actual)
     }
 
     @Test
-    fun whenSomeClientsMatchThenShouldBlockIsTrue() {
+    fun whenSomeClientsMatchThenEvaluateReturnsTrackingEvent() {
         trackerDetector.addClient(neverMatchingClient())
         trackerDetector.addClient(alwaysMatchingClient())
-        assertTrue(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+        val expected = TrackingEvent("http://example.com/index.com", "http://thirdparty.com/update.js", null, true)
+        val actual = trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType)
+        assertEquals(expected, actual)
     }
 
     @Test
-    fun whenUrlHasSameDomainAsDocumentThenShouldBlockIsFalse() {
+    fun whenTrackerIsPartOfNetworkThenEvaluateReturnsTrackingEventWithNetwork() {
+        val networks = arrayListOf(
+                DisconnectTracker("thirdparty.com", "", network, "http://network.com")
+        )
+        networkTrackers.updateData(networks)
+        trackerDetector.addClient(alwaysMatchingClient())
+
+        val network = TrackerNetwork(network, "http://network.com")
+        val expected = TrackingEvent("http://example.com/index.com", "http://thirdparty.com/update.js", network, true)
+        val actual = trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType)
+        assertEquals(expected, actual)
+    }
+
+    @Test
+    fun whenUrlHasSameDomainAsDocumentThenEvaluateReturnsNull() {
         trackerDetector.addClient(alwaysMatchingClient())
-        assertFalse(trackerDetector.shouldBlock("http://example.com/update.js", "http://example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://example.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenUrlIsSubdomainOfDocumentThenShouldBlockIsFalse() {
+    fun whenUrlIsSubdomainOfDocumentThenEvaluateReturnsNull() {
         trackerDetector.addClient(alwaysMatchingClient())
-        assertFalse(trackerDetector.shouldBlock("http://mobile.example.com/update.js", "http://example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://mobile.example.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenUrlIsParentOfDocumentThenShouldBlockIsFalse() {
+    fun whenUrlIsParentOfDocumentThenEvaluateReturnsNull() {
         trackerDetector.addClient(alwaysMatchingClient())
-        assertFalse(trackerDetector.shouldBlock("http://example.com/update.js", "http://mobile.example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://example.com/update.js", "http://mobile.example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenUrlIsNetworkOfDocumentThenShouldBlockIsFalse() {
-        val networks = Arrays.asList(DisconnectTracker("example.com", "", network, "http://thirdparty.com/"))
+    fun whenUrlIsNetworkOfDocumentThenEvaluateReturnsNull() {
+        val networks = arrayListOf(DisconnectTracker("example.com", "", network, "http://thirdparty.com/"))
         networkTrackers.updateData(networks)
-        assertFalse(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenDocumentIsNetworkOfUrlThenShouldBlockIsFalse() {
-        val networks = Arrays.asList(DisconnectTracker("thirdparty.com", "", network, "http://example.com"))
+    fun whenDocumentIsNetworkOfUrlThenEvaluateReturnsNull() {
+        val networks = arrayListOf(DisconnectTracker("thirdparty.com", "", network, "http://example.com"))
         networkTrackers.updateData(networks)
-        assertFalse(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     @Test
-    fun whenUrlSharesSameNetworkAsDocumentThenShouldBlockIsFalse() {
-        val networks = Arrays.asList(
+    fun whenUrlSharesSameNetworkAsDocumentThenEvaluateReturnsNull() {
+        val networks = arrayListOf(
                 DisconnectTracker("thirdparty.com", "", network, "http://network.com"),
                 DisconnectTracker("example.com", "", network, "http://network.com")
         )
         networkTrackers.updateData(networks)
-        assertFalse(trackerDetector.shouldBlock("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
+        assertNull(trackerDetector.evaluate("http://thirdparty.com/update.js", "http://example.com/index.com", resourceType))
     }
 
     private fun alwaysMatchingClient(): Client {

app/src/androidTest/java/com/duckduckgo/app/trackerdetection/TrackerDetectorListInstrumentationTest.kt

@@ -20,10 +20,11 @@ package com.duckduckgo.app.trackerdetection
 import android.support.test.runner.AndroidJUnit4
 import com.duckduckgo.app.trackerdetection.Client.ClientName.EASYLIST
 import com.duckduckgo.app.trackerdetection.Client.ClientName.EASYPRIVACY
-import com.duckduckgo.app.trackerdetection.model.NetworkTrackers
 import com.duckduckgo.app.trackerdetection.model.ResourceType
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
+import com.duckduckgo.app.trackerdetection.model.TrackerNetworks
+import com.duckduckgo.app.trackerdetection.model.TrackingEvent
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
@@ -43,27 +44,29 @@ class TrackerDetectorListInstrumentationTest {
     fun before() {
         val easylistAdblock = adblockClient(EASYLIST, "binary/easylist_sample")
         val easyprivacyAdblock = adblockClient(EASYPRIVACY, "binary/easyprivacy_sample")
-        testee = TrackerDetector(NetworkTrackers())
+        testee = TrackerDetector(TrackerNetworks())
         testee.addClient(easyprivacyAdblock)
         testee.addClient(easylistAdblock)
     }
 
     @Test
-    fun whenUrlIsInEasyListThenShouldBlockIsTrue() {
+    fun whenUrlIsInEasyListThenEvaluateReturnsTrackingEvent() {
         val url = "http://imasdk.googleapis.com/js/sdkloader/ima3.js"
-        assertTrue(testee.shouldBlock(url, documentUrl, resourceType))
+        val expected = TrackingEvent(documentUrl, url, null, true)
+        assertEquals(expected, testee.evaluate(url, documentUrl, resourceType))
     }
 
     @Test
-    fun whenUrlIsInEasyPrivacyListThenShouldBlockIsTrue() {
+    fun whenUrlIsInEasyPrivacyListThenEvaluateReturnsTrackingEvent() {
         val url = "http://cdn.tagcommander.com/1705/tc_catalog.css"
-        assertTrue(testee.shouldBlock(url, documentUrl, resourceType))
+        val expected = TrackingEvent(documentUrl, url, null, true)
+        assertEquals(expected, testee.evaluate(url, documentUrl, resourceType))
     }
 
     @Test
-    fun whenUrlIsNotInAnyTrackerListsThenShouldBlockIsFalse() {
+    fun whenUrlIsNotInAnyTrackerListsThenEvaluateReturnsNull() {
         val url = "https://duckduckgo.com/index.html"
-        assertFalse(testee.shouldBlock(url, documentUrl, resourceType))
+        assertNull(testee.evaluate(url, documentUrl, resourceType))
     }
 
     private fun adblockClient(name: Client.ClientName, dataFile: String): Client {