test: E2E

app/build.gradle.kts

@@ -8,6 +8,8 @@ plugins {
     alias(libs.plugins.sonar)
     id("jacoco")
     alias(libs.plugins.gms)
+    id("kotlin-kapt")
+    id("com.google.dagger.hilt.android")
 }
 
 android {
@@ -38,7 +40,7 @@ android {
         versionCode = 1
         versionName = "1.0"
 
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunner = "com.github.se.travelpouch.HiltTestRunner"
         vectorDrawables {
             useSupportLibrary = true
         }
@@ -99,12 +101,12 @@ android {
     }
 
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_11
-        targetCompatibility = JavaVersion.VERSION_11
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
     }
 
     kotlinOptions {
-        jvmTarget = "11"
+        jvmTarget = "17"
     }
 
     packaging {
@@ -186,14 +188,16 @@ dependencies {
     globalTestImplementation(libs.androidx.junit)
     globalTestImplementation(libs.androidx.espresso.core)
 
-    //todo: wait for a listener to finish libraries
-    implementation(libs.guava)
+    //Hilt
+    implementation(libs.hilt.android)
+    kapt(libs.hilt.android.compiler)
+    kapt(libs.androidx.hilt.compiler)
+    implementation(libs.androidx.hilt.navigation.compose)
 
-    // To use CallbackToFutureAdapter
-    implementation(libs.androidx.concurrent.futures)
-
-    // Kotlin
-    implementation(libs.kotlinx.coroutines.guava)
+    testImplementation(libs.hilt.android.testing)
+    kaptTest(libs.hilt.android.compiler)
+    androidTestImplementation(libs.hilt.android.testing)
+    kaptAndroidTest(libs.hilt.android.compiler)
 
 
     // Google Service and Maps
@@ -276,6 +280,11 @@ dependencies {
     androidTestImplementation(libs.mockito.kotlin)
 }
 
+// Allow references to generated code
+kapt {
+    correctErrorTypes = true
+}
+
 tasks.withType<Test> {
     // Configure Jacoco for each tests
     configure<JacocoTaskExtension> {

app/src/androidTest/java/com/github/se/travelpouch/HiltTestRunner.kt

@@ -0,0 +1,16 @@
+package com.github.se.travelpouch
+
+import android.app.Application
+import android.content.Context
+import androidx.test.runner.AndroidJUnitRunner
+import dagger.hilt.android.testing.HiltTestApplication
+
+class HiltTestRunner : AndroidJUnitRunner() {
+  override fun newApplication(
+      cl: ClassLoader?,
+      className: String?,
+      context: Context?
+  ): Application {
+    return super.newApplication(cl, HiltTestApplication::class.java.name, context)
+  }
+}

app/src/androidTest/java/com/github/se/travelpouch/di/TestModule.kt

@@ -0,0 +1,36 @@
+package com.github.se.travelpouch.di
+
+import com.github.se.travelpouch.model.authentication.AuthenticationService
+import com.github.se.travelpouch.model.authentication.MockFirebaseAuthenticationService
+import com.github.se.travelpouch.model.profile.ProfileRepository
+import com.github.se.travelpouch.model.profile.ProfileRepositoryMock
+import com.github.se.travelpouch.model.travels.TravelRepository
+import com.github.se.travelpouch.model.travels.TravelRepositoryMock
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+import javax.inject.Singleton
+
+@InstallIn(SingletonComponent::class)
+@Module
+object TestModule {
+
+  @Provides
+  @Singleton
+  fun provideFirebaseAuth(): AuthenticationService {
+    return MockFirebaseAuthenticationService()
+  }
+
+  @Provides
+  @Singleton
+  fun providesProfileRepository(): ProfileRepository {
+    return ProfileRepositoryMock()
+  }
+
+  @Provides
+  @Singleton
+  fun providesTravelRepository(): TravelRepository {
+    return TravelRepositoryMock()
+  }
+}

app/src/androidTest/java/com/github/se/travelpouch/endtoend/EndToEndTest.kt

@@ -0,0 +1,123 @@
+package com.github.se.travelpouch.endtoend
+
+import androidx.compose.ui.test.assert
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertTextEquals
+import androidx.compose.ui.test.hasText
+import androidx.compose.ui.test.isDisplayed
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+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.se.travelpouch.MainActivity
+import com.github.se.travelpouch.di.AppModule
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import dagger.hilt.android.testing.UninstallModules
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+@HiltAndroidTest
+@UninstallModules(AppModule::class)
+class EndToEndTest {
+
+  @get:Rule(order = 0) val hiltRule = HiltAndroidRule(this)
+
+  @get:Rule(order = 1) val composeTestRule = createAndroidComposeRule<MainActivity>()
+
+  @Before
+  fun setUp() {
+    hiltRule.inject()
+  }
+
+  @Test
+  fun verifyUserFlowForTravelCreation() =
+      runTest(timeout = 40.seconds) {
+
+        // assert that login screen is displayed
+        composeTestRule.onNodeWithTag("appLogo").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("welcomText").assertIsDisplayed()
+        composeTestRule.onNodeWithText("Sign in with email and password").assertIsDisplayed()
+
+        // go to sign in screen with email and password and log in
+        composeTestRule.onNodeWithText("Sign in with email and password").performClick()
+
+        composeTestRule.onNodeWithTag("emailField").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("passwordField").assertIsDisplayed()
+        composeTestRule.onNodeWithText("Sign in").assertIsDisplayed()
+
+        composeTestRule.onNodeWithTag("emailField").performTextInput("[email protected]")
+        composeTestRule.onNodeWithTag("passwordField").performTextInput("travelpouchtest1password")
+        composeTestRule.onNodeWithText("Sign in").performClick()
+
+        // wait until we are in the travel list screen
+        composeTestRule.waitUntil {
+          composeTestRule.onNodeWithTag("emptyTravelPrompt", useUnmergedTree = true).isDisplayed()
+        }
+
+        // test that no travels are displayed because we have a new account
+        composeTestRule
+            .onNodeWithTag("emptyTravelPrompt", useUnmergedTree = true)
+            .assertIsDisplayed()
+        composeTestRule.onNodeWithTag("createTravelFab").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("createTravelFab").performClick()
+
+        // wait until we are in the screen to add a travel
+        composeTestRule.waitUntil {
+          composeTestRule.onNodeWithTag("travelTitle", useUnmergedTree = true).isDisplayed()
+        }
+
+        // test that everything is displayed
+        composeTestRule.onNodeWithTag("travelTitle").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("travelTitle").assertTextEquals("Create a new travel")
+        composeTestRule.onNodeWithTag("inputTravelTitle").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("inputTravelDescription").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("inputTravelLocation").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("inputTravelStartDate").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("inputTravelEndDate").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("travelSaveButton").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("travelSaveButton").assertTextEquals("Save")
+
+        // input fields to create a travel
+        composeTestRule.onNodeWithTag("inputTravelTitle").performTextInput("e2e travel 1")
+        composeTestRule
+            .onNodeWithTag("inputTravelDescription")
+            .performTextInput("test travel description")
+        composeTestRule.onNodeWithTag("inputTravelLocation").performTextInput("L")
+
+        // wait to have La paz displayed
+        composeTestRule.waitUntil {
+          composeTestRule.onNodeWithText("La Paz, Bolivia").isDisplayed()
+        }
+
+        composeTestRule.onNodeWithText("La Paz, Bolivia").performClick()
+        composeTestRule.onNodeWithTag("inputTravelStartDate").performTextInput("10/11/2024")
+        composeTestRule.onNodeWithTag("inputTravelEndDate").performTextInput("20/11/2024")
+
+        // save the travel and go back to the list of travels
+        composeTestRule.onNodeWithTag("travelSaveButton").performClick()
+
+        // verify that the previous buttons are still here
+        composeTestRule
+            .onNodeWithTag("TravelListScreen", useUnmergedTree = true)
+            .assertIsDisplayed()
+        composeTestRule.onNodeWithTag("createTravelFab").assertIsDisplayed()
+
+        // verify that the empty travel prompt does not exist since we saved a travel
+        composeTestRule
+            .onNodeWithTag("emptyTravelPrompt", useUnmergedTree = true)
+            .assertDoesNotExist()
+
+        composeTestRule.onNodeWithText("e2e travel 1").assertIsDisplayed()
+        composeTestRule.onNodeWithText("e2e travel 1").assert(hasText("e2e travel 1"))
+        composeTestRule.onNodeWithText("e2e travel 1").assert(hasText("test travel description"))
+        composeTestRule.onNodeWithText("e2e travel 1").assert(hasText("La Paz, Bolivia"))
+        composeTestRule.onNodeWithText("e2e travel 1").assert(hasText("10/11/2024"))
+      }
+}

app/src/androidTest/java/com/github/se/travelpouch/ui/authentication/SignInViewTest.kt

@@ -7,6 +7,7 @@ import androidx.compose.ui.test.assertIsDisplayed
 import androidx.compose.ui.test.assertTextEquals
 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 com.github.se.travelpouch.model.profile.ProfileModelView
 import com.github.se.travelpouch.model.profile.ProfileRepository
@@ -66,4 +67,13 @@ class SignInViewTest {
     composeTestRule.waitForIdle()
     composeTestRule.onNodeWithTag("loadingSpinner").assertIsDisplayed()
   }
+
+  @Test
+  fun signInWithWmailAndPasswordIsDisplayed() {
+    composeTestRule.setContent {
+      SignInScreen(navigationActions = mockNavigationActions, profileModelView, travelViewModel)
+    }
+
+    composeTestRule.onNodeWithText("Sign in with email and password").assertIsDisplayed()
+  }
 }

app/src/androidTest/java/com/github/se/travelpouch/ui/authentication/TestSignInEmailPasswordUI.kt

@@ -0,0 +1,110 @@
+package com.github.se.travelpouch.ui.authentication
+
+import androidx.compose.ui.test.assertIsDisplayed
+import androidx.compose.ui.test.assertTextEquals
+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.se.travelpouch.model.authentication.AuthenticationService
+import com.github.se.travelpouch.model.authentication.MockFirebaseAuthenticationService
+import com.github.se.travelpouch.model.profile.ProfileModelView
+import com.github.se.travelpouch.model.profile.ProfileRepository
+import com.github.se.travelpouch.model.travels.ListTravelViewModel
+import com.github.se.travelpouch.model.travels.TravelRepository
+import com.github.se.travelpouch.ui.navigation.NavigationActions
+import kotlin.time.Duration.Companion.seconds
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+import org.mockito.Mockito.mock
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.verify
+
+class TestSignInEmailPasswordUI {
+  val mockNavigationActions = mock(NavigationActions::class.java)
+  val travelRepository = mock(TravelRepository::class.java)
+  val profileRepository = mock(ProfileRepository::class.java)
+
+  val travelViewModel = ListTravelViewModel(travelRepository)
+  val profileModelView = ProfileModelView(profileRepository)
+
+  val authenticationService: AuthenticationService = mock()
+  val authenticationServiceMock = MockFirebaseAuthenticationService()
+
+  @get:Rule val composeTestRule = createComposeRule()
+
+  @Test
+  fun verifiesTopBarAppDisplayed() {
+    composeTestRule.setContent {
+      SignInWithPassword(
+          mockNavigationActions, profileModelView, travelViewModel, authenticationService)
+    }
+
+    composeTestRule.onNodeWithTag("PasswordTitle").assertIsDisplayed()
+    composeTestRule.onNodeWithTag("PasswordTitle").assertTextEquals("Signing in with password")
+
+    composeTestRule.onNodeWithTag("goBackButton").assertIsDisplayed()
+    composeTestRule.onNodeWithTag("goBackButton").performClick()
+    verify(mockNavigationActions).navigateTo(anyOrNull())
+  }
+
+  @Test
+  fun signingInWithPasswordCallsCreateUser() =
+      runTest(timeout = 20.seconds) {
+        composeTestRule.setContent {
+          SignInWithPassword(
+              mockNavigationActions, profileModelView, travelViewModel, authenticationService)
+        }
+
+        composeTestRule.onNodeWithTag("emailField").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("passwordField").assertIsDisplayed()
+        composeTestRule.onNodeWithText("Sign in").assertIsDisplayed()
+
+        composeTestRule.onNodeWithTag("emailField").performTextInput("[email protected]")
+        composeTestRule.onNodeWithTag("passwordField").performTextInput("travelpouchtest1password")
+        composeTestRule.onNodeWithText("Sign in").performClick()
+
+        verify(authenticationService).createUser(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())
+      }
+
+  @Test
+  fun logInWithPasswordCallsLogin() =
+      runTest(timeout = 20.seconds) {
+        composeTestRule.setContent {
+          SignInWithPassword(
+              mockNavigationActions, profileModelView, travelViewModel, authenticationService)
+        }
+
+        composeTestRule.onNodeWithTag("emailField").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("passwordField").assertIsDisplayed()
+        composeTestRule.onNodeWithText("Log in").assertIsDisplayed()
+
+        composeTestRule.onNodeWithTag("emailField").performTextInput("[email protected]")
+        composeTestRule.onNodeWithTag("passwordField").performTextInput("travelpouchtest1password")
+        composeTestRule.onNodeWithText("Log in").performClick()
+
+        verify(authenticationService).login(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())
+      }
+
+  @Test
+  fun logInWithPasswordCallsProfileVM() =
+      runTest(timeout = 20.seconds) {
+        composeTestRule.setContent {
+          SignInWithPassword(
+              mockNavigationActions, profileModelView, travelViewModel, authenticationServiceMock)
+        }
+
+        composeTestRule.onNodeWithTag("emailField").assertIsDisplayed()
+        composeTestRule.onNodeWithTag("passwordField").assertIsDisplayed()
+        composeTestRule.onNodeWithText("Log in").assertIsDisplayed()
+
+        composeTestRule.onNodeWithTag("emailField").performTextInput("[email protected]")
+        composeTestRule.onNodeWithTag("passwordField").performTextInput("travelpouchtest1password")
+        composeTestRule.onNodeWithText("Log in").performClick()
+
+        verify(profileRepository).initAfterLogin(anyOrNull())
+        verify(mockNavigationActions).navigateTo(anyOrNull())
+      }
+}

app/src/main/AndroidManifest.xml

@@ -3,6 +3,7 @@
     xmlns:tools="http://schemas.android.com/tools">
 
     <application
+        android:name=".TravelPouchApp"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
         android:fullBackupContent="@xml/backup_rules"