Add the Create and Update PaymentGateway actions

Author: joshheald

Yosemite/Yosemite/Actions/PaymentGatewayAction.swift

@@ -6,4 +6,12 @@ public enum PaymentGatewayAction: Action {
     /// Retrieves and stores all payment gateways for the provided `siteID`
     ///
     case synchronizePaymentGateways(siteID: Int64, onCompletion: (Result<Void, Error>) -> Void)
+
+    /// Updates a Payment Gateway for a site given its ID and returns the updated Payment Gateway if the request succeeds.
+    ///
+    /// - `paymentGateway`: the Payment Gateway to be updated.
+    /// - `onCompletion`: invoked when the update finishes.
+    ///
+    case updatePaymentGateway(_ paymentGateway: PaymentGateway,
+                              onCompletion: (Result<PaymentGateway, Error>) -> Void)
 }

Yosemite/Yosemite/Stores/PaymentGatewayStore.swift

@@ -36,13 +36,14 @@ public final class PaymentGatewayStore: Store {
         switch action {
         case let .synchronizePaymentGateways(siteID, onCompletion):
             synchronizePaymentGateways(siteID: siteID, onCompletion: onCompletion)
+        case let .updatePaymentGateway(paymentGateway, onCompletion):
+            updatePaymentGateway(paymentGateway, onCompletion: onCompletion)
         }
     }
 }
 
-// MARK: Storage Methods
+// MARK: Payment Gateway store services
 private extension PaymentGatewayStore {
-
     /// Loads and stores all payment gateways for the provided `siteID`
     func synchronizePaymentGateways(siteID: Int64, onCompletion: @escaping (Result<Void, Error>) -> Void) {
         remote.loadAllPaymentGateways(siteID: siteID) { [weak self] result in
@@ -59,6 +60,31 @@ private extension PaymentGatewayStore {
         }
     }
 
+    /// Updates a paymentGateway given its details.
+    /// After the API request succeeds, the stored paymentGateway should be updated accordingly.
+    /// - Parameters:
+    ///   - paymentGateway: The paymentGateway to be updated
+    ///   - onCompletion: Closure to call after update is complete. Called on the main thread.
+    ///
+    func updatePaymentGateway(_ paymentGateway: PaymentGateway,
+                      siteTimezone: TimeZone? = nil,
+                      onCompletion: @escaping (Result<PaymentGateway, Error>) -> Void) {
+        remote.updatePaymentGateway(paymentGateway) { [weak self] result in
+            guard let self = self else { return }
+            switch result {
+            case .failure(let error):
+                onCompletion(.failure(error))
+            case .success(let paymentGateway):
+                self.upsertPaymentGatewaysInBackground(siteID: paymentGateway.siteID, paymentGateways: [paymentGateway]) {
+                    onCompletion(.success(paymentGateway))
+                }
+            }
+        }
+    }
+}
+
+// MARK: Storage Methods
+private extension PaymentGatewayStore {
     /// Updates (OR Inserts) the specified ReadOnly Payment Gateways Entities
     /// *in a background thread*. `onCompletion` will be called on the main thread!
     ///

Yosemite/YosemiteTests/Stores/PaymentGatewayStoreTests.swift

@@ -27,28 +27,38 @@ final class PaymentGatewayStoreTests: XCTestCase {
         return storageManager.viewStorage
     }
 
+    /// Convenience: returns the number of stored payment gateways
+    ///
+    private var storedPaymentGatewaysCount: Int {
+        return viewStorage.countObjects(ofType: StoragePaymentGateway.self)
+    }
+
     /// Dummy Site ID
     ///
     private let sampleSiteID: Int64 = 123
 
+    /// Store
+    ///
+    private var store: PaymentGatewayStore!
+
     override func setUp() {
         super.setUp()
         dispatcher = Dispatcher()
         storageManager = MockStorageManager()
         network = MockNetwork(useResponseQueue: true)
+        store = PaymentGatewayStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
     }
 
     func test_synchronize_gateways_correctly_persists_payment_gateways() throws {
         // Given
-        let store = PaymentGatewayStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
         network.simulateResponse(requestUrlSuffix: "payment_gateways", filename: "payment-gateway-list")
 
         // When
         let result: Result<Void, Error> = waitFor { promise in
             let action = PaymentGatewayAction.synchronizePaymentGateways(siteID: self.sampleSiteID) { result in
                 promise(result)
             }
-            store.onAction(action)
+            self.store.onAction(action)
         }
 
         // Then
@@ -61,7 +71,6 @@ final class PaymentGatewayStoreTests: XCTestCase {
 
     func test_synchronize_gateways_correctly_deletes_stale_payment_gateways() throws {
         // Given
-        let store = PaymentGatewayStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
         network.simulateResponse(requestUrlSuffix: "payment_gateways", filename: "payment-gateway-list")
         network.simulateResponse(requestUrlSuffix: "payment_gateways", filename: "payment-gateway-list-half")
 
@@ -73,7 +82,7 @@ final class PaymentGatewayStoreTests: XCTestCase {
             let secondSync = PaymentGatewayAction.synchronizePaymentGateways(siteID: self.sampleSiteID) { result in
                 promise(result)
             }
-            store.onAction(secondSync)
+            self.store.onAction(secondSync)
         }
 
         // Then
@@ -83,4 +92,73 @@ final class PaymentGatewayStoreTests: XCTestCase {
         XCTAssertNil(viewStorage.loadPaymentGateway(siteID: sampleSiteID, gatewayID: "paypal"))
         XCTAssertNil(viewStorage.loadPaymentGateway(siteID: sampleSiteID, gatewayID: "cod"))
     }
+
+    func test_updatePaymentGateway_returns_network_error_on_failure() {
+        // Given
+        let samplePaymentGatewayID = "cod"
+        let samplePaymentGateway = PaymentGateway.fake().copy(siteID: sampleSiteID,
+                                                              gatewayID: samplePaymentGatewayID,
+                                                              title: "Failing gateway",
+                                                              enabled: false)
+        storePaymentGateway(samplePaymentGateway, for: sampleSiteID)
+        assertEqual(1, storedPaymentGatewaysCount)
+
+        let expectedError = NetworkError.unacceptableStatusCode(statusCode: 500)
+        network.simulateError(requestUrlSuffix: "payment_gateways/\(samplePaymentGatewayID)", error: expectedError)
+
+        // When
+        let updatedPaymentGateway = samplePaymentGateway.copy(title: "Cash on delivery")
+        let result: Result<Networking.PaymentGateway, Error> = waitFor { promise in
+            let action = PaymentGatewayAction.updatePaymentGateway(updatedPaymentGateway) { result in
+                promise(result)
+            }
+            self.store.onAction(action)
+        }
+
+        // Then
+        XCTAssertEqual(result.failure as? NetworkError, expectedError)
+        assertEqual(1, storedPaymentGatewaysCount)
+        assertEqual("Failing gateway", viewStorage.loadPaymentGateway(siteID: sampleSiteID, gatewayID: samplePaymentGatewayID)?.title)
+    }
+
+    func test_updatePaymentGateway_updates_stored_paymentGateway_upon_success() throws {
+        // Given
+        let samplePaymentGatewayID = "cod"
+        let samplePaymentGateway = PaymentGateway.fake().copy(siteID: sampleSiteID,
+                                                              gatewayID: samplePaymentGatewayID,
+                                                              title: "Old title",
+                                                              enabled: false)
+
+        storePaymentGateway(samplePaymentGateway, for: sampleSiteID)
+        assertEqual(1, storedPaymentGatewaysCount)
+
+        network.simulateResponse(requestUrlSuffix: "payment_gateways/\(samplePaymentGatewayID)", filename: "payment-gateway-cod")
+
+        // When
+        let updatedPaymentGateway = samplePaymentGateway.copy(enabled: true)
+        let result: Result<Networking.PaymentGateway, Error> = waitFor { promise in
+            let action: PaymentGatewayAction
+            action = .updatePaymentGateway(updatedPaymentGateway) { result in
+                promise(result)
+            }
+            self.store.onAction(action)
+        }
+
+        // Then
+        XCTAssertTrue(result.isSuccess)
+
+        let storedPaymentGateway = try XCTUnwrap(viewStorage.loadPaymentGateway(siteID: sampleSiteID, gatewayID: samplePaymentGatewayID))
+        assertEqual("Cash on delivery", storedPaymentGateway.title)
+        XCTAssertTrue(storedPaymentGateway.enabled)
+    }
+}
+
+private extension PaymentGatewayStoreTests {
+    @discardableResult
+    func storePaymentGateway(_ paymentGateway: Networking.PaymentGateway, for siteID: Int64) -> Storage.PaymentGateway {
+        let storedPaymentGateway = viewStorage.insertNewObject(ofType: PaymentGateway.self)
+        storedPaymentGateway.update(with: paymentGateway)
+        storedPaymentGateway.siteID = siteID
+        return storedPaymentGateway
+    }
 }