Dynamic Dashboard: Update Yosemite with stock report fetching

Networking/Networking/Remote/ProductsRemote.swift

@@ -51,7 +51,7 @@ public protocol ProductsRemoteProtocol {
     func loadNumberOfProducts(siteID: Int64) async throws -> Int64
 
     func loadStock(for siteID: Int64,
-                   with stockStatus: ProductStockStatus,
+                   with stockType: String,
                    pageNumber: Int,
                    pageSize: Int,
                    orderBy: ProductsRemote.OrderKey,
@@ -414,14 +414,14 @@ public final class ProductsRemote: Remote, ProductsRemoteProtocol {
     }
 
     public func loadStock(for siteID: Int64,
-                          with stockStatus: ProductStockStatus,
+                          with stockType: String,
                           pageNumber: Int,
                           pageSize: Int,
                           orderBy: ProductsRemote.OrderKey,
                           order: ProductsRemote.Order) async throws -> [ProductStock] {
         let path = Path.stockReports
         let parameters: [String: Any] = [
-            ParameterKey.type: stockStatus.rawValue,
+            ParameterKey.type: stockType,
             ParameterKey.page: String(pageNumber),
             ParameterKey.perPage: String(pageSize),
             ParameterKey.order: order,

Networking/NetworkingTests/Remote/ProductsRemoteTests.swift

@@ -737,7 +737,7 @@ final class ProductsRemoteTests: XCTestCase {
         network.simulateResponse(requestUrlSuffix: "reports/stock", filename: "product-stock")
 
         // When
-        let stock = try await remote.loadStock(for: 8, with: .outOfStock, pageNumber: 1, pageSize: 3, orderBy: .name, order: .descending)
+        let stock = try await remote.loadStock(for: 8, with: "outOfStock", pageNumber: 1, pageSize: 3, orderBy: .name, order: .descending)
 
         // Then
         XCTAssertEqual(stock.count, 1)
@@ -756,7 +756,7 @@ final class ProductsRemoteTests: XCTestCase {
         let remote = ProductsRemote(network: network)
 
         // When
-        await assertThrowsError({ _ = try await remote.loadStock(for: 8, with: .outOfStock, pageNumber: 1, pageSize: 3, orderBy: .name, order: .descending) },
+        await assertThrowsError({ _ = try await remote.loadStock(for: 8, with: "outofstock", pageNumber: 1, pageSize: 3, orderBy: .name, order: .descending) },
                                 errorAssert: {
             // Then
             $0 as? NetworkError == .notFound()

Yosemite/Yosemite/Actions/ProductAction.swift

@@ -189,4 +189,21 @@ public enum ProductAction: Action {
                            categories: [ProductCategory],
                            tags: [ProductTag],
                            completion: (Result<AIProduct, Error>) -> Void)
+
+    /// Fetches stock based on the given status for a site
+    /// - Parameter siteID: Site ID to fetch stock for.
+    /// - Parameter stockType: Raw type of stock to query.
+    /// - Parameter pageNumber: The index of the content page to query.
+    /// - Parameter pageSize: The max amount of items to return per page.
+    /// - Parameter orderBy: The key to sort returned items.
+    /// - Parameter order: Whether to sort returned items ASC or DESC.
+    /// - Parameter completion: Closure to trigger when fetching completes.
+    ///
+    case fetchStockReport(siteID: Int64,
+                          stockType: String,
+                          pageNumber: Int,
+                          pageSize: Int,
+                          orderBy: ProductsRemote.OrderKey,
+                          order: ProductsRemote.Order,
+                          completion: (Result<[ProductStock], Error>) -> Void)
 }

Yosemite/Yosemite/Stores/ProductStore.swift

@@ -156,6 +156,14 @@ public class ProductStore: Store {
                               categories: categories,
                               tags: tags,
                               completion: completion)
+        case let .fetchStockReport(siteID, stockType, pageNumber, pageSize, orderBy, order, completion):
+            fetchStockReport(siteID: siteID,
+                             stockType: stockType,
+                             pageNumber: pageNumber,
+                             pageSize: pageSize,
+                             orderBy: orderBy,
+                             order: order,
+                             completion: completion)
         }
     }
 }
@@ -731,6 +739,28 @@ private extension ProductStore {
             completion(result)
         }
     }
+
+    func fetchStockReport(siteID: Int64,
+                          stockType: String,
+                          pageNumber: Int,
+                          pageSize: Int,
+                          orderBy: ProductsRemote.OrderKey,
+                          order: ProductsRemote.Order,
+                          completion: @escaping (Result<[ProductStock], Error>) -> Void) {
+        Task { @MainActor in
+            do {
+                let stock = try await remote.loadStock(for: siteID,
+                                                       with: stockType,
+                                                       pageNumber: pageNumber,
+                                                       pageSize: pageSize,
+                                                       orderBy: orderBy,
+                                                       order: order)
+                completion(.success(stock))
+            } catch {
+                completion(.failure(error))
+            }
+        }
+    }
 }
 
 

Yosemite/YosemiteTests/Mocks/Networking/Remote/MockProductsRemote.swift

@@ -43,6 +43,8 @@ final class MockProductsRemote {
 
     private var searchProductsBySKUResultsBySKU = [String: Result<[Product], Error>]()
 
+    private var fetchedStockResult: Result<[ProductStock], Error>?
+
     /// The number of times that `loadProduct()` was invoked.
     private(set) var invocationCountOfLoadProduct: Int = 0
 
@@ -102,6 +104,10 @@ final class MockProductsRemote {
     func whenSearchingProductsBySKU(sku: String, thenReturn result: Result<[Product], Error>) {
         searchProductsBySKUResultsBySKU[sku] = result
     }
+
+    func whenFetchingStock(thenReturn result: Result<[ProductStock], Error>) {
+        fetchedStockResult = result
+    }
 }
 
 // MARK: - ProductsEndpointsProviding
@@ -270,12 +276,19 @@ extension MockProductsRemote: ProductsRemoteProtocol {
     }
 
     func loadStock(for siteID: Int64,
-                   with stockStatus: ProductStockStatus,
+                   with stockType: String,
                    pageNumber: Int,
                    pageSize: Int,
                    orderBy: ProductsRemote.OrderKey,
                    order: ProductsRemote.Order) async throws -> [ProductStock] {
-        // no-op
-        return []
+        guard let result = fetchedStockResult else {
+            throw NetworkError.notFound()
+        }
+        switch result {
+        case let .success(stock):
+            return stock
+        case let .failure(error):
+            throw error
+        }
     }
 }

Yosemite/YosemiteTests/Stores/ProductStoreTests.swift

@@ -2831,6 +2831,70 @@ final class ProductStoreTests: XCTestCase {
         XCTAssertTrue(result.isFailure)
         XCTAssertEqual(result.failure as? NetworkError, .timeout())
     }
+
+    // MARK: - Fetch stock
+
+    func test_fetchStock_returns_stock_on_success() throws {
+        // Given
+        let stock = ProductStock.fake().copy(siteID: sampleSiteID,
+                                             productID: 13,
+                                             name: "Steamed bun",
+                                             sku: "1353",
+                                             manageStock: true,
+                                             stockQuantity: 4,
+                                             stockStatusKey: "instock")
+        let mockRemote = MockProductsRemote()
+        mockRemote.whenFetchingStock(thenReturn: .success([stock]))
+        let productStore = ProductStore(dispatcher: dispatcher,
+                                        storageManager: storageManager,
+                                        network: network,
+                                        remote: mockRemote)
+
+        // When
+        let result = waitFor { promise in
+            productStore.onAction(ProductAction.fetchStockReport(siteID: self.sampleSiteID,
+                                                                 stockType: "lowstock",
+                                                                 pageNumber: 1,
+                                                                 pageSize: 3,
+                                                                 orderBy: .date,
+                                                                 order: .descending,
+                                                                 completion: { result in
+                promise(result)
+            }))
+        }
+
+        // Then
+        let receivedStock = try XCTUnwrap(result.get())
+        XCTAssertEqual(receivedStock.count, 1)
+        XCTAssertEqual(receivedStock.first, stock)
+    }
+
+    func test_fetchStock_returns_error_on_failure() throws {
+        // Given
+        let mockRemote = MockProductsRemote()
+        mockRemote.whenFetchingStock(thenReturn: .failure(NetworkError.timeout()))
+        let productStore = ProductStore(dispatcher: dispatcher,
+                                        storageManager: storageManager,
+                                        network: network,
+                                        remote: mockRemote)
+
+        // When
+        let result = waitFor { promise in
+            productStore.onAction(ProductAction.fetchStockReport(siteID: self.sampleSiteID,
+                                                                 stockType: "lowstock",
+                                                                 pageNumber: 1,
+                                                                 pageSize: 3,
+                                                                 orderBy: .date,
+                                                                 order: .descending,
+                                                                 completion: { result in
+                promise(result)
+            }))
+        }
+
+        // Then
+        XCTAssertTrue(result.isFailure)
+        XCTAssertEqual(result.failure as? NetworkError, .timeout())
+    }
 }
 
 // MARK: - Private Helpers