Initialize databases before broadcasting user

Author: jeffdgr8

src/app/src/androidTest/java/com/couchbase/learningpath/DatabaseIntegrationTests.kt

@@ -14,6 +14,7 @@ import com.couchbase.learningpath.models.*
 import com.couchbase.learningpath.services.MockAuthenticationService
 import com.couchbase.lite.CouchbaseLiteException
 import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.test.runTest
 import org.junit.*
 import org.junit.Assert.*
@@ -80,8 +81,10 @@ class DatabaseIntegrationTests {
             databaseManager.deleteDatabases()
             databaseManager.initializeDatabases(user1)
 
-            authenticationService = MockAuthenticationService()
-            val isAuth = authenticationService.authenticatedUser(user1.username, user1.password)
+            authenticationService = MockAuthenticationService(databaseManager)
+            val isAuth = runBlocking {
+                authenticationService.authenticatedUser(user1.username, user1.password)
+            }
 
             //arrange repositories
             auditRepository = AuditRepositoryDb(authenticationService, databaseManager)

src/app/src/main/java/com/couchbase/learningpath/services/AuthenticationService.kt

@@ -6,6 +6,6 @@ import com.couchbase.learningpath.models.User
 interface AuthenticationService {
     val currentUser: LiveData<User?>
     fun getCurrentUser() : User
-    fun authenticatedUser(username: String, password: String) : Boolean
+    suspend fun authenticatedUser(username: String, password: String) : Boolean
     fun logout()
 }

src/app/src/main/java/com/couchbase/learningpath/services/MockAuthenticationService.kt

@@ -2,9 +2,14 @@ package com.couchbase.learningpath.services
 
 import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
+import com.couchbase.learningpath.data.DatabaseManager
 import com.couchbase.learningpath.models.User
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 
-class MockAuthenticationService : AuthenticationService {
+class MockAuthenticationService(
+    private val databaseManager: DatabaseManager
+) : AuthenticationService {
 
     private var _user = MutableLiveData<User?>()
     private var _mockUsers = HashMap<String, User>()
@@ -15,11 +20,17 @@ class MockAuthenticationService : AuthenticationService {
         return _user.value ?: User("", "", "")
     }
 
-    override fun authenticatedUser(username: String, password: String): Boolean {
+    override suspend fun authenticatedUser(username: String, password: String): Boolean {
         return if (_mockUsers.containsKey(username)){
             val user = _mockUsers[username]
             if (user?.password == password){
-                _user.value = user
+                withContext(Dispatchers.IO) {
+                    //initialize database if needed
+                    databaseManager.initializeDatabases(user)
+                    withContext(Dispatchers.Main) {
+                        _user.value = user
+                    }
+                }
                 true
             } else {
                 false

src/app/src/main/java/com/couchbase/learningpath/ui/login/LoginView.kt

@@ -8,6 +8,7 @@ import androidx.compose.foundation.text.KeyboardOptions
 import androidx.compose.material.*
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.livedata.observeAsState
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
@@ -28,6 +29,7 @@ import com.google.accompanist.drawablepainter.rememberDrawablePainter
 import com.couchbase.learningpath.R
 import com.couchbase.learningpath.ui.theme.LearningPathTheme
 import com.couchbase.learningpath.ui.theme.Red500
+import kotlinx.coroutines.launch
 
 @Composable
 fun LoginView(onSuccessLogin: () -> Unit,
@@ -36,12 +38,16 @@ fun LoginView(onSuccessLogin: () -> Unit,
     val password = viewModel.password.observeAsState("")
     val isError = viewModel.isError.observeAsState(false)
 
+    val composableScope = rememberCoroutineScope()
+
     //****
     //checks authentication if works, route to UserProfile
     //****
     val onLoginCheck: () -> Unit = {
-        if (viewModel.login()) {
-            onSuccessLogin()
+        composableScope.launch {
+            if (viewModel.login()) {
+                onSuccessLogin()
+            }
         }
     }
 

src/app/src/main/java/com/couchbase/learningpath/ui/login/LoginViewModel.kt

@@ -34,17 +34,12 @@ class LoginViewModel(
     private val _isError = MutableLiveData(false)
     val isError: LiveData<Boolean> = _isError
 
-    fun login(): Boolean {
+    suspend fun login(): Boolean {
         _username.value?.let { uname ->
             _password.value?.let { pwd ->
                 if (authenticationService.authenticatedUser(username = uname, password = pwd)) {
                     _isError.value = false
-                    val currentUser = authenticationService.getCurrentUser()
-                    viewModelScope.launch(Dispatchers.IO) {
-                        //initialize database if needed
-                        databaseManager.initializeDatabases(currentUser)
-                        replicatorService.updateAuthentication(isReset = false)
-                    }
+                    replicatorService.updateAuthentication(isReset = false)
                     return true
                 }
             }