fix(payment): CHECKOUT-3401 Load order payments using checkout.orderId

Author: davidchin

src/order/order-action-creator.spec.js

@@ -132,14 +132,14 @@ describe('OrderActionCreator', () => {
         });
     });
 
-    describe('#loadCurrentOrderPayments()', () => {
+    describe('#loadOrderPayments()', () => {
         beforeEach(() => {
             jest.spyOn(checkoutClient, 'loadOrder')
                 .mockReturnValue(Promise.resolve(getResponse(getOrder())));
         });
 
         it('emits actions if able to load order', async () => {
-            const actions = await Observable.from(orderActionCreator.loadCurrentOrderPayments()(store))
+            const actions = await orderActionCreator.loadOrderPayments(295)
                 .toArray()
                 .toPromise();
 
@@ -154,7 +154,7 @@ describe('OrderActionCreator', () => {
                 .mockReturnValue(Promise.reject(getErrorResponse()));
 
             const errorHandler = jest.fn((action) => Observable.of(action));
-            const actions = await Observable.from(orderActionCreator.loadCurrentOrderPayments()(store))
+            const actions = await orderActionCreator.loadOrderPayments(295)
                 .catch(errorHandler)
                 .toArray()
                 .toPromise();
@@ -167,7 +167,7 @@ describe('OrderActionCreator', () => {
         });
 
         it('loads order by using order id from order object', async () => {
-            await orderActionCreator.loadCurrentOrderPayments()(store)
+            await orderActionCreator.loadOrderPayments(295)
                 .toPromise();
 
             expect(checkoutClient.loadOrder).toHaveBeenCalledWith(295, undefined);
@@ -180,25 +180,14 @@ describe('OrderActionCreator', () => {
                 order: getOrderState(),
             });
 
-            await orderActionCreator.loadCurrentOrderPayments()(store)
+            await orderActionCreator.loadOrderPayments(295)
                 .toPromise();
 
             expect(checkoutClient.loadOrder).toHaveBeenCalledWith(295, undefined);
         });
 
-        it('throws error if there is no existing order id', async () => {
-            store = createCheckoutStore();
-
-            try {
-                await orderActionCreator.loadCurrentOrderPayments()(store)
-                    .toPromise();
-            } catch (error) {
-                expect(error).toBeInstanceOf(MissingDataError);
-            }
-        });
-
         it('loads order only when action is dispatched', async () => {
-            const action = orderActionCreator.loadCurrentOrderPayments()(store);
+            const action = orderActionCreator.loadOrderPayments(295);
 
             expect(checkoutClient.loadOrder).not.toHaveBeenCalled();
 

src/order/order-action-creator.ts

@@ -34,15 +34,18 @@ export default class OrderActionCreator {
     }
 
     // TODO: Remove when checkout does not contain unrelated order data.
-    loadCurrentOrderPayments(options?: RequestOptions): ThunkAction<LoadOrderPaymentsAction, InternalCheckoutSelectors> {
-        return store => defer(() => {
-            const orderId = this._getCurrentOrderId(store.getState());
-
-            if (!orderId) {
-                throw new MissingDataError(MissingDataErrorType.MissingOrderId);
-            }
+    loadOrderPayments(orderId: number, options?: RequestOptions): Observable<LoadOrderPaymentsAction> {
+        return new Observable((observer: Observer<LoadOrderPaymentsAction>) => {
+            observer.next(createAction(OrderActionType.LoadOrderPaymentsRequested));
 
-            return this._loadOrderPayments(orderId, options);
+            this._checkoutClient.loadOrder(orderId, options)
+                .then(response => {
+                    observer.next(createAction(OrderActionType.LoadOrderPaymentsSucceeded, response.body));
+                    observer.complete();
+                })
+                .catch(response => {
+                    observer.error(createErrorAction(OrderActionType.LoadOrderPaymentsFailed, response));
+                });
         });
     }
 
@@ -104,25 +107,10 @@ export default class OrderActionCreator {
         );
     }
 
-    // TODO: Remove when checkout does not contain unrelated order data.
-    private _loadOrderPayments(orderId: number, options?: RequestOptions): Observable<LoadOrderPaymentsAction> {
-        return new Observable((observer: Observer<LoadOrderPaymentsAction>) => {
-            observer.next(createAction(OrderActionType.LoadOrderPaymentsRequested));
-
-            this._checkoutClient.loadOrder(orderId, options)
-                .then(response => {
-                    observer.next(createAction(OrderActionType.LoadOrderPaymentsSucceeded, response.body));
-                    observer.complete();
-                })
-                .catch(response => {
-                    observer.error(createErrorAction(OrderActionType.LoadOrderPaymentsFailed, response));
-                });
-        });
-    }
-
     private _getCurrentOrderId(state: InternalCheckoutSelectors): number | undefined {
         const order = state.order.getOrder();
         const checkout = state.checkout.getCheckout();
+
         return (order && order.orderId) || (checkout && checkout.orderId);
     }
 

src/payment/payment-strategy-action-creator.spec.ts

@@ -209,8 +209,8 @@ describe('PaymentStrategyActionCreator', () => {
             jest.spyOn(noPaymentDataStrategy, 'execute')
                 .mockReturnValue(Promise.resolve(store.getState()));
 
-            jest.spyOn(orderActionCreator, 'loadCurrentOrderPayments')
-                .mockReturnValue(() => Observable.of(createAction(OrderActionType.LoadOrderPaymentsRequested)));
+            jest.spyOn(orderActionCreator, 'loadOrderPayments')
+                .mockReturnValue(Observable.of(createAction(OrderActionType.LoadOrderPaymentsRequested)));
         });
 
         it('finds payment strategy by method', async () => {
@@ -246,7 +246,7 @@ describe('PaymentStrategyActionCreator', () => {
             await Observable.from(actionCreator.execute(payload)(store))
                 .toPromise();
 
-            expect(orderActionCreator.loadCurrentOrderPayments).toHaveBeenCalled();
+            expect(orderActionCreator.loadOrderPayments).toHaveBeenCalled();
         });
 
         it('emits action to load order and notify execution progress', async () => {
@@ -343,8 +343,8 @@ describe('PaymentStrategyActionCreator', () => {
             jest.spyOn(strategy, 'finalize')
                 .mockReturnValue(Promise.resolve(store.getState()));
 
-            jest.spyOn(orderActionCreator, 'loadCurrentOrderPayments')
-                .mockReturnValue((() => Observable.of(createAction(OrderActionType.LoadOrderPaymentsRequested))));
+            jest.spyOn(orderActionCreator, 'loadOrderPayments')
+                .mockReturnValue(Observable.of(createAction(OrderActionType.LoadOrderPaymentsRequested)));
         });
 
         it('finds payment strategy by method', async () => {
@@ -372,7 +372,7 @@ describe('PaymentStrategyActionCreator', () => {
             await Observable.from(actionCreator.finalize()(store))
                 .toPromise();
 
-            expect(orderActionCreator.loadCurrentOrderPayments).toHaveBeenCalled();
+            expect(orderActionCreator.loadOrderPayments).toHaveBeenCalled();
         });
 
         it('emits action to load order and notify finalization progress', async () => {

src/payment/payment-strategy-action-creator.ts

@@ -1,7 +1,6 @@
 import { createAction, createErrorAction, ThunkAction } from '@bigcommerce/data-store';
 import { concat } from 'rxjs/observable/concat';
 import { empty } from 'rxjs/observable/empty';
-import { from } from 'rxjs/observable/from';
 import { Observable } from 'rxjs/Observable';
 import { Observer } from 'rxjs/Observer';
 
@@ -174,10 +173,11 @@ export default class PaymentStrategyActionCreator {
     }
 
     private _loadOrderPaymentsIfNeeded(store: ReadableCheckoutStore, options?: RequestOptions): Observable<LoadOrderPaymentsAction> {
-        const checkout = store.getState().checkout.getCheckout();
+        const state = store.getState();
+        const checkout = state.checkout.getCheckout();
 
         if (checkout && checkout.orderId) {
-            return from(this._orderActionCreator.loadCurrentOrderPayments(options)(store));
+            return this._orderActionCreator.loadOrderPayments(checkout.orderId, options);
         }
 
         return empty();