Add new action to check if store has bookings

Author: itsmeichigo

Modules/Sources/Yosemite/Actions/BookingAction.swift

@@ -14,4 +14,10 @@ public enum BookingAction: Action {
                              pageNumber: Int,
                              pageSize: Int = BookingsRemote.Default.pageSize,
                              onCompletion: (Result<Bool, Error>) -> Void)
+
+    /// Checks if the store already has any bookings.
+    /// Returns `false` if the store has no bookings.
+    ///
+    case checkIfStoreHasBookings(siteID: Int64,
+                                 onCompletion: (Result<Bool, Error>) -> Void)
 }

Modules/Sources/Yosemite/Stores/BookingStore.swift

@@ -37,6 +37,8 @@ public class BookingStore: Store {
         switch action {
         case let .synchronizeBookings(siteID, pageNumber, pageSize, onCompletion):
             synchronizeBookings(siteID: siteID, pageNumber: pageNumber, pageSize: pageSize, onCompletion: onCompletion)
+        case let .checkIfStoreHasBookings(siteID, onCompletion):
+            checkIfStoreHasBookings(siteID: siteID, onCompletion: onCompletion)
         }
     }
 }
@@ -65,6 +67,31 @@ private extension BookingStore {
             }
         }
     }
+
+    /// Checks if the store already has any bookings.
+    /// Returns `false` if the store has no bookings.
+    ///
+    func checkIfStoreHasBookings(siteID: Int64, onCompletion: @escaping (Result<Bool, Error>) -> Void) {
+        let derivedStorage = storageManager.viewStorage
+        let hasLocalBookings = derivedStorage.countObjects(ofType: StorageBooking.self, matching: NSPredicate(format: "siteID == %lld", siteID)) > 0
+
+        if hasLocalBookings {
+            onCompletion(.success(true))
+            return
+        }
+
+        Task { @MainActor in
+            do {
+                let bookings = try await remote.loadAllBookings(for: siteID,
+                                                                pageNumber: 1,
+                                                                pageSize: 1)
+                let hasRemoteBookings = !bookings.isEmpty
+                onCompletion(.success(hasRemoteBookings))
+            } catch {
+                onCompletion(.failure(error))
+            }
+        }
+    }
 }
 
 

Modules/Tests/YosemiteTests/Stores/BookingStoreTests.swift

@@ -206,6 +206,103 @@ struct BookingStoreTests {
         #expect(result.isSuccess)
         #expect(storedBookingCount == 2)
     }
+
+    // MARK: - checkIfStoreHasBookings
+
+    @Test func checkIfStoreHasBookings_returns_true_when_bookings_exist_locally() async throws {
+        // Given
+        let booking = Booking.fake().copy(siteID: sampleSiteID, bookingID: 123)
+        storeBooking(booking)
+        #expect(storedBookingCount == 1)
+
+        let store = BookingStore(dispatcher: Dispatcher(),
+                                 storageManager: storageManager,
+                                 network: network,
+                                 remote: remote)
+
+        // When
+        let result = await withCheckedContinuation { continuation in
+            store.onAction(BookingAction.checkIfStoreHasBookings(siteID: sampleSiteID,
+                                                                onCompletion: { result in
+                continuation.resume(returning: result)
+            }))
+        }
+
+        // Then
+        let hasBookings = try result.get()
+        #expect(hasBookings == true)
+    }
+
+    @Test func checkIfStoreHasBookings_returns_true_when_no_local_bookings_but_remote_has_bookings() async throws {
+        // Given
+        #expect(storedBookingCount == 0)
+        let remoteBooking = Booking.fake()
+        remote.whenLoadingAllBookings(thenReturn: .success([remoteBooking]))
+
+        let store = BookingStore(dispatcher: Dispatcher(),
+                                 storageManager: storageManager,
+                                 network: network,
+                                 remote: remote)
+
+        // When
+        let result = await withCheckedContinuation { continuation in
+            store.onAction(BookingAction.checkIfStoreHasBookings(siteID: sampleSiteID,
+                                                                onCompletion: { result in
+                continuation.resume(returning: result)
+            }))
+        }
+
+        // Then
+        let hasBookings = try result.get()
+        #expect(hasBookings == true)
+    }
+
+    @Test func checkIfStoreHasBookings_returns_false_when_no_bookings_exist_locally_or_remotely() async throws {
+        // Given
+        #expect(storedBookingCount == 0)
+        remote.whenLoadingAllBookings(thenReturn: .success([]))
+
+        let store = BookingStore(dispatcher: Dispatcher(),
+                                 storageManager: storageManager,
+                                 network: network,
+                                 remote: remote)
+
+        // When
+        let result = await withCheckedContinuation { continuation in
+            store.onAction(BookingAction.checkIfStoreHasBookings(siteID: sampleSiteID,
+                                                                onCompletion: { result in
+                continuation.resume(returning: result)
+            }))
+        }
+
+        // Then
+        let hasBookings = try result.get()
+        #expect(hasBookings == false)
+    }
+
+    @Test func checkIfStoreHasBookings_returns_error_on_remote_failure() async throws {
+        // Given
+        #expect(storedBookingCount == 0)
+        remote.whenLoadingAllBookings(thenReturn: .failure(NetworkError.timeout()))
+
+        let store = BookingStore(dispatcher: Dispatcher(),
+                                 storageManager: storageManager,
+                                 network: network,
+                                 remote: remote)
+
+        // When
+        let result = await withCheckedContinuation { continuation in
+            store.onAction(BookingAction.checkIfStoreHasBookings(siteID: sampleSiteID,
+                                                                onCompletion: { result in
+                continuation.resume(returning: result)
+            }))
+        }
+
+        // Then
+        #expect(result.isFailure)
+        let error = result.failure as? NetworkError
+        #expect(error == .timeout())
+    }
 }
 
 private extension BookingStoreTests {