catalyst-core 0.3.0-beta.5 → 0.3.0-canary.2

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/utils/DeviceInfoUtilsTest.kt

@@ -0,0 +1,167 @@
+package io.yourname.androidproject.utils
+
+import android.content.Context
+import android.util.DisplayMetrics
+import android.view.Display
+import android.view.WindowManager
+import io.yourname.androidproject.security.SecurityCheckManager
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import java.util.Properties
+
+/**
+ * Unit tests for DeviceInfoUtils (Android coverage batch 4), previously
+ * entirely untested (0/~40 lines).
+ *
+ * NOTE: A root-package `io.yourname.androidproject.DeviceInfoUtilsTest`
+ * already existed before this batch (contract/shape assertions only, no
+ * mocking, doesn't call getDeviceInfo() at all). Per this task's package-
+ * matching rule, this new file lives in the `.utils` package alongside its
+ * source and is a distinct class from the old one -- both compile and run
+ * side by side. The old file is left untouched ("test files only, don't
+ * touch other files") but is a candidate for a follow-up cleanup/removal
+ * since this file supersedes it with real mock-driven coverage.
+ *
+ * Empirically confirmed facts this suite relies on (see task history):
+ * - Under this project's mockable android.jar
+ *   (testOptions.unitTests.isReturnDefaultValues = true), Build.VERSION.SDK_INT
+ *   is 0, so getDisplayMetrics() always takes the pre-R (`else`) branch:
+ *   windowManager.defaultDisplay.getMetrics(displayMetrics). The R+
+ *   WindowMetrics branch (Build.VERSION.SDK_INT >= R) is unreachable under
+ *   this test setup and is NOT covered here -- Build.VERSION.SDK_INT is a
+ *   static final int and not mockable (project-wide rule #1).
+ * - Build.MODEL / Build.MANUFACTURER are null under the mockable jar
+ *   (also unmockable per rule #1). Verified empirically (see a throwaway
+ *   org.json.JSONObject script) that `JSONObject.put(key, null)` does NOT
+ *   store a null value -- it OMITS the key entirely (`has(key)` returns
+ *   false afterwards). So this suite does NOT assert presence/absence of
+ *   "model"/"manufacturer" one way or the other as a stable contract --
+ *   only that the fields that DON'T depend on Build.* (screenWidth/
+ *   screenHeight/screenDensity/appInfo/security) are correct.
+ * - SecurityCheckManager.getLatestSecurityResults(context) is exercised
+ *   with a plain mocked Context (no SharedPreferences stubbing): its
+ *   internal try/catch absorbs the NPE from an unstubbed
+ *   getSharedPreferences() call and returns null, so getDeviceInfo() takes
+ *   the "security pending" branch. This mirrors
+ *   SecurityCheckManagerTest's own "returns null when nothing has been
+ *   saved yet" / "throws" coverage, so SecurityCheckManager's internals
+ *   are not re-tested here -- only that DeviceInfoUtils wires the pending
+ *   fallback correctly.
+ */
+class DeviceInfoUtilsTest {
+
+    private fun mockContext(widthPx: Int, heightPx: Int, density: Float): Context {
+        val display = mock<Display> {
+            on { getMetrics(any()) } doAnswer { invocation ->
+                val dm = invocation.getArgument<DisplayMetrics>(0)
+                dm.widthPixels = widthPx
+                dm.heightPixels = heightPx
+                dm.density = density
+                Unit
+            }
+        }
+        val windowManager = mock<WindowManager> {
+            on { getDefaultDisplay() } doReturn display
+        }
+        return mock {
+            on { getSystemService(Context.WINDOW_SERVICE) } doReturn windowManager
+        }
+    }
+
+    // ============================================================
+    // Screen dimension fields (via the pre-R WindowManager path)
+    // ============================================================
+
+    @Test
+    fun `getDeviceInfo populates screen fields from the deprecated defaultDisplay path`() {
+        val context = mockContext(widthPx = 1080, heightPx = 2280, density = 2.75f)
+
+        val info = DeviceInfoUtils.getDeviceInfo(context)
+
+        assertEquals(1080, info.getInt("screenWidth"))
+        assertEquals(2280, info.getInt("screenHeight"))
+        assertEquals(2.75, info.getDouble("screenDensity"), 0.001)
+    }
+
+    @Test
+    fun `getDeviceInfo always sets platform to android`() {
+        val context = mockContext(widthPx = 100, heightPx = 200, density = 1.0f)
+
+        val info = DeviceInfoUtils.getDeviceInfo(context)
+
+        assertEquals("android", info.getString("platform"))
+    }
+
+    // ============================================================
+    // appInfo (from optional Properties)
+    // ============================================================
+
+    @Test
+    fun `getDeviceInfo includes appInfo from properties when present`() {
+        val context = mockContext(widthPx = 100, heightPx = 200, density = 1.0f)
+        val properties = Properties().apply { setProperty("appInfo", "MyApp v1.2.3") }
+
+        val info = DeviceInfoUtils.getDeviceInfo(context, properties)
+
+        assertEquals("MyApp v1.2.3", info.getString("appInfo"))
+    }
+
+    @Test
+    fun `getDeviceInfo sets appInfo to JSON null when properties is null`() {
+        val context = mockContext(widthPx = 100, heightPx = 200, density = 1.0f)
+
+        val info = DeviceInfoUtils.getDeviceInfo(context, null)
+
+        assertTrue(info.has("appInfo"))
+        assertTrue(info.isNull("appInfo"))
+    }
+
+    @Test
+    fun `getDeviceInfo sets appInfo to JSON null when properties lacks the key`() {
+        val context = mockContext(widthPx = 100, heightPx = 200, density = 1.0f)
+        val properties = Properties().apply { setProperty("unrelated", "value") }
+
+        val info = DeviceInfoUtils.getDeviceInfo(context, properties)
+
+        assertTrue(info.isNull("appInfo"))
+    }
+
+    // ============================================================
+    // security field
+    // ============================================================
+
+    @Test
+    fun `getDeviceInfo marks security pending when no results are saved yet`() {
+        val context = mockContext(widthPx = 100, heightPx = 200, density = 1.0f)
+
+        // No SharedPreferences stubbing -- SecurityCheckManager.getLatestSecurityResults
+        // catches the resulting failure internally and returns null (matches
+        // SecurityCheckManagerTest's own "returns null" precedent).
+        val info = DeviceInfoUtils.getDeviceInfo(context)
+
+        assertTrue(info.has("security"))
+        assertTrue(info.getJSONObject("security").getBoolean("pending"))
+    }
+
+    // ============================================================
+    // Error path
+    // ============================================================
+
+    @Test
+    fun `getDeviceInfo returns an error object when getSystemService throws`() {
+        val context: Context = mock {
+            on { getSystemService(Context.WINDOW_SERVICE) } doAnswer { throw RuntimeException("boom") }
+        }
+
+        val info = DeviceInfoUtils.getDeviceInfo(context)
+
+        assertTrue(info.has("error"))
+        assertFalse(info.has("screenWidth"))
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/utils/DownloadUtilsTest.kt

@@ -0,0 +1,197 @@
+package io.yourname.androidproject.utils
+
+import android.content.Context
+import org.junit.Assert.*
+import org.junit.Test
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import java.io.File
+import java.util.concurrent.TimeUnit
+import kotlin.io.path.createTempDirectory
+
+/**
+ * Unit tests for DownloadUtils (Android coverage batch 3), previously
+ * entirely untested (0/114 lines).
+ *
+ * Context.cacheDir is mocked to a real temp directory, matching
+ * OfflineCacheServiceTest/WebCacheManagerTest's established pattern.
+ *
+ * Deliberately out of scope: downloadFile/getRemoteFileSize (real
+ * java.net network calls) and downloadFileWithCallback/
+ * validateDownloadRequirements (both call downloadFile/getRemoteFileSize
+ * internally, so exercising them meaningfully would require the same real
+ * network dependency) -- consistent with this project's standing stance
+ * (see WebCacheManagerTest's fetchAndCacheResourceBlocking note) against
+ * mocking java.net deeply enough to test the mock instead of the code.
+ * Covered instead: isValidUrl, extractFileNameFromUrl,
+ * hasSufficientStorage, and cleanupDownloadedFiles -- all pure logic or
+ * simple Context.cacheDir-backed file I/O.
+ */
+class DownloadUtilsTest {
+
+    private lateinit var cacheDir: File
+    private lateinit var context: Context
+
+    private fun freshContext(cacheDirOverride: File = cacheDir): Context = mock {
+        on { getCacheDir() } doReturn cacheDirOverride
+    }
+
+    @org.junit.Before
+    fun setUp() {
+        cacheDir = createTempDirectory(prefix = "catalyst-download-test").toFile()
+        context = freshContext()
+    }
+
+    @org.junit.After
+    fun tearDown() {
+        cacheDir.deleteRecursively()
+    }
+
+    // ============================================================
+    // isValidUrl
+    // ============================================================
+
+    @Test
+    fun `isValidUrl accepts a well-formed http url`() {
+        assertTrue(DownloadUtils.isValidUrl("http://example.com/file.pdf"))
+    }
+
+    @Test
+    fun `isValidUrl accepts a well-formed https url`() {
+        assertTrue(DownloadUtils.isValidUrl("https://example.com/file.pdf"))
+    }
+
+    @Test
+    fun `isValidUrl rejects a blank url`() {
+        assertFalse(DownloadUtils.isValidUrl(""))
+        assertFalse(DownloadUtils.isValidUrl("   "))
+    }
+
+    @Test
+    fun `isValidUrl rejects urls without http or https scheme`() {
+        assertFalse(DownloadUtils.isValidUrl("ftp://example.com/file.pdf"))
+        assertFalse(DownloadUtils.isValidUrl("file:///local/path"))
+        assertFalse(DownloadUtils.isValidUrl("example.com/file.pdf"))
+    }
+
+    @Test
+    fun `isValidUrl accepts a url with an empty host after the scheme`() {
+        // Verified against the real java.net.URL parser: "https://" alone
+        // parses successfully (an empty host is legal per the URL spec),
+        // and a space in the host doesn't throw either -- java.net.URL is
+        // far more lenient than the class's own KDoc ("throws if malformed")
+        // implies. Since isValidUrl already gates on startsWith("http://")/
+        // ("https://") before calling URL(...), there is no reachable input
+        // that passes that prefix check yet still throws inside URL(...) --
+        // the try/catch's catch branch is effectively unreachable for any
+        // string this method is actually called with. This test documents
+        // that finding rather than asserting a false-negative expectation.
+        assertTrue(DownloadUtils.isValidUrl("https://"))
+    }
+
+    // ============================================================
+    // extractFileNameFromUrl
+    // ============================================================
+
+    @Test
+    fun `extractFileNameFromUrl returns the last path segment`() {
+        assertEquals("file.pdf", DownloadUtils.extractFileNameFromUrl("https://example.com/path/to/file.pdf"))
+    }
+
+    @Test
+    fun `extractFileNameFromUrl strips query parameters`() {
+        assertEquals("file.pdf", DownloadUtils.extractFileNameFromUrl("https://example.com/file.pdf?token=abc123"))
+    }
+
+    @Test
+    fun `extractFileNameFromUrl falls back to a default name when the path is empty`() {
+        assertEquals("downloaded_file", DownloadUtils.extractFileNameFromUrl("https://example.com/"))
+    }
+
+    @Test
+    fun `extractFileNameFromUrl with no path segment returns the host as the filename`() {
+        // substringAfterLast("/") on "https://example.com" (no trailing
+        // slash, no path) returns "example.com" -- the whole string after
+        // the last "/" in the scheme separator itself. This is a real
+        // quirk of the current implementation, not a bug this batch is
+        // fixing; documented here rather than asserting the fallback that
+        // only actually triggers when the path segment is present but
+        // blank (covered by the trailing-slash case above).
+        assertEquals("example.com", DownloadUtils.extractFileNameFromUrl("https://example.com"))
+    }
+
+    // ============================================================
+    // hasSufficientStorage
+    // ============================================================
+
+    @Test
+    fun `hasSufficientStorage returns true when free space comfortably exceeds the requirement`() {
+        // Real temp dirs typically have plenty of free space on a CI/dev
+        // machine; request a tiny amount to make this deterministic.
+        assertTrue(DownloadUtils.hasSufficientStorage(context, requiredBytes = 1024L))
+    }
+
+    @Test
+    fun `hasSufficientStorage returns false when required bytes exceed available free space`() {
+        // File.freeSpace() reflects the real filesystem the temp dir lives
+        // on -- request far more than any real disk has to force the
+        // false branch deterministically rather than mocking File itself
+        // (File is a concrete java.io class, not mockable via Context).
+        val hugeRequirement = Long.MAX_VALUE / 2
+        assertFalse(DownloadUtils.hasSufficientStorage(context, requiredBytes = hugeRequirement))
+    }
+
+    // ============================================================
+    // cleanupDownloadedFiles
+    // ============================================================
+
+    @Test
+    fun `cleanupDownloadedFiles does nothing when the downloaded_files dir does not exist`() {
+        // No dir created -- should not throw.
+        DownloadUtils.cleanupDownloadedFiles(context)
+    }
+
+    @Test
+    fun `cleanupDownloadedFiles deletes files older than maxAgeMillis and keeps newer ones`() {
+        val downloadDir = File(cacheDir, "downloaded_files")
+        downloadDir.mkdirs()
+
+        val oldFile = File(downloadDir, "old.pdf")
+        oldFile.writeText("old content")
+        val fourDaysAgo = System.currentTimeMillis() - TimeUnit.DAYS.toMillis(4)
+        oldFile.setLastModified(fourDaysAgo)
+
+        val newFile = File(downloadDir, "new.pdf")
+        newFile.writeText("new content")
+
+        // Default maxAgeMillis is 3 days.
+        DownloadUtils.cleanupDownloadedFiles(context)
+
+        assertFalse("File older than 3 days should be deleted", oldFile.exists())
+        assertTrue("Recently-modified file should survive cleanup", newFile.exists())
+    }
+
+    @Test
+    fun `cleanupDownloadedFiles respects a custom maxAgeMillis`() {
+        val downloadDir = File(cacheDir, "downloaded_files")
+        downloadDir.mkdirs()
+
+        val file = File(downloadDir, "recent.pdf")
+        file.writeText("content")
+        val oneHourAgo = System.currentTimeMillis() - TimeUnit.HOURS.toMillis(1)
+        file.setLastModified(oneHourAgo)
+
+        // maxAgeMillis of 30 minutes -- the 1-hour-old file should be
+        // deleted even though it wouldn't be under the 3-day default.
+        DownloadUtils.cleanupDownloadedFiles(context, maxAgeMillis = TimeUnit.MINUTES.toMillis(30))
+
+        assertFalse(file.exists())
+    }
+
+    @Test
+    fun `cleanupDownloadedFiles on an empty downloaded_files dir does not throw`() {
+        val downloadDir = File(cacheDir, "downloaded_files")
+        downloadDir.mkdirs()
+        DownloadUtils.cleanupDownloadedFiles(context)
+    }
+}

package/dist/native/androidProject/app/src/test/java/io/yourname/androidproject/utils/NetworkMonitorTest.kt

@@ -0,0 +1,271 @@
+package io.yourname.androidproject.utils
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkRequest
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.mockito.MockedConstruction
+import org.mockito.Mockito.mockConstruction
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+/**
+ * Unit tests for NetworkMonitor (Android coverage batch 3), previously
+ * entirely untested (0/25 lines). NetworkUtils (the top-level
+ * getCurrentStatus/NetworkStatus in the same file) is exercised
+ * indirectly here since NetworkMonitor.start() calls it immediately, and
+ * again from each NetworkCallback override.
+ *
+ * ConnectivityManager/Network/NetworkCapabilities are all interfaces or
+ * mockable framework classes reachable via a mocked Context.
+ * NetworkRequest.Builder is a real android.jar builder class whose
+ * methods are stubbed to return null under the mockable jar
+ * (addCapability(...) returns null, so a real `.build()` call inside
+ * start() NPEs) -- rather than skip start() coverage entirely (it's the
+ * bulk of this class), Mockito.mockConstruction(NetworkRequest.Builder)
+ * is used (mirroring MetricsMonitorTest's mockStatic(Choreographer)
+ * pattern, applied to a constructor instead of a static). No real
+ * NetworkRequest.Builder is ever constructed, so this stays compliant
+ * with the project's "don't call .build() on real platform builders"
+ * rule -- the builder itself is fully faked. Kept open for every test's
+ * lifetime since start() constructs a fresh Builder on each call.
+ *
+ * Build.VERSION.SDK_INT resolves to 0 under the mockable android.jar
+ * (confirmed empirically), so `Build.VERSION.SDK_INT >= Build.VERSION_CODES.N`
+ * is always false in these tests -- the registerNetworkCallback(request,
+ * callback) branch is the only one structurally reachable here.
+ * registerDefaultNetworkCallback is never invoked and is not tested.
+ */
+class NetworkMonitorTest {
+
+    private lateinit var connectivityManager: ConnectivityManager
+    private lateinit var appContext: Context
+    private lateinit var context: Context
+    private lateinit var requestBuilderMock: MockedConstruction<NetworkRequest.Builder>
+
+    @Before
+    fun setUp() {
+        connectivityManager = mock()
+        appContext = mock {
+            on { getSystemService(Context.CONNECTIVITY_SERVICE) } doReturn connectivityManager
+        }
+        context = mock {
+            on { getApplicationContext() } doReturn appContext
+        }
+
+        // Default: no active network -- getCurrentStatus resolves to offline
+        // unless a test overrides these.
+        whenever(connectivityManager.activeNetwork).thenReturn(null)
+        whenever(connectivityManager.getNetworkCapabilities(anyOrNull())).thenReturn(null)
+        whenever(connectivityManager.activeNetworkInfo).thenReturn(null)
+
+        requestBuilderMock = mockConstruction(NetworkRequest.Builder::class.java) { builderMock, _ ->
+            whenever(builderMock.addCapability(any())).thenReturn(builderMock)
+            whenever(builderMock.build()).thenReturn(mock<NetworkRequest>())
+        }
+    }
+
+    @After
+    fun tearDown() {
+        requestBuilderMock.close()
+    }
+
+    // ============================================================
+    // start()
+    // ============================================================
+
+    @Test
+    fun `start emits the current status immediately`() {
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+
+        monitor.start()
+
+        assertEquals(1, statuses.size)
+        assertEquals(false, statuses[0].isOnline)
+    }
+
+    @Test
+    fun `start emits an online status when capabilities report internet validated`() {
+        val capabilities = mock<NetworkCapabilities> {
+            on { hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED) } doReturn true
+            on { hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) } doReturn true
+            on { hasTransport(any()) } doReturn false
+        }
+        val network = mock<Network>()
+        whenever(connectivityManager.activeNetwork).thenReturn(network)
+        whenever(connectivityManager.getNetworkCapabilities(network)).thenReturn(capabilities)
+
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+
+        monitor.start()
+
+        assertEquals(1, statuses.size)
+        assertTrue(statuses[0].isOnline)
+    }
+
+    @Test
+    fun `start registers a network callback via registerNetworkCallback`() {
+        val monitor = NetworkMonitor(context) { }
+
+        monitor.start()
+
+        verify(connectivityManager).registerNetworkCallback(
+            any<NetworkRequest>(),
+            any<ConnectivityManager.NetworkCallback>()
+        )
+    }
+
+    @Test
+    fun `calling start twice does not emit a second immediate status or re-register`() {
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+
+        monitor.start()
+        monitor.start()
+
+        // Second start() is a no-op guarded by `if (callback != null) return`.
+        assertEquals(1, statuses.size)
+        verify(connectivityManager, times(1)).registerNetworkCallback(
+            any<NetworkRequest>(),
+            any<ConnectivityManager.NetworkCallback>()
+        )
+    }
+
+    @Test
+    fun `start swallows a registration exception and resets callback to null`() {
+        whenever(
+            connectivityManager.registerNetworkCallback(
+                any<NetworkRequest>(),
+                any<ConnectivityManager.NetworkCallback>()
+            )
+        ).thenThrow(RuntimeException("boom"))
+
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+
+        // Should not throw -- try/catch swallows the registration failure
+        // and resets callback to null.
+        monitor.start()
+
+        // The immediate status emission still happened before the
+        // exception (it's emitted first, outside the try/catch).
+        assertEquals(1, statuses.size)
+
+        // Since callback was reset to null, a second start() is not
+        // treated as a no-op -- it emits a second immediate status and
+        // retries registration.
+        monitor.start()
+        assertEquals(2, statuses.size)
+        verify(connectivityManager, times(2)).registerNetworkCallback(
+            any<NetworkRequest>(),
+            any<ConnectivityManager.NetworkCallback>()
+        )
+    }
+
+    // ============================================================
+    // stop()
+    // ============================================================
+
+    @Test
+    fun `stop before start does not throw and does not unregister`() {
+        val monitor = NetworkMonitor(context) { }
+        monitor.stop()
+        verify(connectivityManager, never()).unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>())
+    }
+
+    @Test
+    fun `stop after start unregisters the callback`() {
+        val monitor = NetworkMonitor(context) { }
+        monitor.start()
+
+        monitor.stop()
+
+        verify(connectivityManager).unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>())
+    }
+
+    @Test
+    fun `stop swallows an unregister exception`() {
+        whenever(connectivityManager.unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>()))
+            .thenThrow(RuntimeException("boom"))
+        val monitor = NetworkMonitor(context) { }
+        monitor.start()
+
+        // Should not throw.
+        monitor.stop()
+    }
+
+    @Test
+    fun `calling stop twice only unregisters once`() {
+        val monitor = NetworkMonitor(context) { }
+        monitor.start()
+        monitor.stop()
+        monitor.stop()
+
+        // unregisterNetworkCallback should only be invoked once -- the
+        // second stop() sees callback == null and no-ops.
+        verify(connectivityManager, times(1)).unregisterNetworkCallback(any<ConnectivityManager.NetworkCallback>())
+    }
+
+    // ============================================================
+    // NetworkCallback overrides (onAvailable/onLost/onUnavailable) --
+    // captured via ArgumentCaptor and invoked directly, since there's no
+    // real ConnectivityManager driving them in a JVM unit test.
+    // ============================================================
+
+    @Test
+    fun `onAvailable re-emits the current status`() {
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+        monitor.start()
+
+        val captor = argumentCaptor<ConnectivityManager.NetworkCallback>()
+        verify(connectivityManager).registerNetworkCallback(any<NetworkRequest>(), captor.capture())
+
+        captor.firstValue.onAvailable(mock())
+
+        assertEquals(2, statuses.size)
+    }
+
+    @Test
+    fun `onLost re-emits the current status`() {
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+        monitor.start()
+
+        val captor = argumentCaptor<ConnectivityManager.NetworkCallback>()
+        verify(connectivityManager).registerNetworkCallback(any<NetworkRequest>(), captor.capture())
+
+        captor.firstValue.onLost(mock())
+
+        assertEquals(2, statuses.size)
+    }
+
+    @Test
+    fun `onUnavailable re-emits the current status`() {
+        val statuses = mutableListOf<NetworkStatus>()
+        val monitor = NetworkMonitor(context) { statuses.add(it) }
+        monitor.start()
+
+        val captor = argumentCaptor<ConnectivityManager.NetworkCallback>()
+        verify(connectivityManager).registerNetworkCallback(any<NetworkRequest>(), captor.capture())
+
+        captor.firstValue.onUnavailable()
+
+        assertEquals(2, statuses.size)
+    }
+}