Add unit tests for NetworkConnectionMonitor

Extract the NetworkCallback logic into @VisibleForTesting onNetworkAvailable/
onNetworkLost so the connected-state model can be tested without the Android
framework wiring in start(). Add NetworkConnectionMonitorTest covering: connected
on first network, disconnected when the last network is lost, no false disconnect
during a handover, de-dupe when unchanged, and re-emit on reconnect.

Satisfies the Danger check requiring tests for the new class.

Author: nbradbury

WordPress/src/main/java/org/wordpress/android/networking/NetworkConnectionMonitor.kt

@@ -7,6 +7,7 @@ import android.net.NetworkCapabilities
 import android.net.NetworkRequest
 import android.os.Handler
 import android.os.HandlerThread
+import androidx.annotation.VisibleForTesting
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import org.wordpress.android.util.AppLog
@@ -46,14 +47,8 @@ class NetworkConnectionMonitor @Inject constructor() {
 
         val thread = HandlerThread("NetworkConnectionMonitor").apply { start() }
         val callback = object : ConnectivityManager.NetworkCallback() {
-            override fun onAvailable(network: Network) {
-                availableNetworks.add(network)
-                onConnectivityChanged(availableNetworks.isNotEmpty())
-            }
-            override fun onLost(network: Network) {
-                availableNetworks.remove(network)
-                onConnectivityChanged(availableNetworks.isNotEmpty())
-            }
+            override fun onAvailable(network: Network) = onNetworkAvailable(network)
+            override fun onLost(network: Network) = onNetworkLost(network)
         }
         val request = NetworkRequest.Builder()
             .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
@@ -62,6 +57,18 @@ class NetworkConnectionMonitor @Inject constructor() {
         started = true
     }
 
+    @VisibleForTesting
+    internal fun onNetworkAvailable(network: Network) {
+        availableNetworks.add(network)
+        onConnectivityChanged(availableNetworks.isNotEmpty())
+    }
+
+    @VisibleForTesting
+    internal fun onNetworkLost(network: Network) {
+        availableNetworks.remove(network)
+        onConnectivityChanged(availableNetworks.isNotEmpty())
+    }
+
     /**
      * Called on the monitor's background thread. Updates [isConnected] on the first callback and whenever the
      * connected state actually changes, so observers aren't spammed while connectivity churns.

WordPress/src/test/java/org/wordpress/android/networking/NetworkConnectionMonitorTest.kt

@@ -0,0 +1,73 @@
+package org.wordpress.android.networking
+
+import android.net.Network
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.Before
+import org.junit.Test
+import org.mockito.kotlin.mock
+import org.wordpress.android.BaseUnitTest
+
+@ExperimentalCoroutinesApi
+class NetworkConnectionMonitorTest : BaseUnitTest() {
+    private lateinit var monitor: NetworkConnectionMonitor
+    private val emissions = mutableListOf<Boolean>()
+
+    @Before
+    fun setUp() {
+        monitor = NetworkConnectionMonitor()
+        monitor.isConnected.observeForever { emissions.add(it) }
+    }
+
+    @Test
+    fun `emits connected when the first network becomes available`() {
+        monitor.onNetworkAvailable(mock())
+
+        assertThat(monitor.isConnected.value).isTrue
+        assertThat(emissions).containsExactly(true)
+    }
+
+    @Test
+    fun `emits disconnected when the only network is lost`() {
+        val network = mock<Network>()
+        monitor.onNetworkAvailable(network)
+        monitor.onNetworkLost(network)
+
+        assertThat(monitor.isConnected.value).isFalse
+        assertThat(emissions).containsExactly(true, false)
+    }
+
+    @Test
+    fun `does not report a disconnection during a network handover`() {
+        val wifi = mock<Network>()
+        val cellular = mock<Network>()
+
+        monitor.onNetworkAvailable(wifi)
+        // the replacement network arrives before the old one is torn down
+        monitor.onNetworkAvailable(cellular)
+        monitor.onNetworkLost(wifi)
+
+        assertThat(monitor.isConnected.value).isTrue
+        // only the initial connected emission; the handover is not a change
+        assertThat(emissions).containsExactly(true)
+    }
+
+    @Test
+    fun `does not emit again while the connected state is unchanged`() {
+        monitor.onNetworkAvailable(mock())
+        monitor.onNetworkAvailable(mock())
+
+        assertThat(emissions).containsExactly(true)
+    }
+
+    @Test
+    fun `emits again when reconnecting after a full disconnect`() {
+        val first = mock<Network>()
+        monitor.onNetworkAvailable(first)
+        monitor.onNetworkLost(first)
+        monitor.onNetworkAvailable(mock())
+
+        assertThat(monitor.isConnected.value).isTrue
+        assertThat(emissions).containsExactly(true, false, true)
+    }
+}