Feature/authentication screens

.github/workflows/ci.yml

@@ -111,4 +111,4 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-        run: ./gradlew sonar --parallel --build-cache
+        run: ./gradlew sonar --info

app/build.gradle.kts

@@ -53,11 +53,22 @@ android {
     packaging {
         resources {
             excludes += "/META-INF/{AL2.0,LGPL2.1}"
+            merges += "META-INF/LICENSE.md"
+            merges += "META-INF/LICENSE-notice.md"
         }
     }
     testCoverage {
         jacocoVersion = "0.8.8"
     }
+
+    // Necessary to make mockk work on integration tests
+    testOptions {
+        packaging {
+            jniLibs {
+                useLegacyPackaging = true
+            }
+        }
+    }
 }
 
 dependencies {
@@ -86,6 +97,7 @@ dependencies {
     androidTestImplementation(libs.androidx.espresso.core)
     androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.ui.test.junit4)
+    androidTestImplementation(libs.mockk.android)
 
     debugImplementation(libs.androidx.ui.tooling)
     debugImplementation(libs.androidx.ui.test.manifest)

app/src/androidTest/java/com/github/swent/echo/compose/authentication/AuthenticationFormTest.kt

@@ -0,0 +1,74 @@
+package com.github.swent.echo.compose.authentication
+
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class AuthenticationFormTest {
+
+    companion object {
+        const val ACTION = "Action Button"
+        const val EMAIL = "test@test.com"
+        const val PASSWORD = "password"
+    }
+
+    @get:Rule val composeTestRule = createComposeRule()
+
+    private var authenticationCount = 0
+    private var email = ""
+    private var password = ""
+
+    private fun onAuthenticate(email: String, password: String) {
+        this.email = email
+        this.password = password
+        authenticationCount++
+    }
+
+    @Before
+    fun setUp() {
+        authenticationCount = 0
+        email = ""
+        password = ""
+    }
+
+    @Test
+    fun shouldNotDisplayErrorWhenErrorIsNull() {
+        composeTestRule.setContent { AuthenticationForm(ACTION, this::onAuthenticate, null) }
+        composeTestRule.onNodeWithTag("error-message").assertDoesNotExist()
+    }
+
+    @Test
+    fun shouldDisplayErrorMessageWhenErrorIsNotNull() {
+        val error = "An error occurred"
+        composeTestRule.setContent { AuthenticationForm(ACTION, this::onAuthenticate, error) }
+        composeTestRule.onNodeWithTag("error-message").assertExists()
+    }
+
+    @Test
+    fun shouldDisplayLabelsAndActionButton() {
+        composeTestRule.setContent { AuthenticationForm(ACTION, this::onAuthenticate) }
+        composeTestRule.onNodeWithTag("action-button").assertExists()
+        composeTestRule.onNodeWithText(ACTION).assertExists()
+        composeTestRule.onNodeWithText("Email").assertExists()
+        composeTestRule.onNodeWithText("Password").assertExists()
+    }
+
+    @Test
+    fun shouldCallOnAuthenticateWithCorrectParametersWhenActionButtonIsPressed() {
+        composeTestRule.setContent { AuthenticationForm(ACTION, this::onAuthenticate) }
+
+        composeTestRule.onNodeWithTag("email-field").performTextInput(EMAIL)
+        composeTestRule.onNodeWithTag("password-field").performTextInput(PASSWORD)
+        assertEquals(0, authenticationCount)
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        assertEquals(1, authenticationCount)
+        assertEquals(EMAIL, email)
+        assertEquals(PASSWORD, password)
+    }
+}

app/src/androidTest/java/com/github/swent/echo/compose/authentication/AuthenticationScreenTest.kt

@@ -0,0 +1,116 @@
+package com.github.swent.echo.compose.authentication
+
+import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import com.github.swent.echo.viewmodels.authentication.AuthenticationState
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class AuthenticationScreenTest {
+
+    companion object {
+        const val ACTION = "Action Button"
+    }
+
+    @get:Rule val composeTestRule = createComposeRule()
+
+    private var authenticationCount = 0
+    private var email = ""
+    private var password = ""
+
+    private fun onAuthenticate(email: String, password: String) {
+        this.email = email
+        this.password = password
+        authenticationCount++
+    }
+
+    @Before
+    fun setUp() {
+        authenticationCount = 0
+        email = ""
+        password = ""
+    }
+
+    @Test
+    fun shouldHaveLoginButtonAndInputFieldsWhenIsSignedOut() {
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.SignedOut, this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithText(ACTION).assertExists().assertHasClickAction()
+        composeTestRule.onNodeWithTag("email-field").assertExists()
+        composeTestRule.onNodeWithTag("password-field").assertExists()
+        composeTestRule.onNodeWithTag("error-message").assertDoesNotExist()
+    }
+
+    @Test
+    fun shouldCallOnAuthenticateWithCorrectParametersWhenActionButtonIsPressedInSignedOutState() {
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.SignedOut, this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithTag("email-field").performTextInput("test@test.test")
+        composeTestRule.onNodeWithTag("password-field").performTextInput("password")
+        assertEquals(0, authenticationCount)
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        assertEquals(1, authenticationCount)
+        assertEquals("test@test.test", email)
+        assertEquals("password", password)
+    }
+
+    @Test
+    fun shouldHaveSigningInTextWhenIsSigningIn() {
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.SigningIn, this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithText("Signing in...").assertExists()
+        assertEquals(0, authenticationCount)
+    }
+
+    @Test
+    fun shouldHaveSignedInTextWhenIsSignedIn() {
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.SignedIn, this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithText("Signed in").assertExists()
+        assertEquals(0, authenticationCount)
+    }
+
+    @Test
+    fun shouldHaveErrorTextWhenIsError() {
+        val message = "Error message"
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.Error(message), this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithText(message).assertExists()
+    }
+
+    @Test
+    fun shouldHaveLoginButtonAndInputFieldsWhenIsError() {
+        val message = "Error message"
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.Error(message), this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithText(ACTION).assertExists().assertHasClickAction()
+        composeTestRule.onNodeWithTag("email-field").assertExists()
+        composeTestRule.onNodeWithTag("password-field").assertExists()
+        composeTestRule.onNodeWithTag("error-message").assertExists()
+    }
+
+    @Test
+    fun shouldCallOnAuthenticateWithCorrectParametersWhenActionButtonIsPressedInErrorState() {
+        composeTestRule.setContent {
+            AuthenticationScreen(ACTION, AuthenticationState.Error("Error"), this::onAuthenticate)
+        }
+        composeTestRule.onNodeWithTag("email-field").performTextInput("test@test.test")
+        composeTestRule.onNodeWithTag("password-field").performTextInput("password")
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        assertEquals(1, authenticationCount)
+        assertEquals("test@test.test", email)
+        assertEquals("password", password)
+    }
+}

app/src/androidTest/java/com/github/swent/echo/compose/authentication/LoginScreenTest.kt

@@ -0,0 +1,58 @@
+package com.github.swent.echo.compose.authentication
+
+import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import com.github.swent.echo.viewmodels.authentication.AuthenticationState
+import com.github.swent.echo.viewmodels.authentication.LoginViewModel
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class LoginScreenTest {
+
+    @get:Rule val composeTestRule = createComposeRule()
+
+    private lateinit var loginViewModel: LoginViewModel
+    private lateinit var state: MutableStateFlow<AuthenticationState>
+
+    @Before
+    fun setUp() {
+        loginViewModel = mockk(relaxed = true)
+        state = MutableStateFlow(AuthenticationState.SignedOut)
+        every { loginViewModel.state } answers { state.asStateFlow() }
+        composeTestRule.setContent { LoginScreen(loginViewModel) }
+    }
+
+    @Test
+    fun shouldHaveLoginButtonAndInputFieldsWhenIsSignedOut() {
+        state.value = AuthenticationState.SignedOut
+        composeTestRule.onNodeWithText("Login").assertExists().assertHasClickAction()
+    }
+
+    @Test
+    fun shouldCallLoginOnViewModelWithEmailPasswordWhenLoginButtonIsClickedInSignedOutState() {
+        state.value = AuthenticationState.SignedOut
+        composeTestRule.onNodeWithTag("email-field").performTextInput("test@test.test")
+        composeTestRule.onNodeWithTag("password-field").performTextInput("password")
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        verify { loginViewModel.login("test@test.test", "password") }
+    }
+
+    @Test
+    fun shouldCallLoginOnViewModelWithEmailPasswordWhenLoginButtonIsClickedInErrorState() {
+        state.value = AuthenticationState.Error("Error message")
+        composeTestRule.onNodeWithTag("email-field").performTextInput("test@test.test")
+        composeTestRule.onNodeWithTag("password-field").performTextInput("password")
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        verify { loginViewModel.login("test@test.test", "password") }
+    }
+}

app/src/androidTest/java/com/github/swent/echo/compose/authentication/RegisterScreenTest.kt

@@ -0,0 +1,58 @@
+package com.github.swent.echo.compose.authentication
+
+import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTextInput
+import com.github.swent.echo.viewmodels.authentication.AuthenticationState
+import com.github.swent.echo.viewmodels.authentication.RegisterViewModel
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.verify
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class RegisterScreenTest {
+
+    @get:Rule val composeTestRule = createComposeRule()
+
+    private lateinit var registerViewModel: RegisterViewModel
+    private lateinit var state: MutableStateFlow<AuthenticationState>
+
+    @Before
+    fun setUp() {
+        registerViewModel = mockk(relaxed = true)
+        state = MutableStateFlow(AuthenticationState.SignedOut)
+        every { registerViewModel.state } answers { state.asStateFlow() }
+        composeTestRule.setContent { RegisterScreen(registerViewModel) }
+    }
+
+    @Test
+    fun shouldHaveRegisterButtonAndInputFieldsWhenIsSignedOut() {
+        state.value = AuthenticationState.SignedOut
+        composeTestRule.onNodeWithText("Register").assertExists().assertHasClickAction()
+    }
+
+    @Test
+    fun shouldCallRegisterOnViewModelWithEmailPasswordWhenRegisterButtonIsClickedInSignedOutState() {
+        state.value = AuthenticationState.SignedOut
+        composeTestRule.onNodeWithTag("email-field").performTextInput("test@test.test")
+        composeTestRule.onNodeWithTag("password-field").performTextInput("password")
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        verify { registerViewModel.register("test@test.test", "password") }
+    }
+
+    @Test
+    fun shouldCallRegisterOnViewModelWithEmailPasswordWhenRegisterButtonIsClickedInErrorState() {
+        state.value = AuthenticationState.Error("Error message")
+        composeTestRule.onNodeWithTag("email-field").performTextInput("test@test.test")
+        composeTestRule.onNodeWithTag("password-field").performTextInput("password")
+        composeTestRule.onNodeWithTag("action-button").performClick()
+        verify { registerViewModel.register("test@test.test", "password") }
+    }
+}

app/src/main/java/com/github/swent/echo/authentication/AuthenticationService.kt

@@ -26,5 +26,5 @@ interface AuthenticationService {
      *
      * @return The current user's ID, or null if the user is not signed in.
      */
-    fun getCurrentUserID(): String?
+    suspend fun getCurrentUserID(): String?
 }

app/src/main/java/com/github/swent/echo/authentication/AuthenticationServiceImpl.kt

@@ -46,7 +46,7 @@ class AuthenticationServiceImpl(private val auth: Auth) : AuthenticationService
         return AuthenticationResult.Success
     }
 
-    override fun getCurrentUserID(): String? {
+    override suspend fun getCurrentUserID(): String? {
         return auth.currentSessionOrNull()?.user?.id
     }
 }