update unit testing for setting the binder and stopping tor

Author: 05nelsonm

topl-service/src/test/java/io/matthewnelson/test_helpers/service/TestTorService.kt

@@ -83,7 +83,6 @@ import io.matthewnelson.topl_service.service.components.onionproxy.ServiceTorIns
 import io.matthewnelson.topl_service.service.components.onionproxy.ServiceTorSettings
 import io.matthewnelson.topl_service.service.BaseService
 import io.matthewnelson.topl_service.service.components.actions.ServiceActionProcessor
-import io.matthewnelson.topl_service.service.components.binding.TorServiceConnection
 import io.matthewnelson.topl_service.service.components.receiver.TorServiceReceiver
 import kotlinx.coroutines.*
 import kotlinx.coroutines.test.TestCoroutineScope
@@ -104,17 +103,13 @@ internal class TestTorService(
     val testTorServiceBinder: TestTorServiceBinder by lazy {
             TestTorServiceBinder(this)
     }
-    var serviceIsBound = false
-        private set
 
     override fun unbindTorService() {
         try {
-            unbindService(context, TorServiceConnection.torServiceConnection)
-            serviceIsBound = false
+            unbindService(context)
         } catch (e: IllegalArgumentException) {}
     }
     override fun onBind(intent: Intent?): IBinder? {
-        serviceIsBound = true
         return testTorServiceBinder
     }
 
@@ -240,6 +235,11 @@ internal class TestTorService(
     override fun startTor() {
         simulateStart()
     }
+
+    val bandwidth1000 = "1000"
+    val bandwidth0 = "0"
+
+    // Add 6_000ms delay at start of each test to account for startup time.
     @ExperimentalCoroutinesApi
     private fun simulateStart() = getScopeIO().launch {
         try {
@@ -251,19 +251,29 @@ internal class TestTorService(
             serviceEventBroadcaster.broadcastTorState(TorState.ON, TorNetworkState.DISABLED)
             delay(1000)
             serviceEventBroadcaster.broadcastTorState(TorState.ON, TorNetworkState.ENABLED)
+            delay(1000)
+            serviceEventBroadcaster.broadcastNotice("NOTICE|BaseEventListener|Bootstrapped 95% (")
+            delay(1000)
+            serviceEventBroadcaster.broadcastNotice("NOTICE|BaseEventListener|Bootstrapped 100% (")
+            delay(1000)
+            serviceEventBroadcaster.broadcastBandwidth(bandwidth1000, bandwidth1000)
+            delay(1000)
+            serviceEventBroadcaster.broadcastBandwidth(bandwidth0, bandwidth0)
         } catch (e: Exception) {
             broadcastLogger.exception(e)
         }
     }
     @WorkerThread
     override fun stopTor() {
-        try {
-            serviceEventBroadcaster.broadcastTorState(TorState.STOPPING, TorNetworkState.ENABLED)
-            serviceEventBroadcaster.broadcastTorState(TorState.STOPPING, TorNetworkState.DISABLED)
-            serviceEventBroadcaster.broadcastTorState(TorState.OFF, TorNetworkState.DISABLED)
-        } catch (e: Exception) {
-            broadcastLogger.exception(e)
-        }
+        simulateStopTor()
+    }
+
+    private fun simulateStopTor() = getScopeIO().launch {
+        serviceEventBroadcaster.broadcastTorState(TorState.STOPPING, TorNetworkState.ENABLED)
+        delay(1000)
+        serviceEventBroadcaster.broadcastTorState(TorState.STOPPING, TorNetworkState.DISABLED)
+        delay(1000)
+        serviceEventBroadcaster.broadcastTorState(TorState.OFF, TorNetworkState.DISABLED)
     }
     @WorkerThread
     @Throws(

topl-service/src/test/java/io/matthewnelson/topl_service/service/TorServiceUnitTest.kt

@@ -67,6 +67,7 @@
 package io.matthewnelson.topl_service.service
 
 import android.app.Application
+import android.content.ComponentName
 import android.content.Intent
 import androidx.test.core.app.ApplicationProvider
 import io.matthewnelson.test_helpers.application_provided_classes.TestEventBroadcaster
@@ -92,11 +93,10 @@ import kotlinx.coroutines.test.resetMain
 import kotlinx.coroutines.test.runBlockingTest
 import kotlinx.coroutines.test.setMain
 import org.junit.After
+import org.junit.Assert.*
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
 import org.junit.rules.TemporaryFolder
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
@@ -154,7 +154,26 @@ internal class TorServiceUnitTest {
             .build()
 
         Dispatchers.setMain(testDispatcher)
+
+        // Setup TestTorService
         testTorService = TestTorService(app, testDispatcher)
+
+        // Ensure everything's cleared
+        shadowOf(app).clearStartedServices()
+        assertNull(shadowOf(app).nextStartedService)
+
+        // Ensure binder is being set when startService is called
+        shadowOf(app).setComponentNameAndServiceForBindService(
+            ComponentName(app.applicationContext, TestTorService::class.java),
+            testTorService.testTorServiceBinder
+        )
+        BaseService.startService(app, TestTorService::class.java)
+        assertEquals(shadowOf(app).nextStartedService.action, ServiceActionName.START)
+        assertNotNull(TorServiceConnection.serviceBinder)
+
+        // Simulate startup
+        testTorService.onCreate()
+        testTorService.onStartCommand(Intent(ServiceActionName.START), 0, 0)
     }
 
     private fun getNewServiceNotificationBuilder(): ServiceNotification.Builder =
@@ -174,8 +193,7 @@ internal class TorServiceUnitTest {
         // Build it prior to initializing TorServiceController with the builder
         // so we get our test classes initialized which won't be overwritten.
         backgroundPolicyBuilder.build(
-            TestTorService::class.java,
-            TorServiceConnection.torServiceConnection
+            TestTorService::class.java
         )
 
         return TorServiceController.Builder(
@@ -201,8 +219,6 @@ internal class TorServiceUnitTest {
     @ExperimentalCoroutinesApi
     @Test
     fun `validate startup state`() = runBlockingTest(testDispatcher) {
-        simulateStartService()
-
         // Check EventBroadcasters are working and notification is being updated
         var statePair = testTorService.getSimulatedTorStates()
         assertEquals(TorState.STARTING, statePair.first)
@@ -226,26 +242,27 @@ internal class TorServiceUnitTest {
         // Waiting to Bootstrap
         assertEquals(true, serviceNotification.progressBarShown)
         assertEquals(serviceNotification.imageNetworkDisabled, serviceNotification.currentIcon)
+        delay(1000)
 
         // Bootstrapped
-        serviceEventBroadcaster.broadcastNotice("NOTICE|BaseEventListener|Bootstrapped 95% (")
         assertEquals("Bootstrapped 95%", serviceNotification.currentContentText)
-        serviceEventBroadcaster.broadcastNotice("NOTICE|BaseEventListener|Bootstrapped 100% (")
+        delay(1000)
+
         assertEquals("Bootstrapped 100%", serviceNotification.currentContentText)
         assertEquals(false, serviceNotification.progressBarShown)
         assertEquals(serviceNotification.imageNetworkEnabled, serviceNotification.currentIcon)
+        delay(1000)
 
         // Data transfer
-        val bytesRead = "1000"
-        val bytesWritten = "1050"
-        serviceEventBroadcaster.broadcastBandwidth(bytesRead, bytesWritten)
+        val bandwidth = testTorService.bandwidth1000
         val contentTextString =
-            ServiceUtilities.getFormattedBandwidthString(bytesRead.toLong(), bytesWritten.toLong())
+            ServiceUtilities.getFormattedBandwidthString(bandwidth.toLong(), bandwidth.toLong())
         assertEquals(contentTextString, serviceNotification.currentContentText)
         assertEquals(serviceNotification.imageDataTransfer, serviceNotification.currentIcon)
-        serviceEventBroadcaster.broadcastBandwidth("0", "0")
-        assertEquals(serviceNotification.imageNetworkEnabled, serviceNotification.currentIcon)
+        delay(1000)
 
+        assertEquals(serviceNotification.imageNetworkEnabled, serviceNotification.currentIcon)
+        delay(1000)
 
         // Ensure Receivers were registered
         shadowOf(app).registeredReceivers.elementAtOrNull(0)?.let {
@@ -264,9 +281,46 @@ internal class TorServiceUnitTest {
         testTorService.refreshBroadcastLoggerWasCalled = false
     }
 
-    private fun simulateStartService() {
-        testTorService.onCreate()
-        testTorService.onStartCommand(Intent(ServiceActionName.START), 0, 0)
-        testTorService.onBind(null)
+    @ExperimentalCoroutinesApi
+    @Test
+    fun `calling stopTor cleans up`() = runBlockingTest(testDispatcher){
+        delay(6000) // testTorService.simulateStart() takes 6000ms
+
+        TorServiceController.stopTor()
+
+        // Broadcaster and notification are working properly
+        var statePair = testTorService.getSimulatedTorStates()
+        assertEquals(TorState.STOPPING, statePair.first)
+        assertEquals(TorNetworkState.ENABLED, statePair.second)
+        assertEquals(TorState.STOPPING, serviceNotification.currentContentTitle)
+        assertEquals("Stopping Service...", serviceNotification.currentContentText)
+        delay(1000)
+
+        statePair = testTorService.getSimulatedTorStates()
+        assertEquals(TorState.STOPPING, statePair.first)
+        assertEquals(TorNetworkState.DISABLED, statePair.second)
+        assertEquals(TorState.STOPPING, serviceNotification.currentContentTitle)
+        delay(1000)
+
+        statePair = testTorService.getSimulatedTorStates()
+        assertEquals(TorState.OFF, statePair.first)
+        assertEquals(TorNetworkState.DISABLED, statePair.second)
+        assertEquals(TorState.OFF, serviceNotification.currentContentTitle)
+        delay(1000)
+
+        // Ensure Receivers were unregistered
+        shadowOf(app).registeredReceivers.elementAtOrNull(0)?.let {
+            // Registered with the system
+            assertNull(it.broadcastReceiver)
+            // Boolean value is correct
+            assertEquals(false, TorServiceReceiver.isRegistered)
+        }
+
+        // Test TorServicePrefsListener is unregistered
+        val currentHasDebugLogsValue = testTorService.serviceTorSettings.hasDebugLogs
+        val prefs = TorServicePrefs(app.applicationContext)
+        assertFalse(testTorService.refreshBroadcastLoggerWasCalled)
+        prefs.putBoolean(PrefKeyBoolean.HAS_DEBUG_LOGS, !currentHasDebugLogsValue)
+        assertFalse(testTorService.refreshBroadcastLoggerWasCalled)
     }
 }