test(users): add coverage for UserManager's coroutine-native methods

scheduleDuplicateAccountsForDeletionSuspend() was the only method with
tests; currentUser, deleteUserSuspend, scheduleUserForDeletionWithIdSuspend,
setUserAsActiveSuspend, storeProfileSuspend and other suspend methods
introduced by the coroutines migration had none.

Assisted-by: Claude Code:claude-sonnet-5

Signed-off-by: Marcel Hibbe <dev@mhibbe.de>

Author: mahibi

app/src/test/java/com/nextcloud/talk/users/UserManagerTest.kt

@@ -8,14 +8,22 @@ package com.nextcloud.talk.users
 
 import com.nextcloud.talk.data.user.UsersRepository
 import com.nextcloud.talk.data.user.model.User
+import com.nextcloud.talk.models.ExternalSignalingServer
+import kotlinx.coroutines.flow.emptyFlow
 import kotlinx.coroutines.test.runTest
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
 import org.junit.Before
 import org.junit.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.check
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyBlocking
 import org.mockito.kotlin.wheneverBlocking
 
 @Suppress("DEPRECATION")
@@ -33,6 +41,9 @@ class UserManagerTest {
         // scheduleDuplicateAccountsForDeletion() falls back to the `current` flag / oldest row,
         // matching the behavior asserted by the tests below that don't care about this priority.
         wheneverBlocking { usersRepository.getActiveUser() }.thenReturn(null)
+        // activeUserSubject/activeUserStateFlow lazily collect this on init; an empty flow lets
+        // that background collection finish without racing the synchronous updates asserted below.
+        wheneverBlocking { usersRepository.getActiveUserFlow() }.thenReturn(emptyFlow())
     }
 
     @Test
@@ -185,4 +196,277 @@ class UserManagerTest {
         assertEquals(1, scheduledCount)
         assertTrue(duplicate.scheduledForDeletion)
     }
+
+    @Test
+    fun `currentUser returns the active user without touching any fallback`() {
+        val active = user(id = 1, username = "userA", baseUrl = "https://example.com", current = true)
+        wheneverBlocking { usersRepository.getActiveUser() }.thenReturn(active)
+
+        val result = userManager.currentUser.blockingGet()
+
+        assertEquals(active, result)
+        verifyBlocking(usersRepository, never()) { getUsersNotScheduledForDeletion() }
+    }
+
+    @Test
+    fun `currentUser falls back to any non-deleted user and sets it active when none is active`() {
+        val fallback = user(id = 1, username = "userA", baseUrl = "https://example.com")
+        wheneverBlocking { usersRepository.getUsersNotScheduledForDeletion() }.thenReturn(listOf(fallback))
+        wheneverBlocking { usersRepository.setUserAsActiveWithId(fallback.id!!) }.thenReturn(true)
+        // getActiveUser() is re-queried after setUserAsActiveWithId() succeeds, simulating the DB
+        // now reporting the freshly-activated row.
+        wheneverBlocking { usersRepository.getActiveUser() }.thenReturn(null, fallback)
+
+        val result = userManager.currentUser.blockingGet()
+
+        assertEquals(fallback, result)
+        verifyBlocking(usersRepository) { setUserAsActiveWithId(fallback.id!!) }
+    }
+
+    @Test
+    fun `currentUser is empty when there is no active user and none to fall back to`() {
+        wheneverBlocking { usersRepository.getUsersNotScheduledForDeletion() }.thenReturn(emptyList())
+
+        assertTrue(userManager.currentUser.isEmpty.blockingGet())
+    }
+
+    @Test
+    fun `deleteUserSuspend does nothing and returns 0 when the user does not exist`() =
+        runTest {
+            wheneverBlocking { usersRepository.getUserWithId(42L) }.thenReturn(null)
+
+            val result = userManager.deleteUserSuspend(42L)
+
+            assertEquals(0, result)
+            verify(usersRepository, never()).deleteUser(any())
+        }
+
+    @Test
+    fun `deleteUserSuspend deletes the user when it exists`() =
+        runTest {
+            val existing = user(id = 42, username = "userA", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.getUserWithId(42L) }.thenReturn(existing)
+            wheneverBlocking { usersRepository.deleteUser(existing) }.thenReturn(1)
+
+            val result = userManager.deleteUserSuspend(42L)
+
+            assertEquals(1, result)
+            verify(usersRepository).deleteUser(existing)
+        }
+
+    @Test
+    fun `checkIfUserIsScheduledForDeletionSuspend reflects the matching user's flag`() =
+        runTest {
+            val scheduled = user(id = 1, username = "userA", baseUrl = "https://example.com")
+                .apply { scheduledForDeletion = true }
+            wheneverBlocking {
+                usersRepository.getUserWithUsernameAndServer("userA", "https://example.com")
+            }.thenReturn(scheduled)
+
+            assertTrue(userManager.checkIfUserIsScheduledForDeletionSuspend("userA", "https://example.com"))
+        }
+
+    @Test
+    fun `checkIfUserIsScheduledForDeletionSuspend is false when the user does not exist`() =
+        runTest {
+            wheneverBlocking {
+                usersRepository.getUserWithUsernameAndServer("userA", "https://example.com")
+            }.thenReturn(null)
+
+            assertFalse(userManager.checkIfUserIsScheduledForDeletionSuspend("userA", "https://example.com"))
+        }
+
+    @Test
+    fun `checkIfUserExistsSuspend is true only when a matching user is found`() =
+        runTest {
+            wheneverBlocking {
+                usersRepository.getUserWithUsernameAndServer("userA", "https://example.com")
+            }.thenReturn(user(id = 1, username = "userA", baseUrl = "https://example.com"))
+            wheneverBlocking {
+                usersRepository.getUserWithUsernameAndServer("userB", "https://example.com")
+            }.thenReturn(null)
+
+            assertTrue(userManager.checkIfUserExistsSuspend("userA", "https://example.com"))
+            assertFalse(userManager.checkIfUserExistsSuspend("userB", "https://example.com"))
+        }
+
+    @Test
+    fun `scheduleUserForDeletionWithIdSuspend returns false when the user does not exist`() =
+        runTest {
+            wheneverBlocking { usersRepository.getUserWithId(99L) }.thenReturn(null)
+
+            assertFalse(userManager.scheduleUserForDeletionWithIdSuspend(99L))
+            verify(usersRepository, never()).updateUser(any())
+        }
+
+    @Test
+    fun `scheduleUserForDeletionWithIdSuspend marks the user deleted and returns false with nobody left to activate`() =
+        runTest {
+            val target = user(id = 1, username = "userA", baseUrl = "https://example.com", current = true)
+            wheneverBlocking { usersRepository.getUserWithId(1L) }.thenReturn(target)
+            wheneverBlocking { usersRepository.getUsersNotScheduledForDeletion() }.thenReturn(emptyList())
+
+            val result = userManager.scheduleUserForDeletionWithIdSuspend(1L)
+
+            assertFalse(result)
+            assertTrue(target.scheduledForDeletion)
+            assertFalse(target.current)
+            verify(usersRepository).updateUser(target)
+        }
+
+    @Test
+    fun `scheduleUserForDeletionWithIdSuspend returns true and activates another user when one remains`() =
+        runTest {
+            val target = user(id = 1, username = "userA", baseUrl = "https://example.com", current = true)
+            val other = user(id = 2, username = "userB", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.getUserWithId(1L) }.thenReturn(target)
+            wheneverBlocking { usersRepository.getUsersNotScheduledForDeletion() }.thenReturn(listOf(other))
+            wheneverBlocking { usersRepository.setUserAsActiveWithId(other.id!!) }.thenReturn(true)
+            wheneverBlocking { usersRepository.getActiveUser() }.thenReturn(other)
+
+            val result = userManager.scheduleUserForDeletionWithIdSuspend(1L)
+
+            assertTrue(result)
+            assertTrue(target.scheduledForDeletion)
+            verify(usersRepository).setUserAsActiveWithId(other.id!!)
+        }
+
+    @Test
+    fun `updateExternalSignalingServerSuspend throws when the user does not exist`() =
+        runTest {
+            wheneverBlocking { usersRepository.getUserWithId(7L) }.thenReturn(null)
+
+            try {
+                userManager.updateExternalSignalingServerSuspend(7L, ExternalSignalingServer())
+                fail("Expected NoSuchElementException")
+            } catch (expected: NoSuchElementException) {
+                // expected
+            }
+        }
+
+    @Test
+    fun `updateExternalSignalingServerSuspend updates the matching user`() =
+        runTest {
+            val existing = user(id = 7, username = "userA", baseUrl = "https://example.com")
+            val server = ExternalSignalingServer(externalSignalingServer = "https://signaling.example.com")
+            wheneverBlocking { usersRepository.getUserWithId(7L) }.thenReturn(existing)
+            wheneverBlocking { usersRepository.updateUser(existing) }.thenReturn(1)
+
+            val result = userManager.updateExternalSignalingServerSuspend(7L, server)
+
+            assertEquals(1, result)
+            assertEquals(server, existing.externalSignalingServer)
+        }
+
+    @Test
+    fun `updateOrCreateUserSuspend inserts a user without an id`() =
+        runTest {
+            val newUser = User(id = null, username = "userA", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.insertUser(newUser) }.thenReturn(5L)
+
+            val result = userManager.updateOrCreateUserSuspend(newUser)
+
+            assertEquals(5, result)
+            verify(usersRepository, never()).updateUser(any())
+        }
+
+    @Test
+    fun `updateOrCreateUserSuspend updates a user that already has an id`() =
+        runTest {
+            val existing = user(id = 3, username = "userA", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.updateUser(existing) }.thenReturn(1)
+
+            val result = userManager.updateOrCreateUserSuspend(existing)
+
+            assertEquals(1, result)
+            verify(usersRepository, never()).insertUser(any())
+        }
+
+    @Test
+    fun `setUserAsActiveSuspend publishes the new user on currentUserFlow only when it succeeds`() =
+        runTest {
+            val target = user(id = 1, username = "userA", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.setUserAsActiveWithId(1L) }.thenReturn(true)
+
+            val result = userManager.setUserAsActiveSuspend(target)
+
+            assertTrue(result)
+            assertEquals(target, userManager.currentUserFlow.value)
+        }
+
+    @Test
+    fun `setUserAsActiveSuspend leaves currentUserFlow untouched when it fails`() =
+        runTest {
+            val target = user(id = 1, username = "userA", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.setUserAsActiveWithId(1L) }.thenReturn(false)
+
+            val result = userManager.setUserAsActiveSuspend(target)
+
+            assertFalse(result)
+            assertNull(userManager.currentUserFlow.value)
+        }
+
+    @Test
+    fun `storeProfileSuspend creates a new user when the attributes carry no id`() =
+        runTest {
+            val attributes = UserManager.UserAttributes(
+                id = null,
+                serverUrl = "https://example.com",
+                currentUser = true,
+                userId = "userId",
+                token = "token",
+                displayName = "Display Name",
+                pushConfigurationState = null,
+                // createUser() guards these with TextUtils.isEmpty(), which this project's unit
+                // tests stub to always return false (testOptions.unitTests.isReturnDefaultValues),
+                // so a null value here would still hit LoganSquare.parse(null, ...) and NPE.
+                capabilities = "{}",
+                serverVersion = "{}",
+                certificateAlias = null,
+                externalSignalingServer = "{}"
+            )
+            val stored = user(id = 10, username = "userA", baseUrl = "https://example.com")
+            wheneverBlocking { usersRepository.insertUser(any()) }.thenReturn(10L)
+            wheneverBlocking { usersRepository.getUserWithId(10L) }.thenReturn(stored)
+
+            val result = userManager.storeProfileSuspend("userA", attributes)
+
+            assertEquals(stored, result)
+            verify(usersRepository).insertUser(
+                check {
+                    assertEquals("userA", it.username)
+                    assertEquals("https://example.com", it.baseUrl)
+                    assertEquals("token", it.token)
+                    assertEquals("Display Name", it.displayName)
+                }
+            )
+        }
+
+    @Test
+    fun `storeProfileSuspend updates the existing user resolved from the attributes' id`() =
+        runTest {
+            val existing = user(id = 10, username = "userA", baseUrl = "https://old.example.com")
+            val attributes = UserManager.UserAttributes(
+                id = 10,
+                serverUrl = "https://new.example.com",
+                currentUser = true,
+                userId = "userId",
+                token = "newToken",
+                displayName = "New Display Name",
+                pushConfigurationState = null,
+                capabilities = null,
+                serverVersion = null,
+                certificateAlias = null,
+                externalSignalingServer = null
+            )
+            wheneverBlocking { usersRepository.getUserWithId(10L) }.thenReturn(existing)
+            wheneverBlocking { usersRepository.insertUser(existing) }.thenReturn(10L)
+
+            val result = userManager.storeProfileSuspend("userA", attributes)
+
+            assertEquals("https://new.example.com", existing.baseUrl)
+            assertEquals("newToken", existing.token)
+            assertEquals("New Display Name", existing.displayName)
+            assertEquals(existing, result)
+        }
 }