Feature/event listing - Implement Event List Overview with Mock Data, UI Enhancements, and Unit Tests

app/src/androidTest/java/com/android/unio/screen/EventListOverviewTest.kt

@@ -0,0 +1,133 @@
+package com.android.unio.ui.events
+
+import androidx.compose.ui.test.*
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.unit.ExperimentalUnitApi
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.unio.model.event.Event
+import com.android.unio.model.event.EventListViewModel
+import com.android.unio.model.event.EventRepositoryMock
+import com.android.unio.ui.event.EventListOverview
+import kotlinx.coroutines.test.runBlockingTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Test class for the EventListOverview Composable. This class contains unit tests to validate the
+ * behavior of the Event List UI.
+ */
+@ExperimentalUnitApi
+@RunWith(AndroidJUnit4::class)
+class EventListOverviewTest {
+
+  @get:Rule val composeTestRule = createComposeRule()
+
+  // Mock event repository to provide test data.
+  private val mockEventRepository = EventRepositoryMock()
+
+  /**
+   * Tests the functionality of switching between tabs and verifying animations. Ensures that the
+   * 'All' tab exists and can be clicked, and verifies the underlying bar's presence when switching
+   * tabs.
+   */
+  @Test
+  fun testTabSwitchingAndAnimation() {
+    composeTestRule.setContent {
+      val eventListViewModel = EventListViewModel(mockEventRepository)
+      EventListOverview(eventListViewModel = eventListViewModel, onAddEvent = {}, onEventClick = {})
+    }
+
+    // Assert that the 'All' tab exists and has a click action.
+    composeTestRule.onNodeWithTag("event_tabAll").assertExists()
+    composeTestRule.onNodeWithTag("event_tabAll").assertHasClickAction()
+
+    // Assert that the underlying bar exists.
+    composeTestRule.onNodeWithTag("event_UnderlyingBar").assertExists()
+
+    // Perform a click on the 'Following' tab.
+    composeTestRule.onNodeWithTag("event_tabFollowing").performClick()
+
+    // Assert that the 'Following' tab and the underlying bar still exist.
+    composeTestRule.onNodeWithTag("event_tabFollowing").assertExists()
+    composeTestRule.onNodeWithTag("event_UnderlyingBar").assertExists()
+  }
+
+  /**
+   * Tests the UI when the event list is empty. Asserts that the appropriate message is displayed
+   * when there are no events available.
+   */
+  @Test
+  fun testEmptyEventList() {
+    composeTestRule.setContent {
+      val emptyEventRepository =
+          object : EventRepositoryMock() {
+            override fun getEvents(
+                onSuccess: (List<Event>) -> Unit,
+                onFailure: (Exception) -> Unit
+            ) {
+              // Return an empty list for testing
+              onSuccess(emptyList())
+            }
+          }
+      val eventListViewModel = EventListViewModel(emptyEventRepository)
+      EventListOverview(eventListViewModel = eventListViewModel, onAddEvent = {}, onEventClick = {})
+    }
+
+    // Assert that the empty event prompt is displayed.
+    composeTestRule.onNodeWithTag("event_emptyEventPrompt").assertExists()
+    composeTestRule.onNodeWithText("No events available.").assertExists()
+  }
+
+  /**
+   * Tests the functionality of the Map button. Verifies that clicking the button triggers the
+   * expected action.
+   */
+  @Test
+  fun testMapButton() {
+    var mapClicked = false
+
+    composeTestRule.setContent {
+      val eventListViewModel = EventListViewModel(mockEventRepository)
+      EventListOverview(
+          eventListViewModel = eventListViewModel,
+          onAddEvent = { mapClicked = true },
+          onEventClick = {})
+    }
+
+    composeTestRule.onNodeWithTag("event_MapButton").performClick()
+
+    assert(mapClicked)
+  }
+
+  /**
+   * Tests the sequence of clicking on the 'Following' tab and then on the 'Add' button to ensure
+   * that both actions trigger their respective animations and behaviors.
+   */
+  @Test
+  fun testClickFollowingAndAdd() = runBlockingTest {
+    var addClicked = false
+
+    composeTestRule.setContent {
+      val eventListViewModel = EventListViewModel(mockEventRepository)
+      EventListOverview(
+          eventListViewModel = eventListViewModel,
+          onAddEvent = { addClicked = true },
+          onEventClick = {})
+    }
+
+    // Ensure the 'Following' tab exists and perform a click.
+    composeTestRule.onNodeWithTag("event_tabFollowing").assertExists()
+    composeTestRule.onNodeWithTag("event_tabFollowing").performClick()
+
+    // Perform a click on the 'Add' button.
+    composeTestRule.onNodeWithTag("event_MapButton").assertExists()
+    composeTestRule.onNodeWithTag("event_MapButton").performClick()
+
+    // Assert that the 'Add' button was clicked.
+    assert(addClicked)
+
+    // Optionally, verify that the animation related to the 'Add' button was triggered.
+    // This could involve checking the state changes or specific UI elements.
+  }
+}

app/src/main/java/com/android/unio/model/event/Event.kt

@@ -17,5 +17,5 @@ data class Event(
     val price: Double = 0.0,
     val date: Timestamp = Timestamp(Date()),
     val location: Location = Location(),
-    val types: List<String> = mutableListOf()
+    val types: List<EventType> = mutableListOf<EventType>()
 )

app/src/main/java/com/android/unio/model/event/EventListViewModel.kt

@@ -0,0 +1,75 @@
+package com.android.unio.model.event
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.ViewModelProvider
+import androidx.lifecycle.viewModelScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+
+/**
+ * ViewModel class that manages the event list data and provides it to the UI. It uses an
+ * [EventRepository] to load the list of events and exposes them through a [StateFlow] to be
+ * observed by the UI.
+ *
+ * @property repository The [EventRepository] that provides the events.
+ */
+class EventListViewModel(private val repository: EventRepository) : ViewModel() {
+
+  /**
+   * A private mutable state flow that holds the list of events. It is internal to the ViewModel and
+   * cannot be modified from the outside.
+   */
+  private val _events = MutableStateFlow<List<Event>>(emptyList())
+
+  /**
+   * A public immutable [StateFlow] that exposes the list of events to the UI. This flow can only be
+   * observed and not modified.
+   */
+  val events: StateFlow<List<Event>> = _events
+
+  /** Initializes the ViewModel by loading the events from the repository. */
+  init {
+    loadEvents()
+  }
+
+  /**
+   * Loads the list of events from the repository asynchronously using coroutines and updates the
+   * internal [MutableStateFlow].
+   */
+  private fun loadEvents() {
+    // Launch a coroutine in the ViewModel scope to load events asynchronously
+    viewModelScope.launch {
+      repository.getEvents(
+          onSuccess = { eventList ->
+            _events.value = eventList // Update the state flow with the loaded events
+          },
+          onFailure = { exception ->
+            // Handle error (e.g., log it, show a message to the user)
+            _events.value = emptyList() // Clear events on failure or handle accordingly
+          })
+    }
+  }
+
+  /**
+   * Companion object that provides a factory for creating instances of [EventListViewModel]. This
+   * factory is used to create the ViewModel with the [EventRepositoryMock] dependency.
+   */
+  companion object {
+    /** A factory for creating [EventListViewModel] instances with the [EventRepositoryMock]. */
+    val Factory: ViewModelProvider.Factory =
+        object : ViewModelProvider.Factory {
+          /**
+           * Creates an instance of the [EventListViewModel].
+           *
+           * @param modelClass The class of the ViewModel to create.
+           * @return The created ViewModel instance.
+           * @throws IllegalArgumentException if the [modelClass] does not match.
+           */
+          @Suppress("UNCHECKED_CAST")
+          override fun <T : ViewModel> create(modelClass: Class<T>): T {
+            return EventListViewModel(EventRepositoryMock()) as T
+          }
+        }
+  }
+}

app/src/main/java/com/android/unio/model/event/EventRepositoryMock.kt

@@ -0,0 +1,168 @@
+package com.android.unio.model.event
+
+import com.android.unio.model.association.Association
+import com.android.unio.model.firestore.MockReferenceList
+import com.android.unio.model.map.Location
+import com.google.firebase.Timestamp
+import java.util.Date
+import java.util.UUID
+
+/**
+ * A mock implementation of the EventRepository interface. This class is used for testing purposes
+ * to provide a predefined list of events.
+ *
+ * Since the actual EventRepository is not implemented yet, this mock repository allows for easy
+ * testing with specific data.
+ */
+open class EventRepositoryMock : EventRepository {
+
+  /**
+   * Retrieves a list of mock events.
+   *
+   * @return A list of [Event] objects with predefined data for testing.
+   */
+  override fun getEvents(onSuccess: (List<Event>) -> Unit, onFailure: (Exception) -> Unit) {
+    try {
+      val events =
+          listOf(
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "WESKIC",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "weskic",
+                  description =
+                      "The Summer Festival features live music, food stalls, and various activities for all ages.",
+                  catchyDescription = "Come to the best event of the Coaching IC!",
+                  price = 0.0,
+                  date = Timestamp(Date(2024 - 1900, 6, 20)), // July 20, 2024
+                  location = Location(0.0, 0.0, "USA"),
+                  types = listOf(EventType.TRIP)),
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "Oktoberweek",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "oktoberweek",
+                  description =
+                      "An evening of networking with industry leaders and innovators. Don't miss out!",
+                  catchyDescription = "There never enough beersssssss!",
+                  price = 10.0,
+                  date = Timestamp(Date(2024 - 1900, 4, 15)), // May 15, 2024
+                  location = Location(1.0, 1.0, "USA"),
+                  types = listOf(EventType.OTHER)),
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "SwissTech Talk",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "swisstechtalk",
+                  description =
+                      "Learn Kotlin from scratch with real-world examples and expert guidance.",
+                  catchyDescription = "Don't miss the chant de section!",
+                  price = 0.0,
+                  date = Timestamp(Date(2024 - 1900, 2, 10)), // March 10, 2024
+                  location = Location(2.0, 2.0, "USA"),
+                  types = listOf(EventType.OTHER)),
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "Lapin Vert",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "lapin_vert",
+                  description =
+                      "Join us for an unforgettable evening featuring local artists and musicians.",
+                  catchyDescription = "Venez, il y a des gens sympa!",
+                  price = 0.0,
+                  date = Timestamp(Date(2024 - 1900, 8, 25)), // September 25, 2024
+                  location = Location(3.0, 3.0, "USA"),
+                  types = listOf(EventType.OTHER)),
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "Choose your coach!",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "chooseyourcoach",
+                  description =
+                      "Participate in various sports activities and enjoy food and entertainment.",
+                  catchyDescription = "Pick the best one!",
+                  price = 5.0,
+                  date = Timestamp(Date(2024 - 1900, 5, 5)), // June 5, 2024
+                  location = Location(4.0, 4.0, "USA"),
+                  types = listOf(EventType.SPORT)),
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "Concert",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "antoinoxlephar",
+                  description =
+                      "A workshop dedicated to teaching strategies for successful social media marketing.",
+                  catchyDescription = "Best concert everrrrr!",
+                  price = 15.0,
+                  date = Timestamp(Date(2024 - 1900, 7, 30)), // August 30, 2024
+                  location = Location(5.0, 5.0, "USA"),
+                  types = listOf(EventType.OTHER)),
+              Event(
+                  uid = UUID.randomUUID().toString(),
+                  title = "Jam Session: Local Artists",
+                  organisers = MockReferenceList<Association>(),
+                  taggedAssociations = MockReferenceList<Association>(),
+                  image = "photo_2024_10_08_14_57_48",
+                  description =
+                      "An evening of music with local artists. Bring your instruments or just enjoy the show!",
+                  catchyDescription = "Support local talent in this open jam session!",
+                  price = 0.0,
+                  date = Timestamp(Date(2024 - 1900, 3, 12)), // April 12, 2024
+                  location = Location(6.0, 6.0, "USA"),
+                  types = listOf(EventType.JAM)))
+      onSuccess(events)
+    } catch (e: Exception) {
+      onFailure(e)
+    }
+  }
+
+  // Mock implementation for getting events by association
+  override fun getEventsOfAssociation(
+      association: String,
+      onSuccess: (List<Event>) -> Unit,
+      onFailure: (Exception) -> Unit
+  ) {
+    // Filter mock events by tagged associations
+    getEvents(
+        { events ->
+          onSuccess(events.filter { it.taggedAssociations.list.value.isEmpty() })
+        }, // Now filtering for empty tagged associations
+        onFailure)
+  }
+
+  // Mock implementation for getting events between two dates
+  override fun getNextEventsFromDateToDate(
+      startDate: Timestamp,
+      endDate: Timestamp,
+      onSuccess: (List<Event>) -> Unit,
+      onFailure: (Exception) -> Unit
+  ) {
+    // Filter mock events by date range
+    getEvents(
+        { events -> onSuccess(events.filter { it.date >= startDate && it.date <= endDate }) },
+        onFailure)
+  }
+
+  // Mock implementation to generate a new UID
+  override fun getNewUid(): String {
+    return UUID.randomUUID().toString()
+  }
+
+  // Mock implementation to add an event
+  override fun addEvent(event: Event, onSuccess: () -> Unit, onFailure: (Exception) -> Unit) {
+    // This is a mock, so we assume the event is added successfully
+    onSuccess()
+  }
+
+  // Mock implementation to delete an event by ID
+  override fun deleteEventById(id: String, onSuccess: () -> Unit, onFailure: (Exception) -> Unit) {
+    // This is a mock, so we assume the event is deleted successfully
+    onSuccess()
+  }
+}