Merge pull request #6227 from woocommerce/issue/6132-lazy-order-creation

Order Creation: Lazily create an order when a new order is modified.

Author: Ecarrion

Networking/Networking/Model/OrderItem.swift

@@ -77,8 +77,14 @@ public struct OrderItem: Decodable, Equatable, Hashable, GeneratedFakeable, Gene
         }
 
         let quantity = try container.decode(Decimal.self, forKey: .quantity)
-        let decimalPrice = try container.decodeIfPresent(Decimal.self, forKey: .price) ?? Decimal(0)
-        let price = NSDecimalNumber(decimal: decimalPrice)
+
+        /// WC versions lower than `6.3` send the item price as a `number`.
+        /// WC Versions equal or greater than `6.3` send the item price as a `string`.
+        ///
+        let decimalPrice = container.failsafeDecodeIfPresent(targetType: String.self,
+                                                             forKey: .price,
+                                                             alternativeTypes: [.decimal { String(describing: $0) }])
+        let price = NSDecimalNumber(string: decimalPrice)
 
         let sku = try container.decodeIfPresent(String.self, forKey: .sku)
         let subtotal = try container.decode(String.self, forKey: .subtotal)

WooCommerce/Classes/ViewRelated/Orders/Order Creation/Synchronizer/RemoteOrderSynchronizer.swift

@@ -42,6 +42,10 @@ final class RemoteOrderSynchronizer: OrderSynchronizer {
     ///
     private var baseSyncStatus: OrderStatusEnum = .pending
 
+    /// Subscriptions store.
+    ///
+    private var subscriptions = Set<AnyCancellable>()
+
     // MARK: Initializers
 
     init(siteID: Int64, stores: StoresManager = ServiceLocator.stores) {
@@ -50,6 +54,7 @@ final class RemoteOrderSynchronizer: OrderSynchronizer {
 
         updateBaseSyncOrderStatus()
         bindInputs()
+        bindOrderSync()
     }
 
     // MARK: Methods
@@ -101,4 +106,64 @@ private extension RemoteOrderSynchronizer {
             }
             .assign(to: &$order)
     }
+
+    /// Creates the order(if needed) when a significant order input occurs.
+    ///
+    func bindOrderSync() {
+        // Combine inputs that should trigger an order sync
+        let syncTrigger: AnyPublisher<Void, Never> = setProduct.map { _ in () }
+            .merge(with: setAddresses.map { _ in () })
+            .merge(with: setShipping.map { _ in () })
+            .merge(with: setFee.map { _ in () })
+            .eraseToAnyPublisher()
+
+        // Creates a "draft" order if the order has not been created yet.
+        syncTrigger
+            .debounce(for: 0.5, scheduler: DispatchQueue.main) // Group & wait for 0.5s since the last signal was emitted.
+            .withLatestFrom(orderPublisher)
+            .filter { _, order in
+                order.orderID == .zero // Only continue if the order has not been created.
+            }
+            .flatMap(maxPublishers: .max(1)) { [weak self] (_, order) -> AnyPublisher<Order, Error> in // Only allow one request at a time.
+                guard let self = self else { return Empty().eraseToAnyPublisher() }
+                self.state = .syncing
+                return self.createOrderRemotely(order)
+            }
+            .catch { [weak self] error -> AnyPublisher<Order, Never> in // When an error occurs, update state & finish.
+                self?.state = .error(error)
+                return Empty().eraseToAnyPublisher()
+            }
+            .sink { [weak self] order in // When a value is received update state & order
+                self?.state = .synced
+                self?.order = order
+            }
+            .store(in: &subscriptions)
+    }
+
+    /// Returns a publisher that creates an order remotely using the `baseSyncStatus`.
+    /// The later emitted order is delivered with the latest selected status.
+    ///
+    func createOrderRemotely(_ order: Order) -> AnyPublisher<Order, Error> {
+        Future<Order, Error> { [weak self] promise in
+            guard let self = self else { return }
+
+            // Creates the order with the `draft` status
+            let draftOrder = order.copy(status: self.baseSyncStatus)
+            let action = OrderAction.createOrder(siteID: self.siteID, order: draftOrder) { [weak self] result in
+                guard let self = self else { return }
+
+                switch result {
+                case .success(let remoteOrder):
+                    // Return the order with the current selected status.
+                    let newLocalOrder = remoteOrder.copy(status: self.order.status)
+                    promise(.success(newLocalOrder))
+
+                case .failure(let error):
+                    promise(.failure(error))
+                }
+            }
+            self.stores.dispatch(action)
+        }
+        .eraseToAnyPublisher()
+    }
 }

WooCommerce/WooCommerceTests/ViewRelated/Orders/Order Creation/Synchronizer/RemoteOrderSynchronizerTests.swift

@@ -1,6 +1,7 @@
 import XCTest
 import TestKit
 import Fakes
+import Combine
 
 @testable import WooCommerce
 @testable import Yosemite
@@ -11,6 +12,12 @@ class RemoteOrderSynchronizerTests: XCTestCase {
     private let sampleProductID: Int64 = 234
     private let sampleInputID: Int64 = 345
     private let sampleShippingID: Int64 = 456
+    private var subscriptions = Set<AnyCancellable>()
+
+    override func setUp() {
+        super.setUp()
+        subscriptions.removeAll()
+    }
 
     func test_sending_status_input_updates_local_order() throws {
         // Given
@@ -134,4 +141,244 @@ class RemoteOrderSynchronizerTests: XCTestCase {
         // Then
         XCTAssertEqual(synchronizer.order.shippingLines, [])
     }
+
+    func test_sending_product_input_triggers_order_creation() {
+        // Given
+        let product = Product.fake().copy(productID: sampleProductID)
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+
+        // When
+        let orderCreationInvoked: Bool = waitFor { promise in
+            stores.whenReceivingAction(ofType: OrderAction.self) { action in
+                switch action {
+                case .createOrder:
+                    promise(true)
+                default:
+                    promise(false)
+                }
+            }
+
+            let input = OrderSyncProductInput(product: .product(product), quantity: 1)
+            synchronizer.setProduct.send(input)
+        }
+
+        // Then
+        XCTAssertTrue(orderCreationInvoked)
+    }
+
+    func test_sending_addresses_input_triggers_order_creation() {
+        // Given
+        let address = Address.fake().copy(firstName: "Woo", lastName: "Customer")
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+
+        // When
+        let orderCreationInvoked: Bool = waitFor { promise in
+            stores.whenReceivingAction(ofType: OrderAction.self) { action in
+                switch action {
+                case .createOrder:
+                    promise(true)
+                default:
+                    promise(false)
+                }
+            }
+
+            let input = OrderSyncAddressesInput(billing: address, shipping: address)
+            synchronizer.setAddresses.send(input)
+        }
+
+        // Then
+        XCTAssertTrue(orderCreationInvoked)
+    }
+
+    func test_sending_shipping_input_triggers_order_creation() {
+        // Given
+        let shippingLine = ShippingLine.fake().copy(shippingID: sampleShippingID)
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+
+        // When
+        let orderCreationInvoked: Bool = waitFor { promise in
+            stores.whenReceivingAction(ofType: OrderAction.self) { action in
+                switch action {
+                case .createOrder:
+                    promise(true)
+                default:
+                    promise(false)
+                }
+            }
+
+            synchronizer.setShipping.send(shippingLine)
+        }
+
+        // Then
+        XCTAssertTrue(orderCreationInvoked)
+    }
+
+    func test_sending_fee_input_triggers_order_creation() {
+        // Given
+        let fee = OrderFeeLine.fake().copy()
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+
+        // When
+        let orderCreationInvoked: Bool = waitFor { promise in
+            stores.whenReceivingAction(ofType: OrderAction.self) { action in
+                switch action {
+                case .createOrder:
+                    promise(true)
+                default:
+                    promise(false)
+                }
+            }
+
+            synchronizer.setFee.send(fee)
+        }
+
+        // Then
+        XCTAssertTrue(orderCreationInvoked)
+    }
+
+    func test_states_are_properly_set_upon_success_order_creation() {
+        // Given
+        let product = Product.fake().copy(productID: sampleProductID)
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+        stores.whenReceivingAction(ofType: OrderAction.self) { action in
+            switch action {
+            case .createOrder(_, _, let completion):
+                completion(.success(.fake()))
+            default:
+                XCTFail("Unexpected action: \(action)")
+            }
+        }
+
+        // When
+        let input = OrderSyncProductInput(product: .product(product), quantity: 1)
+        synchronizer.setProduct.send(input)
+
+        let states: [OrderSyncState] = waitFor { promise in
+            synchronizer.statePublisher
+                .dropFirst()
+                .collect(2)
+                .sink { states in
+                    promise(states)
+                }
+                .store(in: &self.subscriptions)
+        }
+
+        // Then
+        XCTAssertEqual(states, [.syncing, .synced])
+    }
+
+    func test_states_are_properly_set_upon_failing_order_creation() {
+        // Given
+        let product = Product.fake().copy(productID: sampleProductID)
+        let error = NSError(domain: "", code: 0, userInfo: nil)
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+        stores.whenReceivingAction(ofType: OrderAction.self) { action in
+            switch action {
+            case .createOrder(_, _, let completion):
+                completion(.failure(error))
+            default:
+                XCTFail("Unexpected action: \(action)")
+            }
+        }
+
+        // When
+        let input = OrderSyncProductInput(product: .product(product), quantity: 1)
+        synchronizer.setProduct.send(input)
+
+        let states: [OrderSyncState] = waitFor { promise in
+            synchronizer.statePublisher
+                .dropFirst()
+                .collect(2)
+                .sink { states in
+                    promise(states)
+                }
+                .store(in: &self.subscriptions)
+        }
+
+        // Then
+        assertEqual(states, [.syncing, .error(error)])
+    }
+
+    func test_sending_double_input_triggers_only_one_order_creation() {
+        // Given
+        let product = Product.fake().copy(productID: sampleProductID)
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+
+        // When
+        let exp = expectation(description: #function)
+        exp.expectedFulfillmentCount = 1
+        exp.assertForOverFulfill = true
+
+        stores.whenReceivingAction(ofType: OrderAction.self) { action in
+            switch action {
+            case .createOrder:
+                exp.fulfill()
+            default:
+                break
+            }
+        }
+
+        let input1 = OrderSyncProductInput(product: .product(product), quantity: 1)
+        synchronizer.setProduct.send(input1)
+
+        let input2 = OrderSyncProductInput(product: .product(product), quantity: 2)
+        synchronizer.setProduct.send(input2)
+
+        // Then
+        wait(for: [exp], timeout: 1.0)
+    }
+
+    func test_order_is_created_with_draft_status_and_returned_with_selected_status() {
+        // Given
+        let stores = MockStoresManager(sessionManager: .testingInstance)
+        stores.whenReceivingAction(ofType: SystemStatusAction.self) { action in // Set version that supports auto-draft
+            switch action {
+            case let .fetchSystemPlugin(_, _, onCompletion):
+                onCompletion(.fake().copy(version: "6.3.0"))
+            default:
+                XCTFail("Unexpected action received: \(action)")
+            }
+        }
+        let synchronizer = RemoteOrderSynchronizer(siteID: sampleSiteID, stores: stores)
+        XCTAssertEqual(synchronizer.order.status, .pending) // initial status
+
+        // When
+        let submittedStatus: OrderStatusEnum = waitFor { promise in
+            stores.whenReceivingAction(ofType: OrderAction.self) { action in
+                switch action {
+                case let .createOrder(_, order, onCompletion):
+                    onCompletion(.success(order))
+                    promise(order.status)
+                default:
+                    XCTFail("Unexpected action: \(action)")
+                }
+            }
+
+            synchronizer.setFee.send(.fake())
+        }
+
+        // Then
+        XCTAssertEqual(submittedStatus, .autoDraft) // Submitted Status
+        XCTAssertEqual(synchronizer.order.status, .pending) // Selected status
+    }
+}
+
+extension OrderSyncState: Equatable {
+    public static func == (lhs: OrderSyncState, rhs: OrderSyncState) -> Bool {
+        switch (lhs, rhs) {
+        case (.syncing, .syncing), (.synced, .synced):
+            return true
+        case (.error(let error1), .error(let error2)):
+            return error1 as NSError == error2 as NSError
+        default:
+            return false
+        }
+    }
 }