Added some persistence unit tests for OrderStatusStoreTests

Author: bummytime

Yosemite/Yosemite/Stores/OrderStatusStore.swift

@@ -52,11 +52,9 @@ private extension OrderStatusStore {
                 return
             }
 
-            self?.upsertStoredStatusesInBackground(siteID: siteID,
-                                                 readOnlyOrderStatuses: orderStatuses,
-                                                 onCompletion: {
+            self?.upsertStatusesInBackground(siteID: siteID, readOnlyOrderStatuses: orderStatuses) {
                 onCompletion(orderStatuses, nil)
-            })
+            }
         }
     }
 
@@ -80,9 +78,7 @@ extension OrderStatusStore {
     /// Updates (OR Inserts) the specified ReadOnly Order Status Entities
     /// *in a background thread*. onCompletion will be called on the main thread!
     ///
-    func upsertStoredStatusesInBackground(siteID: Int,
-                                                  readOnlyOrderStatuses: [Networking.OrderStatus],
-                                                  onCompletion: @escaping () -> Void) {
+    func upsertStatusesInBackground(siteID: Int, readOnlyOrderStatuses: [Networking.OrderStatus], onCompletion: @escaping () -> Void) {
         let derivedStorage = sharedDerivedStorage
         derivedStorage.perform {
             for readOnlyItem in readOnlyOrderStatuses {

Yosemite/YosemiteTests/Stores/OrderStatusStoreTests.swift

@@ -92,6 +92,103 @@ class OrderStatusStoreTests: XCTestCase {
         orderStatusStore.onAction(action)
         wait(for: [expectation], timeout: Constants.expectationTimeout)
     }
+
+    /// Verifies that OrderStatusAction.retrieveOrderStatuses effectively persists any retrieved statuses.
+    ///
+    func testRetrieveOrderStatusesEffectivelyPersistsRetrievedOrderStatuses() {
+        let expectation = self.expectation(description: "Retrieving order statii shall persist order statii")
+        let orderStatusStore = OrderStatusStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
+
+        network.simulateResponse(requestUrlSuffix: "reports/orders/totals", filename: "report-orders")
+        let action = OrderStatusAction.retrieveOrderStatuses(siteID: sampleSiteID) { (statuses, error) in
+            XCTAssertNil(error)
+
+            XCTAssertEqual(self.viewStorage.countObjects(ofType: Storage.OrderStatus.self), 9)
+            let storageOrderStatuses = self.viewStorage.loadOrderStatuses(siteID: self.sampleSiteID)
+            XCTAssertNotNil(storageOrderStatuses)
+            let readOnlyList = storageOrderStatuses?.map({ $0.toReadOnly() })
+            XCTAssertEqual(readOnlyList?.sorted(), self.sampleOrderStatuses().sorted())
+
+            expectation.fulfill()
+        }
+
+        orderStatusStore.onAction(action)
+        wait(for: [expectation], timeout: Constants.expectationTimeout)
+    }
+
+    /// Verifies that `upsertStoredStatusesInBackground` does not produce duplicate entries.
+    ///
+    func testUpdateRetrieveOrderStatusesEffectivelyUpdatesPreexistantOrderStatuses() {
+        let orderStatusStore = OrderStatusStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
+        XCTAssertEqual(self.viewStorage.countObjects(ofType: Storage.OrderStatus.self), 0)
+
+        let group = DispatchGroup()
+
+        group.enter()
+        orderStatusStore.upsertStatusesInBackground(siteID: sampleSiteID, readOnlyOrderStatuses: sampleOrderStatuses()) {
+            XCTAssertTrue(Thread.isMainThread)
+            group.leave()
+        }
+
+        group.enter()
+        orderStatusStore.upsertStatusesInBackground(siteID: sampleSiteID, readOnlyOrderStatuses: sampleOrderStatusesMutated()) {
+            XCTAssertTrue(Thread.isMainThread)
+            group.leave()
+        }
+
+        let expectation = self.expectation(description: "Update existing stored order statii")
+        group.notify(queue: .main) {
+            let originalStatuses = self.sampleOrderStatuses()
+            let expectedStatuses = self.sampleOrderStatusesMutated()
+            let storageStatuses = self.viewStorage.loadOrderStatuses(siteID: self.sampleSiteID)
+            let readOnlyList = storageStatuses?.map({ $0.toReadOnly() })
+
+            XCTAssertNotEqual(readOnlyList, originalStatuses)
+            XCTAssertEqual(readOnlyList?.sorted(), expectedStatuses.sorted())
+            XCTAssertEqual(self.viewStorage.countObjects(ofType: Storage.OrderStatus.self), expectedStatuses.count)
+
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: Constants.expectationTimeout)
+    }
+
+    /// Verifies that `upsertStoredStatusesInBackground` removes deleted entities.
+    ///
+    func testUpdateRetrieveShipmentTrackingListEffectivelyRemovesDeletedShipmentTrackingData() {
+        let orderStatusStore = OrderStatusStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
+        XCTAssertEqual(self.viewStorage.countObjects(ofType: Storage.OrderStatus.self), 0)
+
+        let group = DispatchGroup()
+
+        group.enter()
+        orderStatusStore.upsertStatusesInBackground(siteID: sampleSiteID, readOnlyOrderStatuses: sampleOrderStatuses()) {
+            XCTAssertTrue(Thread.isMainThread)
+            group.leave()
+        }
+
+        group.enter()
+        orderStatusStore.upsertStatusesInBackground(siteID: sampleSiteID, readOnlyOrderStatuses: sampleOrderStatusesDeleted()) {
+            XCTAssertTrue(Thread.isMainThread)
+            group.leave()
+        }
+
+        let expectation = self.expectation(description: "Delete existing stored order statii")
+        group.notify(queue: .main) {
+            let originalStatuses = self.sampleOrderStatuses()
+            let expectedStatuses = self.sampleOrderStatusesDeleted()
+            let storageStatuses = self.viewStorage.loadOrderStatuses(siteID: self.sampleSiteID)
+            let readOnlyList = storageStatuses?.map({ $0.toReadOnly() })
+
+            XCTAssertNotEqual(readOnlyList, originalStatuses)
+            XCTAssertEqual(readOnlyList?.sorted(), expectedStatuses.sorted())
+            XCTAssertEqual(self.viewStorage.countObjects(ofType: Storage.OrderStatus.self), expectedStatuses.count)
+
+            expectation.fulfill()
+        }
+
+        wait(for: [expectation], timeout: Constants.expectationTimeout)
+    }
 }
 
 
@@ -115,13 +212,23 @@ private extension OrderStatusStoreTests {
 
     func sampleOrderStatusesMutated() -> [Networking.OrderStatus] {
         return [
-            OrderStatus(name: "Pending payment", siteID: sampleSiteID, slug: "pending", total: 1123),
-            OrderStatus(name: "Processing", siteID: sampleSiteID, slug: "processing", total: 14),
-            OrderStatus(name: "On hold", siteID: sampleSiteID, slug: "on-hold", total: 15),
-            OrderStatus(name: "Completed", siteID: sampleSiteID, slug: "completed", total: 16),
-            OrderStatus(name: "Refunded", siteID: sampleSiteID, slug: "refunded", total: 18),
-            OrderStatus(name: "Failed", siteID: sampleSiteID, slug: "failed", total: 19),
-            OrderStatus(name: "Pre ordered", siteID: sampleSiteID, slug: "pre-ordered", total: 11)
+            OrderStatus(name: "Pending payment", siteID: sampleSiteID, slug: "pending", total: 123),
+            OrderStatus(name: "Processing", siteID: sampleSiteID, slug: "processing", total: 4),
+            OrderStatus(name: "On hold", siteID: sampleSiteID, slug: "on-hold", total: 5),
+            OrderStatus(name: "Test Status", siteID: sampleSiteID, slug: "test-status", total: 234),
+            OrderStatus(name: "Cancelled", siteID: sampleSiteID, slug: "cancelled", total: 7),
+            OrderStatus(name: "Refunded", siteID: sampleSiteID, slug: "refunded", total: 8),
+            OrderStatus(name: "Failed", siteID: sampleSiteID, slug: "failed", total: 9),
+            OrderStatus(name: "CIA Investigation", siteID: sampleSiteID, slug: "cia-investigation", total: 10),
+            OrderStatus(name: "Pre ordered", siteID: sampleSiteID, slug: "pre-ordered", total: 1)
+        ]
+    }
+
+    func sampleOrderStatusesDeleted() -> [Networking.OrderStatus] {
+        return [
+            OrderStatus(name: "Pending payment", siteID: sampleSiteID, slug: "pending", total: 123),
+            OrderStatus(name: "Processing", siteID: sampleSiteID, slug: "processing", total: 4),
+            OrderStatus(name: "Pre ordered", siteID: sampleSiteID, slug: "pre-ordered", total: 1)
         ]
     }
 }