From b4e790406f1c1b0b510166df54aaea1bf4751178 Mon Sep 17 00:00:00 2001 From: peng-0110 Date: Thu, 19 Nov 2026 08:56:15 +0100 Subject: [PATCH 1/3] feat(booking): list the bookings of all of a lender's listings One query on lenderUid, which the rules already allow, so the Toolbox can show each listing's status without a query per listing. --- .../booking/model/BookingRepository.kt | 3 ++ .../model/FirebaseBookingRepository.kt | 17 +++++++++ .../booking/model/FakeBookingRepository.kt | 15 ++++++++ .../model/FirebaseBookingRepositoryTest.kt | 35 +++++++++++++++++++ rules-tests/firestore.test.js | 13 +++++++ 5 files changed, 83 insertions(+) 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 cdd91432..a0f0e114 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 @@ -16,6 +16,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 06d34210..103e59ea 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 @@ -69,6 +69,23 @@ class FirebaseBookingRepository( .map { it.toBooking() } } + override suspend fun getBookingsForLender(): List { + val uid = + auth.currentUser?.uid + ?: throw FirebaseFirestoreException( + "Sign in to read bookings", + FirebaseFirestoreException.Code.UNAUTHENTICATED, + ) + // 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 = auth.currentUser?.uid 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 d0af4d83..2cac1c3e 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 @@ -10,6 +10,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 @@ -21,6 +25,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 @@ -47,6 +55,13 @@ class FakeBookingRepository : BookingRepository { return listingBookings } + override suspend fun getBookingsForLender(): List { + lenderLoadCount++ + pendingLenderLoad?.await() + lenderLoadFailure?.let { throw it } + return lenderBookings + } + override suspend fun getBookingsForRenter(): List { loadCount++ pendingLoad?.await() 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 2209775d..af9ba263 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 @@ -38,6 +38,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() private val repository = FirebaseBookingRepository(firestore, auth) @@ -60,6 +61,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) } @@ -230,6 +232,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/rules-tests/firestore.test.js b/rules-tests/firestore.test.js index f6770d52..30e35b55 100644 --- a/rules-tests/firestore.test.js +++ b/rules-tests/firestore.test.js @@ -450,6 +450,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" })); From a7286aec740c28bef7d530b791122575d754081c Mon Sep 17 00:00:00 2001 From: peng-0110 Date: Thu, 19 Nov 2026 08:56:15 +0100 Subject: [PATCH 2/3] feat(toolbox): show whether each listing is available or booked today Every Toolbox row shows Paused, Booked today or Available, derived from the listing and its bookings. Lenders cannot approve requests yet, so a request that is not cancelled and covers today counts as booked. --- .../toolbox/model/ToolboxListingStatus.kt | 40 ++++++ .../polybazaar/toolbox/ui/ToolboxCard.kt | 81 ++++++++++-- .../toolbox/viewmodel/ToolboxViewModel.kt | 48 ++++++- .../polybazaar/ui/navigation/AppNavHost.kt | 4 +- app/src/main/res/values/strings.xml | 2 + .../toolbox/model/ToolboxListingStatusTest.kt | 105 ++++++++++++++++ .../polybazaar/toolbox/ui/ToolboxCardTest.kt | 110 +++++++++++++++- .../toolbox/viewmodel/ToolboxViewModelTest.kt | 119 +++++++++++++++--- 8 files changed, 472 insertions(+), 37 deletions(-) create mode 100644 app/src/main/java/com/android/polybazaar/toolbox/model/ToolboxListingStatus.kt create mode 100644 app/src/test/java/com/android/polybazaar/toolbox/model/ToolboxListingStatusTest.kt 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..93fe6e03 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 @@ -3,12 +3,18 @@ package com.android.polybazaar.toolbox.viewmodel 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 +30,39 @@ 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 + * or while they cannot be: the listings then show only whether they are paused. */ 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 +77,18 @@ 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 and + * bookings already shown are kept, so a reload while offline does not empty the Toolbox. Only a + * failure of the listings is shown: without the bookings, the listings are still worth showing. */ 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 +98,20 @@ class ToolboxViewModel(private val listingRepository: ListingRepository) : ViewM if (exception is CancellationException) throw exception _uiState.update { it.copy(error = exception.toAppError()) } } + bookings.await()?.let { loaded -> _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. */ + private suspend fun loadBookings(): List? = + try { + bookingRepository.getBookingsForLender() + } catch (exception: Exception) { + if (exception is CancellationException) throw exception + null + } } 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 0a4b88af..6d55efd2 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 @@ -564,7 +564,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 41b5a8d3..9c3e0817 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -133,6 +133,8 @@ Services You have no item listings. You have no service listings. + Available + Booked today Forgot password 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..bdd8a047 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,105 @@ 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())) + } + 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..9566fefb 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,79 @@ 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_keepsTheStatusesAlreadyShown() { + bookings.lenderBookings = listOf(drillToday) + val viewModel = ToolboxViewModel(repository, bookings) + bookings.lenderLoadFailure = UnknownHostException("offline") + + viewModel.loadListings() + + assertEquals(listOf(drillToday), viewModel.uiState.value.bookings) + } + + @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), + ) + } } From 49e1cdf80b1936d3bb89eaee6d4ffedd29bc532c Mon Sep 17 00:00:00 2001 From: peng-0110 Date: Thu, 19 Nov 2026 16:31:23 +0100 Subject: [PATCH 3/3] fix(toolbox): show no status after a failed bookings refresh A failed reload kept the bookings of the last load, so a listing could still show Available or Booked today after a booking changed, with no error to say it was out of date. The bookings are now dropped on failure, and the failure is logged. --- .../toolbox/viewmodel/ToolboxViewModel.kt | 24 ++++++++++---- .../polybazaar/toolbox/ui/ToolboxCardTest.kt | 19 ++++++++++++ .../toolbox/viewmodel/ToolboxViewModelTest.kt | 31 +++++++++++++++++-- 3 files changed, 66 insertions(+), 8 deletions(-) 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 93fe6e03..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,6 +1,7 @@ // 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 @@ -31,7 +32,8 @@ import kotlinx.coroutines.launch * @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 - * or while they cannot be: the listings then show only whether they are paused. + * 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(), @@ -78,9 +80,10 @@ class ToolboxViewModel( /** * 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 and - * bookings already shown are kept, so a reload while offline does not empty the Toolbox. Only a - * failure of the listings is shown: without the bookings, the listings are still worth showing. + * 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. @@ -98,7 +101,8 @@ class ToolboxViewModel( if (exception is CancellationException) throw exception _uiState.update { it.copy(error = exception.toAppError()) } } - bookings.await()?.let { loaded -> _uiState.update { it.copy(bookings = loaded) } } + 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) } @@ -106,12 +110,20 @@ class ToolboxViewModel( } } - /** The user's bookings as a lender, or null when they cannot be read. */ + /** + * 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/test/java/com/android/polybazaar/toolbox/ui/ToolboxCardTest.kt b/app/src/test/java/com/android/polybazaar/toolbox/ui/ToolboxCardTest.kt index bdd8a047..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 @@ -613,6 +613,25 @@ class ToolboxCardTest { 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 9566fefb..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 @@ -339,14 +339,41 @@ class ToolboxViewModelTest { } @Test - fun bookingsFailingOnAReload_keepsTheStatusesAlreadyShown() { + 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() - assertEquals(listOf(drillToday), viewModel.uiState.value.bookings) + 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