diff --git a/app/src/main/java/com/android/polybazaar/booking/model/BookingRepository.kt b/app/src/main/java/com/android/polybazaar/booking/model/BookingRepository.kt index fc859c9b..1c801594 100644 --- a/app/src/main/java/com/android/polybazaar/booking/model/BookingRepository.kt +++ b/app/src/main/java/com/android/polybazaar/booking/model/BookingRepository.kt @@ -17,6 +17,9 @@ interface BookingRepository { /** Returns bookings for this listing owned by the signed-in lender. */ suspend fun getBookingsForListing(listingId: String): List + /** Returns the bookings of all the listings of the signed-in lender, in any status. */ + suspend fun getBookingsForLender(): List + /** Returns bookings made by the signed-in renter. */ suspend fun getBookingsForRenter(): List diff --git a/app/src/main/java/com/android/polybazaar/booking/model/FirebaseBookingRepository.kt b/app/src/main/java/com/android/polybazaar/booking/model/FirebaseBookingRepository.kt index 975fcfd7..b4f99fbd 100644 --- a/app/src/main/java/com/android/polybazaar/booking/model/FirebaseBookingRepository.kt +++ b/app/src/main/java/com/android/polybazaar/booking/model/FirebaseBookingRepository.kt @@ -62,6 +62,18 @@ class FirebaseBookingRepository( .map { it.toBooking() } } + override suspend fun getBookingsForLender(): List { + val uid = signedInUid("Sign in to read bookings") + // The rules let a lender read the bookings that name them, so the query passes as a whole. + return firestore + .collection(BOOKINGS) + .whereEqualTo("lenderUid", uid) + .get() + .await() + .documents + .map { it.toBooking() } + } + override suspend fun getBookingsForRenter(): List { val uid = signedInUid("Sign in to read bookings") return firestore diff --git a/app/src/main/java/com/android/polybazaar/toolbox/model/ToolboxListingStatus.kt b/app/src/main/java/com/android/polybazaar/toolbox/model/ToolboxListingStatus.kt new file mode 100644 index 00000000..429f91c5 --- /dev/null +++ b/app/src/main/java/com/android/polybazaar/toolbox/model/ToolboxListingStatus.kt @@ -0,0 +1,40 @@ +package com.android.polybazaar.toolbox.model + +import com.android.polybazaar.booking.model.Booking +import com.android.polybazaar.booking.model.BookingStatus +import com.android.polybazaar.listing.model.Listing +import java.time.LocalDate + +/** + * What the owner's Toolbox says about one of their listings (#196), derived from the listing and + * its bookings rather than stored. + * + * Lenders cannot approve or reject a request yet, so any booking that is not cancelled and covers + * today makes the listing [BookedToday]. Once requests can be approved, it should only count + * approved bookings. Bookings on later days do not show: the listing is still [Available] today. + */ +sealed interface ToolboxListingStatus { + /** Hidden from everyone else by its owner; shown whatever its bookings. */ + data object Paused : ToolboxListingStatus + + /** A booking that is not cancelled covers today. */ + data object BookedToday : ToolboxListingStatus + + /** Not paused, and no booking that is not cancelled covers today. */ + data object Available : ToolboxListingStatus +} + +/** + * The status of [listing] on [today], from [bookings], which may include those of other listings. + */ +fun toolboxListingStatus( + listing: Listing, + bookings: List, + today: LocalDate, +): ToolboxListingStatus { + if (listing.isPaused) return ToolboxListingStatus.Paused + val bookedToday = bookings.any { + it.listingId == listing.listingId && it.status != BookingStatus.CANCELLED && today in it.days + } + return if (bookedToday) ToolboxListingStatus.BookedToday else ToolboxListingStatus.Available +} diff --git a/app/src/main/java/com/android/polybazaar/toolbox/ui/ToolboxCard.kt b/app/src/main/java/com/android/polybazaar/toolbox/ui/ToolboxCard.kt index f35f4998..da16827b 100644 --- a/app/src/main/java/com/android/polybazaar/toolbox/ui/ToolboxCard.kt +++ b/app/src/main/java/com/android/polybazaar/toolbox/ui/ToolboxCard.kt @@ -16,6 +16,7 @@ import androidx.compose.foundation.layout.size import androidx.compose.foundation.layout.width import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape import androidx.compose.material3.CircularProgressIndicator import androidx.compose.material3.Text @@ -26,6 +27,7 @@ import androidx.compose.runtime.getValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color import androidx.compose.ui.platform.testTag import androidx.compose.ui.res.stringResource import androidx.compose.ui.semantics.Role @@ -46,8 +48,10 @@ import com.android.polybazaar.listing.model.ListingType import com.android.polybazaar.listing.model.ServiceListing import com.android.polybazaar.listing.model.formatChf import com.android.polybazaar.listing.ui.PausedBadge +import com.android.polybazaar.toolbox.model.ToolboxListingStatus import com.android.polybazaar.toolbox.viewmodel.ToolboxUiState import com.android.polybazaar.toolbox.viewmodel.ToolboxViewModel +import java.time.LocalDate object ToolboxCardTags { const val LISTINGS = "toolbox_listings" @@ -61,8 +65,14 @@ object ToolboxCardTags { const val FILTER_SERVICES = "toolbox_filter_services" const val FILTER_EMPTY = "toolbox_filter_empty" const val PAUSED_BADGE = "toolbox_paused_badge" + /** The status of an unpaused listing: available or booked today. */ + const val STATUS_BADGE = "toolbox_status_badge" } +/** Green for a listing anyone can book, so it reads apart from the busy ones. */ +private val AvailableText = Color(0xFF2E6B3A) +private val AvailableBackground = Color(0xFFE3F1E1) + /** @param onOpenListing called with a listing's id when the user taps its row. */ @Composable fun ToolboxCard(viewModel: ToolboxViewModel, onOpenListing: (String) -> Unit = {}) { @@ -83,6 +93,9 @@ fun ToolboxCard(viewModel: ToolboxViewModel, onOpenListing: (String) -> Unit = { * Fills the height it is given: the title stays in place and the rows scroll inside the card, so it * needs a bounded height. * + * Each row shows its listing's status on [today]: paused, booked today or available. A row whose + * status needs bookings that could not be loaded shows none. + * * @param onOpenListing called with a listing's id when the user taps its row. */ @Composable @@ -92,6 +105,7 @@ fun ToolboxContent( onTypeSelected: (ListingType?) -> Unit, modifier: Modifier = Modifier, onOpenListing: (String) -> Unit = {}, + today: LocalDate = LocalDate.now(), ) { val shape = RoundedCornerShape(20.dp) Column( @@ -182,7 +196,11 @@ fun ToolboxContent( items(filteredListings) { listing -> // A listing loaded from the repository always has its id. val id = listing.listingId - ToolboxListingRow(listing = listing, onClick = id?.let { { onOpenListing(it) } }) + ToolboxListingRow( + listing = listing, + status = uiState.statusOf(listing, today), + onClick = id?.let { { onOpenListing(it) } }, + ) } } } else if (uiState.listings.isNotEmpty()) { @@ -233,9 +251,16 @@ private fun TypeFilterButton( ) } -/** @param onClick called when the user taps the row, or null for a row that cannot be tapped. */ +/** + * @param status what the badge after the title says, or null for no badge. + * @param onClick called when the user taps the row, or null for a row that cannot be tapped. + */ @Composable -private fun ToolboxListingRow(listing: Listing, onClick: (() -> Unit)?) { +private fun ToolboxListingRow( + listing: Listing, + status: ToolboxListingStatus?, + onClick: (() -> Unit)?, +) { val shape = RoundedCornerShape(18.dp) val openLabel = stringResource(R.string.open_listing) // Clipped first, so the ripple follows the row's rounded corners. @@ -269,11 +294,7 @@ private fun ToolboxListingRow(listing: Listing, onClick: (() -> Unit)?) { // Not filling: the badge follows a short title, and a long one is cut before the badge. modifier = Modifier.weight(1f, fill = false), ) - // Paused listings are hidden from everyone else, so the owner needs to see which ones are. - if (listing.isPaused) { - // No vertical padding, so a paused row is as tall as an active one. - PausedBadge(Modifier.testTag(ToolboxCardTags.PAUSED_BADGE), verticalPadding = 0.dp) - } + status?.let { StatusBadge(it) } } Row { Text( @@ -297,6 +318,47 @@ private fun ToolboxListingRow(listing: Listing, onClick: (() -> Unit)?) { } } +/** + * The badge after a row's title. Paused uses the listing detail's badge: paused listings are hidden + * from everyone else, so the owner needs to spot them. No vertical padding, so every row is as tall + * as one without a badge. + */ +@Composable +private fun StatusBadge(status: ToolboxListingStatus) { + when (status) { + ToolboxListingStatus.Paused -> + PausedBadge(Modifier.testTag(ToolboxCardTags.PAUSED_BADGE), verticalPadding = 0.dp) + ToolboxListingStatus.Available -> + StatusPill( + text = stringResource(R.string.toolbox_status_available), + textColor = AvailableText, + background = AvailableBackground, + ) + ToolboxListingStatus.BookedToday -> + StatusPill( + text = stringResource(R.string.toolbox_status_booked_today), + textColor = AuthColors.CardBackground, + background = AuthColors.Accent, + ) + } +} + +/** A pill shaped like [PausedBadge], in the colours of its status. */ +@Composable +private fun StatusPill(text: String, textColor: Color, background: Color) { + Text( + text = text.uppercase(), + color = textColor, + fontSize = 11.sp, + fontWeight = FontWeight.SemiBold, + maxLines = 1, + modifier = + Modifier.testTag(ToolboxCardTags.STATUS_BADGE) + .background(background, CircleShape) + .padding(horizontal = 10.dp), + ) +} + @Preview(showBackground = true, widthDp = 412, heightDp = 320) @Composable internal fun ToolboxContentPreview() { @@ -320,7 +382,8 @@ internal fun ToolboxContentPreview() { "", listingId = "math", ), - ) + ), + bookings = emptyList(), ), onRetry = {}, onTypeSelected = {}, diff --git a/app/src/main/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModel.kt b/app/src/main/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModel.kt index a3181a36..1d50a7ca 100644 --- a/app/src/main/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModel.kt +++ b/app/src/main/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModel.kt @@ -1,14 +1,21 @@ // Co-authored-by: Claude Code (Claude Opus 5.5) package com.android.polybazaar.toolbox.viewmodel +import android.util.Log import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope +import com.android.polybazaar.booking.model.Booking +import com.android.polybazaar.booking.model.BookingRepository import com.android.polybazaar.error.model.AppError import com.android.polybazaar.error.model.toAppError import com.android.polybazaar.listing.model.Listing import com.android.polybazaar.listing.model.ListingRepository import com.android.polybazaar.listing.model.ListingType +import com.android.polybazaar.toolbox.model.ToolboxListingStatus +import com.android.polybazaar.toolbox.model.toolboxListingStatus +import java.time.LocalDate import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.async import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow @@ -24,20 +31,40 @@ import kotlinx.coroutines.launch * @property isLoading true while the listings are being loaded. * @property error why the last load failed, or null. * @property selectedType the type the listings are filtered by, or null to show them all. + * @property bookings the bookings of all the user's listings, or null until they are first loaded + * and after the last load of them failed: the listings then show only whether they are paused, + * since bookings from an earlier load may be out of date. */ data class ToolboxUiState( val listings: List = emptyList(), val isLoading: Boolean = false, val error: AppError? = null, val selectedType: ListingType? = null, + val bookings: List? = null, ) { + /** + * The status of [listing] on [today], or null when it depends on [bookings] that are not loaded: + * a paused listing is known to be paused without them. + */ + fun statusOf(listing: Listing, today: LocalDate): ToolboxListingStatus? = + when { + listing.isPaused -> ToolboxListingStatus.Paused + bookings == null -> null + else -> toolboxListingStatus(listing, bookings, today) + } + /** The [listings] of the [selectedType], or all of them when no type is selected. */ val filteredListings: List get() = if (selectedType == null) listings else listings.filter { it.type == selectedType } } -/** Loads the signed-in user's listings for the Toolbox. */ -class ToolboxViewModel(private val listingRepository: ListingRepository) : ViewModel() { +/** + * Loads the signed-in user's listings for the Toolbox, with the bookings that give their status. + */ +class ToolboxViewModel( + private val listingRepository: ListingRepository, + private val bookingRepository: BookingRepository, +) : ViewModel() { private val _uiState = MutableStateFlow(ToolboxUiState()) val uiState: StateFlow = _uiState.asStateFlow() @@ -52,15 +79,19 @@ class ToolboxViewModel(private val listingRepository: ListingRepository) : ViewM } /** - * Loads the user's listings, for example again after a failure (Retry) or after creating one. - * Ignored while a load is already running. On failure the listings already shown are kept, so a - * reload while offline does not empty the Toolbox. + * Loads the user's listings and their bookings, for example again after a failure (Retry) or + * after creating one. Ignored while a load is already running. On failure the listings already + * shown are kept, so a reload while offline does not empty the Toolbox, and the error says they + * may be out of date. A failure of the bookings shows no error, as the listings are still worth + * showing, so the bookings are dropped instead: a status from an earlier load would look current. */ fun loadListings() { // Two loads at once could finish in any order, and the older answer would overwrite the newer. if (_uiState.value.isLoading) return _uiState.update { it.copy(isLoading = true, error = null) } viewModelScope.launch { + // At the same time as the listings, so the statuses do not arrive a round trip later. + val bookings = async { loadBookings() } try { listingRepository .getMyListings() @@ -70,10 +101,29 @@ class ToolboxViewModel(private val listingRepository: ListingRepository) : ViewM if (exception is CancellationException) throw exception _uiState.update { it.copy(error = exception.toAppError()) } } + val loaded = bookings.await() + _uiState.update { it.copy(bookings = loaded) } } finally { // Also on cancellation, otherwise the guard above would block every later load. _uiState.update { it.copy(isLoading = false) } } } } + + /** + * The user's bookings as a lender, or null when they cannot be read. The failure is logged, as + * nothing on screen reports it: a malformed booking would otherwise hide every status silently. + */ + private suspend fun loadBookings(): List? = + try { + bookingRepository.getBookingsForLender() + } catch (exception: Exception) { + if (exception is CancellationException) throw exception + Log.w(TAG, "Could not load the bookings, so the listings show no status", exception) + null + } + + private companion object { + const val TAG = "ToolboxViewModel" + } } diff --git a/app/src/main/java/com/android/polybazaar/ui/navigation/AppNavHost.kt b/app/src/main/java/com/android/polybazaar/ui/navigation/AppNavHost.kt index 75d0b661..4e6aab0c 100644 --- a/app/src/main/java/com/android/polybazaar/ui/navigation/AppNavHost.kt +++ b/app/src/main/java/com/android/polybazaar/ui/navigation/AppNavHost.kt @@ -569,7 +569,9 @@ fun AppNavHost( viewModel( key = "toolbox_$uid", factory = - viewModelFactory { initializer { ToolboxViewModel(listingRepository) } }, + viewModelFactory { + initializer { ToolboxViewModel(listingRepository, bookingRepository) } + }, ) // Switching tabs keeps this ViewModel, so a listing published since it loaded needs a // reload to show up when the user comes back. diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 022c209c..dc7784f8 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -150,6 +150,8 @@ Services You have no item listings. You have no service listings. + Available + Booked today Forgot password diff --git a/app/src/sharedTest/java/com/android/polybazaar/booking/model/FakeBookingRepository.kt b/app/src/sharedTest/java/com/android/polybazaar/booking/model/FakeBookingRepository.kt index 998c996c..e7607529 100644 --- a/app/src/sharedTest/java/com/android/polybazaar/booking/model/FakeBookingRepository.kt +++ b/app/src/sharedTest/java/com/android/polybazaar/booking/model/FakeBookingRepository.kt @@ -11,6 +11,10 @@ import kotlinx.coroutines.currentCoroutineContext * A [BookingRepository] in memory, for tests. It records the last booking requested and how many * were, and can hold a request back ([pendingRequest]), make it throw ([failure]) or report a write * failure, at once ([immediateWriteFailure]) or later through [writeFailure]. + * + * [getBookingsForLender] returns [lenderBookings], or throws [lenderLoadFailure], after + * [pendingLenderLoad]; it has its own fields so that a screen loading both kinds of bookings can + * fail one alone. */ class FakeBookingRepository : BookingRepository { var requestedBooking: Booking? = null @@ -22,6 +26,10 @@ class FakeBookingRepository : BookingRepository { var requestJob: Job? = null var renterBookings: List = emptyList() var listingBookings: List = emptyList() + var lenderBookings: List = emptyList() + var pendingLenderLoad: CompletableDeferred? = null + var lenderLoadFailure: Exception? = null + var lenderLoadCount = 0 var pendingLoad: CompletableDeferred? = null var loadFailure: Exception? = null var loadCount = 0 @@ -48,6 +56,13 @@ class FakeBookingRepository : BookingRepository { return listingBookings } + override suspend fun getBookingsForLender(): List { + lenderLoadCount++ + pendingLenderLoad?.await() + lenderLoadFailure?.let { throw it } + return lenderBookings + } + /** Does nothing: no test answers a booking request yet. */ override suspend fun acceptBooking(booking: Booking) = Unit diff --git a/app/src/test/java/com/android/polybazaar/booking/model/FirebaseBookingRepositoryTest.kt b/app/src/test/java/com/android/polybazaar/booking/model/FirebaseBookingRepositoryTest.kt index b6a4c143..7709436f 100644 --- a/app/src/test/java/com/android/polybazaar/booking/model/FirebaseBookingRepositoryTest.kt +++ b/app/src/test/java/com/android/polybazaar/booking/model/FirebaseBookingRepositoryTest.kt @@ -43,6 +43,7 @@ class FirebaseBookingRepositoryTest { private val listingQuery = mock() private val lenderQuery = mock() private val renterQuery = mock() + private val allLenderQuery = mock() private val snapshot = mock() private val stored = mock() // A fixed day before every booking these tests store, so none of them is ever finished. @@ -67,6 +68,7 @@ class FirebaseBookingRepositoryTest { whenever(collection.whereEqualTo("listingId", "listing")).thenReturn(listingQuery) whenever(listingQuery.whereEqualTo("lenderUid", "lender")).thenReturn(lenderQuery) whenever(collection.whereEqualTo("renterUid", "renter")).thenReturn(renterQuery) + whenever(collection.whereEqualTo("lenderUid", "renter")).thenReturn(allLenderQuery) whenever(collection.document("booking-id")).thenReturn(document) } @@ -237,6 +239,39 @@ class FirebaseBookingRepositoryTest { verify(collection).whereEqualTo("renterUid", "renter") } + @Test + fun getBookingsForLenderQueriesTheSignedInLenderAndDecodesBookings() = runTest { + whenever(allLenderQuery.get()).thenReturn(Tasks.forResult(snapshot)) + whenever(snapshot.documents).thenReturn(listOf(stored)) + whenever(stored.getString("listingId")).thenReturn(booking.listingId) + whenever(stored.getString("renterUid")).thenReturn(booking.renterUid) + whenever(stored.getString("lenderUid")).thenReturn("renter") + whenever(stored.get("days")).thenReturn(booking.days.map { it.toEpochDay() }) + whenever(stored.getString("status")).thenReturn("CANCELLED") + whenever(stored.id).thenReturn("booking-id") + + assertEquals( + listOf( + booking.copy(lenderUid = "renter", status = BookingStatus.CANCELLED, id = "booking-id") + ), + repository.getBookingsForLender(), + ) + verify(collection).whereEqualTo("lenderUid", "renter") + } + + @Test + fun getBookingsForLenderRejectsSignedOutUser() = runTest { + whenever(auth.currentUser).thenReturn(null) + + val error = runCatching { repository.getBookingsForLender() }.exceptionOrNull() + + assertTrue(error is FirebaseFirestoreException) + assertEquals( + FirebaseFirestoreException.Code.UNAUTHENTICATED, + (error as FirebaseFirestoreException).code, + ) + } + @Test fun getBookingsForRenterRejectsSignedOutUser() = runTest { whenever(auth.currentUser).thenReturn(null) diff --git a/app/src/test/java/com/android/polybazaar/toolbox/model/ToolboxListingStatusTest.kt b/app/src/test/java/com/android/polybazaar/toolbox/model/ToolboxListingStatusTest.kt new file mode 100644 index 00000000..89f15359 --- /dev/null +++ b/app/src/test/java/com/android/polybazaar/toolbox/model/ToolboxListingStatusTest.kt @@ -0,0 +1,105 @@ +package com.android.polybazaar.toolbox.model + +import com.android.polybazaar.booking.model.Booking +import com.android.polybazaar.booking.model.BookingStatus +import com.android.polybazaar.listing.model.ItemListing +import com.android.polybazaar.listing.model.ListingCategory +import java.time.LocalDate +import org.junit.Assert.assertEquals +import org.junit.Test + +class ToolboxListingStatusTest { + + private val today = LocalDate.of(2026, 11, 19) + private val drill = + ItemListing(ListingCategory.ITEM_TOOLS, 8.0, "Bosch drill", "", listingId = "drill") + + private fun booking( + vararg days: LocalDate, + status: BookingStatus = BookingStatus.REQUESTED, + listingId: String = "drill", + ) = Booking(listingId, "renter", "lender", days.toSet(), status) + + private fun status(vararg bookings: Booking) = + toolboxListingStatus(drill, bookings.toList(), today) + + @Test + fun noBookings_isAvailable() { + assertEquals(ToolboxListingStatus.Available, status()) + } + + @Test + fun paused_winsOverABookingToday() { + val paused = drill.copy(isPaused = true) + + assertEquals( + ToolboxListingStatus.Paused, + toolboxListingStatus(paused, listOf(booking(today)), today), + ) + } + + @Test + fun aRequestCoveringToday_isBookedToday() { + assertEquals(ToolboxListingStatus.BookedToday, status(booking(today.minusDays(1), today))) + } + + @Test + fun aSeparateDayBookingWhoseDaysSkipToday_isAvailable() { + // 18 and 20 Nov in one booking: today is between its days, not one of them. + assertEquals( + ToolboxListingStatus.Available, + status(booking(today.minusDays(1), today.plusDays(1))), + ) + } + + @Test + fun bookedToday_winsOverLaterRequests() { + assertEquals( + ToolboxListingStatus.BookedToday, + status(booking(today.plusDays(3)), booking(today)), + ) + } + + @Test + fun onlyLaterBookings_isAvailable() { + assertEquals( + ToolboxListingStatus.Available, + status(booking(today.plusDays(1)), booking(today.plusDays(5), today.plusDays(6))), + ) + } + + @Test + fun aConfirmedBooking_countsLikeARequest() { + assertEquals( + ToolboxListingStatus.BookedToday, + status(booking(today, status = BookingStatus.CONFIRMED)), + ) + } + + @Test + fun cancelledBookings_areIgnored() { + assertEquals( + ToolboxListingStatus.Available, + status( + booking(today, status = BookingStatus.CANCELLED), + booking(today.plusDays(1), status = BookingStatus.CANCELLED), + ), + ) + } + + @Test + fun pastBookings_areIgnored() { + assertEquals( + ToolboxListingStatus.Available, + status(booking(today.minusDays(3), today.minusDays(1))), + ) + } + + @Test + fun bookingsOfOtherListings_areIgnored() { + assertEquals( + ToolboxListingStatus.Available, + status(booking(today, listingId = "tent"), booking(today.plusDays(1), listingId = "tent")), + ) + } +} diff --git a/app/src/test/java/com/android/polybazaar/toolbox/ui/ToolboxCardTest.kt b/app/src/test/java/com/android/polybazaar/toolbox/ui/ToolboxCardTest.kt index a228a91b..63405166 100644 --- a/app/src/test/java/com/android/polybazaar/toolbox/ui/ToolboxCardTest.kt +++ b/app/src/test/java/com/android/polybazaar/toolbox/ui/ToolboxCardTest.kt @@ -28,6 +28,9 @@ import androidx.compose.ui.unit.dp import androidx.test.core.app.ApplicationProvider import androidx.test.ext.junit.runners.AndroidJUnit4 import com.android.polybazaar.R +import com.android.polybazaar.booking.model.Booking +import com.android.polybazaar.booking.model.BookingStatus +import com.android.polybazaar.booking.model.FakeBookingRepository import com.android.polybazaar.error.model.AppError import com.android.polybazaar.listing.model.FakeListingRepository import com.android.polybazaar.listing.model.ItemListing @@ -39,6 +42,7 @@ import com.android.polybazaar.toolbox.viewmodel.ToolboxUiState import com.android.polybazaar.toolbox.viewmodel.ToolboxViewModel import com.android.polybazaar.ui.theme.PolyBazaarTheme import java.net.UnknownHostException +import java.time.LocalDate import org.junit.Assert.assertEquals import org.junit.Assert.assertFalse import org.junit.Assert.assertTrue @@ -53,6 +57,9 @@ class ToolboxCardTest { @get:Rule val composeTestRule = createComposeRule() + private val bookings = FakeBookingRepository() + private val today = LocalDate.of(2026, 11, 19) + private val myListings = listOf( ItemListing(ListingCategory.ITEM_TOOLS, 8.0, "Bosch drill set", "", listingId = "drill"), @@ -391,7 +398,7 @@ class ToolboxCardTest { @Test fun card_showsTheListingsLoadedByTheViewModel() { - val viewModel = ToolboxViewModel(FakeListingRepository(myListings = myListings)) + val viewModel = ToolboxViewModel(FakeListingRepository(myListings = myListings), bookings) composeTestRule.setContent { ToolboxCard(viewModel = viewModel) } composeTestRule.onNodeWithText(string(R.string.toolbox_title)).assertIsDisplayed() @@ -401,7 +408,7 @@ class ToolboxCardTest { @Test fun card_tappingTheFilterButtonsSelectsSwitchesAndShowsAllAgain() { - val viewModel = ToolboxViewModel(FakeListingRepository(myListings = myListings)) + val viewModel = ToolboxViewModel(FakeListingRepository(myListings = myListings), bookings) composeTestRule.setContent { ToolboxCard(viewModel = viewModel) } val all = composeTestRule.onNodeWithTag(ToolboxCardTags.FILTER_ALL) val items = composeTestRule.onNodeWithTag(ToolboxCardTags.FILTER_ITEMS) @@ -438,7 +445,7 @@ class ToolboxCardTest { @Test fun card_retryKeepsTheSelectedFilter() { val repository = FakeListingRepository(myListings = myListings) - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) composeTestRule.setContent { ToolboxCard(viewModel = viewModel) } composeTestRule.onNodeWithTag(ToolboxCardTags.FILTER_SERVICES).performClick() repository.failure = UnknownHostException("offline") @@ -461,7 +468,7 @@ class ToolboxCardTest { FakeListingRepository(myListings = myListings).apply { failure = UnknownHostException("offline") } - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) composeTestRule.setContent { ToolboxCard(viewModel = viewModel) } composeTestRule.onNodeWithTag(ToolboxCardTags.ERROR).assertIsDisplayed() @@ -507,10 +514,124 @@ class ToolboxCardTest { onRetry = onRetry, onTypeSelected = onTypeSelected, onOpenListing = onOpenListing, + today = today, ) } } + /** Four listings: paused, booked today, and two available, one of them booked later. */ + private val statusListings = + listOf( + ItemListing(ListingCategory.ITEM_TOOLS, 5.0, "Kayak", "", listingId = "kayak") + .copy(isPaused = true), + ItemListing(ListingCategory.ITEM_TOOLS, 8.0, "Bosch drill", "", listingId = "drill"), + ItemListing(ListingCategory.ITEM_TOOLS, 12.0, "Tent 3p", "", listingId = "tent"), + ServiceListing( + ListingCategory.SERVICE_TUTORING, + 20.0, + "Bike repair", + "", + listingId = "bike", + ), + ) + + private val statusBookings = + listOf( + // A paused listing stays paused whatever its bookings. + Booking("kayak", "renter", "me", setOf(today)), + Booking("drill", "renter", "me", setOf(today, today.plusDays(1))), + Booking("tent", "renter", "me", setOf(today.plusDays(2))), + Booking("tent", "other", "me", setOf(today.plusDays(4), today.plusDays(6))), + // Neither counts: one is cancelled, the other is over. + Booking("bike", "renter", "me", setOf(today), BookingStatus.CANCELLED), + Booking("bike", "renter", "me", setOf(today.minusDays(2))), + ) + + @Test + fun statuses_showOneBadgePerRow() { + setContent(ToolboxUiState(listings = statusListings, bookings = statusBookings)) + + val rows = composeTestRule.onAllNodesWithTag(ToolboxCardTags.LISTING_ROW) + rows[0] + .assert(hasText("Kayak")) + .assert(hasText(string(R.string.listing_detail_paused).uppercase())) + rows[1] + .assert(hasText("Bosch drill")) + .assert(hasText(string(R.string.toolbox_status_booked_today).uppercase())) + val available = string(R.string.toolbox_status_available).uppercase() + // Booked on later days only: still available today. + rows[2].assert(hasText("Tent 3p")).assert(hasText(available)) + rows[3].assert(hasText("Bike repair")).assert(hasText(available)) + composeTestRule + .onAllNodesWithTag(ToolboxCardTags.PAUSED_BADGE, useUnmergedTree = true) + .assertCountEquals(1) + composeTestRule + .onAllNodesWithTag(ToolboxCardTags.STATUS_BADGE, useUnmergedTree = true) + .assertCountEquals(3) + } + + @Test + fun bookingsNotLoaded_showOnlyThePausedBadge() { + setContent(ToolboxUiState(listings = statusListings, bookings = null)) + + composeTestRule + .onAllNodesWithTag(ToolboxCardTags.PAUSED_BADGE, useUnmergedTree = true) + .assertCountEquals(1) + composeTestRule + .onAllNodesWithTag(ToolboxCardTags.STATUS_BADGE, useUnmergedTree = true) + .assertCountEquals(0) + } + + @Test + @GraphicsMode(GraphicsMode.Mode.NATIVE) // Measures the text for real, so heights are real. + fun everyStatus_keepsTheRowsTheSameHeight() { + composeTestRule.setContent { + PolyBazaarTheme(dynamicColor = false) { + ToolboxContent( + uiState = ToolboxUiState(listings = statusListings, bookings = statusBookings), + onRetry = {}, + onTypeSelected = {}, + today = today, + ) + } + } + + val rows = composeTestRule.onAllNodesWithTag(ToolboxCardTags.LISTING_ROW) + val heights = + (0 until 4).map { rows[it].getUnclippedBoundsInRoot().let { b -> b.bottom - b.top } } + assertEquals(1, heights.distinct().size) + } + + @Test + fun card_showsTheStatusFromTheLenderBookings() { + bookings.lenderBookings = listOf(Booking("drill", "renter", "me", setOf(LocalDate.now()))) + val viewModel = ToolboxViewModel(FakeListingRepository(myListings = myListings), bookings) + composeTestRule.setContent { ToolboxCard(viewModel = viewModel) } + + val rows = composeTestRule.onAllNodesWithTag(ToolboxCardTags.LISTING_ROW) + rows[0].assert(hasText(string(R.string.toolbox_status_booked_today).uppercase())) + rows[1].assert(hasText(string(R.string.toolbox_status_available).uppercase())) + } + + @Test + fun card_aFailedRefreshOfTheBookings_showsNoStaleBadge() { + bookings.lenderBookings = listOf(Booking("drill", "renter", "me", setOf(LocalDate.now()))) + val viewModel = ToolboxViewModel(FakeListingRepository(myListings = myListings), bookings) + composeTestRule.setContent { ToolboxCard(viewModel = viewModel) } + composeTestRule + .onAllNodesWithTag(ToolboxCardTags.STATUS_BADGE, useUnmergedTree = true) + .assertCountEquals(2) + + bookings.lenderLoadFailure = UnknownHostException("offline") + viewModel.loadListings() + composeTestRule.waitForIdle() + + composeTestRule + .onAllNodesWithTag(ToolboxCardTags.STATUS_BADGE, useUnmergedTree = true) + .assertCountEquals(0) + composeTestRule.onAllNodesWithTag(ToolboxCardTags.LISTING_ROW).assertCountEquals(2) + } + private fun string(id: Int): String = ApplicationProvider.getApplicationContext().getString(id) } diff --git a/app/src/test/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModelTest.kt b/app/src/test/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModelTest.kt index 66c2e5d2..ca22d7c4 100644 --- a/app/src/test/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModelTest.kt +++ b/app/src/test/java/com/android/polybazaar/toolbox/viewmodel/ToolboxViewModelTest.kt @@ -2,6 +2,8 @@ // Co-authored-by: Copilot GPT-5.6 Terra package com.android.polybazaar.toolbox.viewmodel +import com.android.polybazaar.booking.model.Booking +import com.android.polybazaar.booking.model.FakeBookingRepository import com.android.polybazaar.error.model.AppError import com.android.polybazaar.listing.model.FakeListingRepository import com.android.polybazaar.listing.model.ItemListing @@ -9,7 +11,9 @@ import com.android.polybazaar.listing.model.Listing import com.android.polybazaar.listing.model.ListingCategory import com.android.polybazaar.listing.model.ListingType import com.android.polybazaar.listing.model.ServiceListing +import com.android.polybazaar.toolbox.model.ToolboxListingStatus import java.net.UnknownHostException +import java.time.LocalDate import kotlinx.coroutines.CancellationException import kotlinx.coroutines.CompletableDeferred import kotlinx.coroutines.Dispatchers @@ -48,6 +52,10 @@ class ToolboxViewModelTest { ) private val repository = FakeListingRepository(myListings = myListings) + private val bookings = FakeBookingRepository() + + private val today = LocalDate.of(2026, 11, 19) + private val drillToday = Booking("drill", "renter", "lender", setOf(today)) @Before fun setUp() { @@ -62,7 +70,7 @@ class ToolboxViewModelTest { @Test fun init_loadsMyListings() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) val state = viewModel.uiState.value assertEquals(myListings, state.listings) @@ -77,7 +85,7 @@ class ToolboxViewModelTest { fun init_withNoListings_showsAnEmptyToolboxWithoutError() { repository.myListings = emptyList() - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) assertEquals(emptyList(), viewModel.uiState.value.listings) assertNull(viewModel.uiState.value.error) @@ -88,7 +96,7 @@ class ToolboxViewModelTest { val gate = CompletableDeferred() repository.gate = gate - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) assertTrue(viewModel.uiState.value.isLoading) assertEquals(emptyList(), viewModel.uiState.value.listings) @@ -101,7 +109,7 @@ class ToolboxViewModelTest { fun loadListings_whileALoadIsRunning_isIgnored() { val gate = CompletableDeferred() repository.gate = gate - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.loadListings() viewModel.loadListings() @@ -115,7 +123,7 @@ class ToolboxViewModelTest { fun loadListings_onFailure_setsTheErrorAndStopsLoading() { repository.failure = UnknownHostException("offline") - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) val state = viewModel.uiState.value assertFalse(state.isLoading) @@ -125,7 +133,7 @@ class ToolboxViewModelTest { @Test fun loadListings_onFailure_keepsTheListingsAlreadyShown() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) repository.failure = UnknownHostException("offline") viewModel.loadListings() @@ -137,7 +145,7 @@ class ToolboxViewModelTest { @Test fun loadListings_retryAfterFailure_clearsTheErrorAndShowsTheListings() { repository.failure = UnknownHostException("offline") - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) assertEquals(AppError.NETWORK, viewModel.uiState.value.error) val gate = CompletableDeferred() @@ -156,7 +164,7 @@ class ToolboxViewModelTest { @Test fun loadListings_afterANewListing_showsIt() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) val newListing = ItemListing(ListingCategory.ITEM_BOOKS, 3.0, "Novel", "", listingId = "novel") repository.myListings = myListings + newListing @@ -168,7 +176,7 @@ class ToolboxViewModelTest { @Test fun loadListings_whenCancelled_reportsNoErrorAndAllowsTheNextLoad() { repository.failure = CancellationException("left the screen") - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) assertNull(viewModel.uiState.value.error) assertFalse(viewModel.uiState.value.isLoading) @@ -181,7 +189,7 @@ class ToolboxViewModelTest { @Test fun init_selectsNoTypeAndShowsAllListings() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) assertNull(viewModel.uiState.value.selectedType) assertEquals(myListings, viewModel.uiState.value.filteredListings) @@ -189,7 +197,7 @@ class ToolboxViewModelTest { @Test fun selectType_item_showsOnlyItems() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.ITEM) @@ -201,7 +209,7 @@ class ToolboxViewModelTest { @Test fun selectType_service_showsOnlyServices() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.SERVICE) @@ -211,7 +219,7 @@ class ToolboxViewModelTest { @Test fun selectType_null_showsAllListings() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.ITEM) viewModel.selectType(null) @@ -222,7 +230,7 @@ class ToolboxViewModelTest { @Test fun selectType_theSelectedTypeAgain_keepsIt() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.ITEM) viewModel.selectType(ListingType.ITEM) @@ -233,7 +241,7 @@ class ToolboxViewModelTest { @Test fun selectType_theOtherType_switchesDirectly() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.ITEM) viewModel.selectType(ListingType.SERVICE) @@ -245,7 +253,7 @@ class ToolboxViewModelTest { @Test fun selectType_withNoListingOfThatType_filtersToAnEmptyList() { repository.myListings = listOf(myListings[0]) - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.SERVICE) @@ -255,7 +263,7 @@ class ToolboxViewModelTest { @Test fun loadListings_afterANewListing_keepsTheFilter() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.ITEM) val newItem = ItemListing(ListingCategory.ITEM_BOOKS, 3.0, "Novel", "", listingId = "novel") val newService = @@ -270,7 +278,7 @@ class ToolboxViewModelTest { @Test fun loadListings_retryAfterFailure_keepsTheFilter() { - val viewModel = ToolboxViewModel(repository) + val viewModel = ToolboxViewModel(repository, bookings) viewModel.selectType(ListingType.SERVICE) repository.failure = UnknownHostException("offline") viewModel.loadListings() @@ -283,4 +291,106 @@ class ToolboxViewModelTest { assertEquals(ListingType.SERVICE, viewModel.uiState.value.selectedType) assertEquals(listOf(myListings[1]), viewModel.uiState.value.filteredListings) } + + @Test + fun init_loadsTheLenderBookings_soEachListingHasItsStatus() { + bookings.lenderBookings = listOf(drillToday) + + val state = ToolboxViewModel(repository, bookings).uiState.value + + assertEquals(1, bookings.lenderLoadCount) + assertEquals(ToolboxListingStatus.BookedToday, state.statusOf(myListings[0], today)) + assertEquals(ToolboxListingStatus.Available, state.statusOf(myListings[1], today)) + } + + @Test + fun loadListings_staysLoadingUntilTheBookingsArrive() { + val gate = CompletableDeferred() + bookings.pendingLenderLoad = gate + bookings.lenderBookings = listOf(drillToday) + + val viewModel = ToolboxViewModel(repository, bookings) + assertTrue(viewModel.uiState.value.isLoading) + // The listings already show; their status is unknown until the bookings arrive. + assertEquals(myListings, viewModel.uiState.value.listings) + assertNull(viewModel.uiState.value.statusOf(myListings[0], today)) + + gate.complete(Unit) + assertFalse(viewModel.uiState.value.isLoading) + assertEquals( + ToolboxListingStatus.BookedToday, + viewModel.uiState.value.statusOf(myListings[0], today), + ) + } + + @Test + fun bookingsFailing_showsTheListingsWithoutStatusAndNoError() { + bookings.lenderLoadFailure = UnknownHostException("offline") + val paused = (myListings[0] as ItemListing).copy(isPaused = true) + repository.myListings = listOf(paused, myListings[1]) + + val state = ToolboxViewModel(repository, bookings).uiState.value + + assertNull(state.error) + assertEquals(listOf(paused, myListings[1]), state.listings) + // Paused needs no bookings; Available would be a guess. + assertEquals(ToolboxListingStatus.Paused, state.statusOf(paused, today)) + assertNull(state.statusOf(myListings[1], today)) + } + + @Test + fun bookingsFailingOnAReload_dropsTheStatusesAlreadyShown() { + bookings.lenderBookings = listOf(drillToday) + val viewModel = ToolboxViewModel(repository, bookings) + assertEquals( + ToolboxListingStatus.BookedToday, + viewModel.uiState.value.statusOf(myListings[0], today), + ) + // Cancelled meanwhile, but the reload fails: Booked today would now be wrong. + bookings.lenderBookings = emptyList() + bookings.lenderLoadFailure = UnknownHostException("offline") + + viewModel.loadListings() + + val state = viewModel.uiState.value + assertNull(state.bookings) + assertNull(state.statusOf(myListings[0], today)) + assertNull(state.statusOf(myListings[1], today)) + // The listings stay, with no error: only their status is unknown. + assertEquals(myListings, state.listings) + assertNull(state.error) + } + + @Test + fun bookingsLoadingAgainAfterAFailedReload_showTheStatusesAgain() { + bookings.lenderLoadFailure = UnknownHostException("offline") + val viewModel = ToolboxViewModel(repository, bookings) + bookings.lenderLoadFailure = null + bookings.lenderBookings = listOf(drillToday) + + viewModel.loadListings() + + assertEquals( + ToolboxListingStatus.BookedToday, + viewModel.uiState.value.statusOf(myListings[0], today), + ) + } + + @Test + fun loadListings_reloadsTheBookings_soABookingForTodayShows() { + val viewModel = ToolboxViewModel(repository, bookings) + assertEquals( + ToolboxListingStatus.Available, + viewModel.uiState.value.statusOf(myListings[0], today), + ) + bookings.lenderBookings = listOf(drillToday) + + viewModel.loadListings() + + assertEquals(2, bookings.lenderLoadCount) + assertEquals( + ToolboxListingStatus.BookedToday, + viewModel.uiState.value.statusOf(myListings[0], today), + ) + } } diff --git a/rules-tests/firestore.test.js b/rules-tests/firestore.test.js index c96d88a9..69c83506 100644 --- a/rules-tests/firestore.test.js +++ b/rules-tests/firestore.test.js @@ -451,6 +451,19 @@ describe("listings", () => { await assertFails(getDocs(query(collection(verified(ALICE), "bookings"), where("listingId", "==", "l1")))); }); + // The Toolbox reads every booking of the lender's listings in one query (#196). + test("a verified lender can list the bookings of all their listings, and only theirs", async () => { + await seed("bookings/b1", booking()); + await seed("bookings/b2", booking({ listingId: "l2" })); + const allForLender = (db, lender) => + getDocs(query(collection(db, "bookings"), where("lenderUid", "==", lender))); + + const listed = await assertSucceeds(allForLender(verified(ALICE), ALICE)); + assert.deepEqual(listed.docs.map((d) => d.id).sort(), ["b1", "b2"]); + await assertFails(allForLender(verified(BOB), ALICE)); + await assertFails(allForLender(unverified(ALICE), ALICE)); + }); + test("renters and lenders can cancel requested or confirmed bookings", async () => { await seed("bookings/renter-requested", booking()); await seed("bookings/renter-confirmed", booking({ status: "CONFIRMED" }));