[WIP] Add UnifiedPushService test with workaround for PushService binder

Author: rfc2822

app/build.gradle.kts

@@ -137,6 +137,9 @@ dependencies {
     implementation(libs.kotlinx.coroutines)
     coreLibraryDesugaring(libs.android.desugaring)
 
+    // reflection
+    implementation(kotlin("reflect"))    // only for UnifiedPushService.resetBinder workaround, remove when not needed anymore
+
     // Hilt
     implementation(libs.hilt.android.base)
     ksp(libs.androidx.hilt.compiler)
@@ -217,6 +220,7 @@ dependencies {
     androidTestImplementation(libs.androidx.work.testing)
     androidTestImplementation(libs.hilt.android.testing)
     androidTestImplementation(libs.junit)
+    androidTestImplementation(libs.kotlinx.coroutines.test)
     androidTestImplementation(libs.mockk.android)
     androidTestImplementation(libs.okhttp.mockwebserver)
     androidTestImplementation(libs.room.testing)

app/src/androidTest/kotlin/at/bitfire/davdroid/push/UnifiedPushServiceTest.kt

@@ -0,0 +1,102 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.push
+
+import android.content.Context
+import android.content.Intent
+import android.os.IBinder
+import androidx.test.rule.ServiceTestRule
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.BindValue
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.coVerify
+import io.mockk.confirmVerified
+import io.mockk.every
+import io.mockk.impl.annotations.RelaxedMockK
+import io.mockk.junit4.MockKRule
+import io.mockk.mockk
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.unifiedpush.android.connector.FailedReason
+import org.unifiedpush.android.connector.PushService
+import org.unifiedpush.android.connector.data.PushEndpoint
+import javax.inject.Inject
+
+@HiltAndroidTest
+class UnifiedPushServiceTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule
+    val mockKRule = MockKRule(this)
+
+    @get:Rule
+    val serviceTestRule = ServiceTestRule()
+
+    @Inject @ApplicationContext
+    lateinit var context: Context
+
+    @RelaxedMockK @BindValue
+    lateinit var pushRegistrationManager: PushRegistrationManager
+
+    lateinit var binder: IBinder
+    lateinit var unifiedPushService: UnifiedPushService
+
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        binder = serviceTestRule.bindService(Intent(context, UnifiedPushService::class.java))!!
+        unifiedPushService = (binder as PushService.PushBinder).getService() as UnifiedPushService
+    }
+
+    @After
+    fun tearDown() {
+        UnifiedPushService.resetBinder()
+    }
+
+
+    @Test
+    fun testOnNewEndpoint_1() {
+        val endpoint = mockk<PushEndpoint> {
+            every { url } returns "https://example.com/12"
+        }
+        unifiedPushService.onNewEndpoint(endpoint, "12")
+
+        coVerify {
+            pushRegistrationManager.processSubscription(12, endpoint)
+        }
+        confirmVerified(pushRegistrationManager)
+    }
+
+    @Test
+    fun testOnNewEndpoint_2() {
+        val endpoint = mockk<PushEndpoint> {
+            every { url } returns "https://example.com/34"
+        }
+        unifiedPushService.onNewEndpoint(endpoint, "34")
+
+        coVerify {
+            pushRegistrationManager.processSubscription(34, endpoint)
+        }
+        confirmVerified(pushRegistrationManager)
+    }
+
+    @Test
+    fun testOnRegistrationFailed() {
+        unifiedPushService.onRegistrationFailed(FailedReason.INTERNAL_ERROR, "34")
+
+        coVerify {
+            pushRegistrationManager.removeSubscription(34)
+        }
+        confirmVerified(pushRegistrationManager)
+    }
+
+}

app/src/main/kotlin/at/bitfire/davdroid/push/UnifiedPushService.kt

@@ -15,13 +15,16 @@ import dagger.Lazy
 import dagger.hilt.android.AndroidEntryPoint
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
+import org.jetbrains.annotations.TestOnly
 import org.unifiedpush.android.connector.FailedReason
 import org.unifiedpush.android.connector.PushService
 import org.unifiedpush.android.connector.data.PushEndpoint
 import org.unifiedpush.android.connector.data.PushMessage
 import java.util.logging.Level
 import java.util.logging.Logger
 import javax.inject.Inject
+import kotlin.reflect.KMutableProperty
+import kotlin.reflect.jvm.isAccessible
 
 /**
  * Entry point for UnifiedPush.
@@ -59,10 +62,10 @@ class UnifiedPushService : PushService() {
 
     override fun onNewEndpoint(endpoint: PushEndpoint, instance: String) {
         val serviceId = instance.toLongOrNull() ?: return
-        logger.log(Level.FINE, "Got UnifiedPush endpoint for service $serviceId", endpoint.url)
+        logger.warning("Got UnifiedPush endpoint for service $serviceId: ${endpoint.url}")
 
         // register new endpoint at CalDAV/CardDAV servers
-        runBlocking {
+        runBlocking(Dispatchers.Default) {
             pushRegistrationManager.processSubscription(serviceId, endpoint)
         }
     }
@@ -72,7 +75,7 @@ class UnifiedPushService : PushService() {
         logger.warning("UnifiedPush registration failed for service $serviceId: $reason")
 
         // unregister subscriptions
-        runBlocking {
+        runBlocking(Dispatchers.Default) {
             pushRegistrationManager.removeSubscription(serviceId)
         }
     }
@@ -81,7 +84,7 @@ class UnifiedPushService : PushService() {
         val serviceId = instance.toLongOrNull() ?: return
         logger.warning("UnifiedPush unregistered for service $serviceId")
 
-        runBlocking {
+        runBlocking(Dispatchers.Default) {
             pushRegistrationManager.removeSubscription(serviceId)
         }
     }
@@ -145,4 +148,33 @@ class UnifiedPushService : PushService() {
         }
     }
 
+
+    companion object {
+
+        /**
+         * We need to reset PushService::Companion.binder to null before creating a new PushService with a new binder. The
+         * current implementation caches the binder, which will always use the first UnifiedPushService that is created during the first
+         * test. All following test will fail because the wrong binder is used by PushService.
+         *
+         * This method resets the binder using reflection, because it's not accessible directly.
+         *
+         * See https://codeberg.org/UnifiedPush/android-connector/issues/8
+         */
+        @TestOnly
+        fun resetBinder() {
+            // requires kotlin-reflection
+            val pushServiceClass = PushService::class
+            val companionClass = pushServiceClass.nestedClasses.first { it.isCompanion }
+
+            val binderProperty = companionClass.members
+                .filterIsInstance(KMutableProperty::class.java)
+                .first { it.name.contains("binder") }
+            binderProperty.isAccessible = true
+            val binderSetter = binderProperty.setter
+
+            binderSetter.call(companionClass, null)
+        }
+
+    }
+
 }

gradle/libs.versions.toml

@@ -93,6 +93,7 @@ hilt-android-testing = { module = "com.google.dagger:hilt-android-testing", vers
 junit = { module = "junit:junit", version = "4.13.2" }
 kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
 kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
 mikepenz-aboutLibraries = { module = "com.mikepenz:aboutlibraries-compose-m3", version.ref = "mikepenz-aboutLibraries" }
 mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
 mockk-android = { module = "io.mockk:mockk-android", version.ref = "mockk" }