Add Yosemite function to update yosemite order

Author: Ecarrion

Networking/Networking/Remote/OrdersRemote.swift

@@ -184,7 +184,7 @@ public class OrdersRemote: Remote {
                         let billingAddressEncoded = try order.billingAddress?.toDictionary()
                         params[Order.CodingKeys.billingAddress.rawValue] = billingAddressEncoded
                     case .fees:
-                        let feesEncoded = try order.fees.toDictionary()
+                        let feesEncoded = try order.fees.map { try $0.toDictionary() }
                         params[Order.CodingKeys.feeLines.rawValue] = feesEncoded
                     }
                 }

Networking/NetworkingTests/Remote/OrdersRemoteTests.swift

@@ -252,16 +252,17 @@ final class OrdersRemoteTests: XCTestCase {
     func test_create_order_properly_encodes_fee_lines() throws {
         // Given
         let remote = OrdersRemote(network: network)
-        let fee = OrderFeeLine(feeID: 0, name: "Line", taxClass: "", taxStatus: .none, total: "12.34", totalTax: "", taxes: [], attributes: [])
+        let fee = OrderFeeLine(feeID: 333, name: "Line", taxClass: "", taxStatus: .none, total: "12.34", totalTax: "", taxes: [], attributes: [])
         let order = Order.fake().copy(fees: [fee])
 
         // When
         remote.createOrder(siteID: 123, order: order, fields: [.feeLines]) { result in }
 
         // Then
         let request = try XCTUnwrap(network.requestsForResponseData.last as? JetpackRequest)
-        let received = try XCTUnwrap(request.parameters["fee_lines"] as? [[String: String]]).first
-        let expected = [
+        let received = try XCTUnwrap(request.parameters["fee_lines"] as? [[String: AnyHashable]]).first
+        let expected: [String: AnyHashable] = [
+            "id": fee.feeID,
             "name": fee.name,
             "tax_status": fee.taxStatus.rawValue,
             "tax_class": fee.taxClass,

Yosemite/Yosemite/Actions/OrderAction.swift

@@ -65,11 +65,22 @@ public enum OrderAction: Action {
     ///
     case updateOrder(siteID: Int64, order: Order, fields: [OrderUpdateField], onCompletion: (Result<Order, Error>) -> Void)
 
-    /// Creates a simple payments order with a specific amount value and no tax.
+    /// Creates a simple payments order with a specific amount value and  tax status.
     ///
     case createSimplePaymentsOrder(siteID: Int64, amount: String, taxable: Bool, onCompletion: (Result<Order, Error>) -> Void)
 
     /// Creates a manual order with the provided order details.
     ///
     case createOrder(siteID: Int64, order: Order, onCompletion: (Result<Order, Error>) -> Void)
+
+    /// Updates a simple payments order with the specified values.
+    ///
+    case updateSimplePaymentsOrder(siteID: Int64,
+                                   orderID: Int64,
+                                   feeID: Int64,
+                                   amount: String,
+                                   taxable: Bool,
+                                   orderNote: String?,
+                                   email: String?,
+                                   onCompletion: (Result<Order, Error>) -> Void)
 }

Yosemite/Yosemite/Stores/OrderStore.swift

@@ -66,6 +66,16 @@ public class OrderStore: Store {
             createSimplePaymentsOrder(siteID: siteID, amount: amount, taxable: taxable, onCompletion: onCompletion)
         case let .createOrder(siteID, order, onCompletion):
             createOrder(siteID: siteID, order: order, onCompletion: onCompletion)
+
+        case let .updateSimplePaymentsOrder(siteID, orderID, feeID, amount, taxable, orderNote, email, onCompletion):
+            updateSimplePaymentsOrder(siteID: siteID,
+                                      orderID: orderID,
+                                      feeID: feeID,
+                                      amount: amount,
+                                      taxable: taxable,
+                                      orderNote: orderNote,
+                                      email: email,
+                                      onCompletion: onCompletion)
         }
     }
 }
@@ -267,6 +277,41 @@ private extension OrderStore {
         }
     }
 
+    /// Updates a simple payment order with the specified values.
+    ///
+    func updateSimplePaymentsOrder(siteID: Int64,
+                                   orderID: Int64,
+                                   feeID: Int64,
+                                   amount: String,
+                                   taxable: Bool,
+                                   orderNote: String?,
+                                   email: String?,
+                                   onCompletion: @escaping (Result<Order, Error>) -> Void) {
+
+        // Recreate the original order
+        let originalOrder = OrderFactory.simplePaymentsOrder(amount: amount, taxable: taxable)
+
+        // Create updated fields
+        let newFee = OrderFactory.simplePaymentFee(feeID: feeID, amount: amount, taxable: taxable)
+        let newBillingAddress = Address(firstName: "",
+                                        lastName: "",
+                                        company: nil,
+                                        address1: "",
+                                        address2: nil,
+                                        city: "",
+                                        state: "",
+                                        postcode: "",
+                                        country: "",
+                                        phone: nil,
+                                        email: email)
+
+        // Set new fields
+        let updatedOrder = originalOrder.copy(orderID: orderID, customerNote: orderNote, billingAddress: newBillingAddress, fees: [newFee])
+        let updateFields: [OrderUpdateField] = [.customerNote, .billingAddress, .fees]
+
+        updateOrder(siteID: siteID, order: updatedOrder, fields: updateFields, onCompletion: onCompletion)
+    }
+
     /// Creates a manual order with the provided order details.
     ///
     func createOrder(siteID: Int64, order: Order, onCompletion: @escaping (Result<Order, Error>) -> Void) {

Yosemite/YosemiteTests/Stores/OrderStoreTests.swift

@@ -710,6 +710,56 @@ final class OrderStoreTests: XCTestCase {
         // Then
         XCTAssertNotNil(storedOrder)
     }
+
+    func test_update_simple_payments_order_sends_correct_values() throws {
+        // Given
+        let feeID: Int64 = 1234
+        let amount = "100.00"
+        let taxable = true
+        let note = "This is a note"
+        let email = "[email protected]"
+
+        let store = OrderStore(dispatcher: dispatcher, storageManager: storageManager, network: network)
+        network.simulateResponse(requestUrlSuffix: "orders/963", filename: "order")
+
+        // When
+        let action = OrderAction.updateSimplePaymentsOrder(siteID: sampleSiteID,
+                                                           orderID: sampleOrderID,
+                                                           feeID: feeID,
+                                                           amount: amount,
+                                                           taxable: taxable,
+                                                           orderNote: note,
+                                                           email: email) { _ in }
+        store.onAction(action)
+
+        // Then
+        let request = try XCTUnwrap(network.requestsForResponseData.last as? JetpackRequest)
+        let receivedFees = try XCTUnwrap(request.parameters["fee_lines"] as? [[String: AnyHashable]]).first
+        let expectedFees: [String: AnyHashable] = [
+            "id": 1234,
+            "name": "Simple Payments",
+            "tax_status": "taxable",
+            "tax_class": "",
+            "total": "100.00"
+        ]
+        assertEqual(expectedFees, receivedFees)
+
+        let receivedBilling = try XCTUnwrap(request.parameters["billing"] as? [String: AnyHashable])
+        let expectedBilling: [String: AnyHashable] = [
+            "first_name": "",
+            "last_name": "",
+            "address_1": "",
+            "city": "",
+            "state": "",
+            "postcode": "",
+            "country": "",
+            "email": email
+        ]
+        assertEqual(receivedBilling, expectedBilling)
+
+        let receivedNote = try XCTUnwrap(request.parameters["customer_note"] as? String)
+        assertEqual(receivedNote, note)
+    }
 }