@rebilly/instruments 4.5.0 → 4.7.0

package/src/views/method-selector/generate-framepay-config.spec.js

@@ -1,192 +1,216 @@
-import {generateFramepayConfig} from './generate-framepay-config';
+import { generateFramepayConfig } from './generate-framepay-config';
 import state from '@/state';
 
 describe('Generate FramePay Config', () => {
-  beforeEach(() => {
-    state.options = {
-      themeFramepay: {},
-      locale: 'en-CA',
-      organizationId: 'test-organization-id',
-      websiteId: 'test-website-id'
-    };
-    state.data = {
-      readyToPay: []
-    }
-  });
-
-  it('should generate default config', () => {
-    const config = generateFramepayConfig({
-      state,
-      methodIds: []
+    beforeEach(() => {
+        state.options = {
+            themeFramepay: {},
+            locale: 'en-CA',
+            organizationId: 'test-organization-id',
+            websiteId: 'test-website-id',
+        };
+        state.data = {
+            readyToPay: [],
+        };
     });
 
-    const {options, data} = state;
-
-    expect(config).toEqual(expect.objectContaining ({
-      style: options.themeFramepay,
-      locale: options.locale,
-      organizationId: options.organizationId,
-      websiteId: options.websiteId,
-      methods: data.readyToPay,
-    }))
-  });
-
-  it('should add publishableKey', () => {
-    state.options.publishableKey = 'test-publishable-key';
-
-    const config = generateFramepayConfig({
-      state,
-      methodIds: []
+    it('should generate default config', () => {
+        const config = generateFramepayConfig({
+            state,
+            methodIds: [],
+        });
+
+        const { options, data } = state;
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                style: options.themeFramepay,
+                locale: options.locale,
+                organizationId: options.organizationId,
+                websiteId: options.websiteId,
+                methods: data.readyToPay,
+            }),
+        );
     });
 
-    expect(config).toEqual(expect.objectContaining ({
-      publishableKey: state.options.publishableKey
-    }));
-  });
+    it('should add publishableKey', () => {
+        state.options.publishableKey = 'test-publishable-key';
 
-  it('should add jwt', () => {
-    state.options.jwt = 'test-jwt';
-    state.options.apiMode = 'sandbox';
+        const config = generateFramepayConfig({
+            state,
+            methodIds: [],
+        });
 
-    const config = generateFramepayConfig({
-      state,
-      methodIds: []
+        expect(config).toEqual(
+            expect.objectContaining({
+                publishableKey: state.options.publishableKey,
+            }),
+        );
     });
 
-    expect(config).toEqual(expect.objectContaining ({
-      jwt: state.options.jwt,
-      sandbox: true
-    }));
-  });
-
-  it('should add configurations for PayPal', () => {
-    state.data.amountAndCurrency = {
-      amount: 10,
-      currency: 'CAD'
-    };
-    state.options.paymentInstruments = {
-      paypal: {
-        test: 'key'
-      }
-    }
-
-    const config = generateFramepayConfig({
-      state,
-      methodIds: ['pay-pal-billing-agreement']
+    it('should add jwt', () => {
+        state.options.jwt = 'test-jwt';
+        state.options.apiMode = 'sandbox';
+
+        const config = generateFramepayConfig({
+            state,
+            methodIds: [],
+        });
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                jwt: state.options.jwt,
+                sandbox: true,
+            }),
+        );
     });
 
-    expect(config).toEqual(expect.objectContaining ({
-      transactionData: expect.objectContaining(
-        state.data.amountAndCurrency
-      ),
-      paypal: state.options.paymentInstruments.paypal
-    }));
-  });
-
-  it('should add configurations for Google Pay', () => {
-    state.options.digitalWallet = {
-      googlePay: {
-        transactionData: {
-          test: 'key'
-        },
-        googlePayDisplayOptions: {
-          test: 'key'
-        }
-      }
-    }
-
-    const config = generateFramepayConfig({
-      state,
-      methodIds: ['google-pay']
+    it('should add configurations for PayPal', () => {
+        state.data.amountAndCurrency = {
+            amount: 10,
+            currency: 'CAD',
+        };
+        state.options.paymentInstruments = {
+            paypal: {
+                test: 'key',
+            },
+        };
+
+        const config = generateFramepayConfig({
+            state,
+            methodIds: ['pay-pal-billing-agreement'],
+        });
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                transactionData: expect.objectContaining(
+                    state.data.amountAndCurrency,
+                ),
+                paypal: state.options.paymentInstruments.paypal,
+            }),
+        );
     });
 
-    expect(config).toEqual(expect.objectContaining ({
-      transactionData: expect.objectContaining(
-        state.options.digitalWallet.googlePay.transactionData
-      ),
-      googlePay: state.options.digitalWallet.googlePay.googlePayDisplayOptions
-    }));
-  });
-
-  it('should add configurations for Apple Pay', () => {
-    state.options.digitalWallet = {
-      applePay: {
-        transactionData: {
-          test: 'key'
-        },
-        applePayDisplayOptions: {
-          test: 'key'
-        }
-      }
-    }
-
-    const config = generateFramepayConfig({
-      state,
-      methodIds: ['apple-pay']
+    it('should add configurations for Google Pay', () => {
+        state.options.digitalWallet = {
+            googlePay: {
+                transactionData: {
+                    test: 'key',
+                },
+                googlePayDisplayOptions: {
+                    test: 'key',
+                },
+            },
+        };
+
+        const config = generateFramepayConfig({
+            state,
+            methodIds: ['google-pay'],
+        });
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                transactionData: expect.objectContaining(
+                    state.options.digitalWallet.googlePay.transactionData,
+                ),
+                googlePay:
+                    state.options.digitalWallet.googlePay
+                        .googlePayDisplayOptions,
+            }),
+        );
     });
 
-    expect(config).toEqual(expect.objectContaining ({
-      transactionData: expect.objectContaining(
-        state.options.digitalWallet.applePay.transactionData
-      ),
-      applePay: state.options.digitalWallet.applePay.applePayDisplayOptions
-    }));
-  });
-
-  it('should add all instrument methods together', () => {
-    state.data.amountAndCurrency = {
-      test: 'key'
-    };
-    state.options = {
-      paymentInstruments: {
-        paypal: {
-          test: 'key'
-        }
-      },
-      digitalWallet: {
-        googlePay: {
-          transactionData: {
-            test: 'key'
-          },
-          googlePayDisplayOptions: {
-            test: 'key'
-          }
-        },
-        applePay: {
-          transactionData: {
-            test: 'key'
-          },
-          applePayDisplayOptions: {
-            test: 'key'
-          }
-        }
-      }
-    }
-
-    const config = generateFramepayConfig({
-      state,
-      methodIds: ['pay-pal-billing-agreement', 'google-pay', 'apple-pay']
+    it('should add configurations for Apple Pay', () => {
+        state.options.digitalWallet = {
+            applePay: {
+                transactionData: {
+                    test: 'key',
+                },
+                applePayDisplayOptions: {
+                    test: 'key',
+                },
+            },
+        };
+
+        const config = generateFramepayConfig({
+            state,
+            methodIds: ['apple-pay'],
+        });
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                transactionData: expect.objectContaining(
+                    state.options.digitalWallet.applePay.transactionData,
+                ),
+                applePay:
+                    state.options.digitalWallet.applePay.applePayDisplayOptions,
+            }),
+        );
     });
 
-    expect(config).toEqual(expect.objectContaining ({
-      transactionData: expect.objectContaining(
-        state.data.amountAndCurrency
-      ),
-      paypal: state.options.paymentInstruments.paypal
-    }));
-
-    expect(config).toEqual(expect.objectContaining ({
-      transactionData: expect.objectContaining(
-        state.options.digitalWallet.googlePay.transactionData
-      ),
-      googlePay: state.options.digitalWallet.googlePay.googlePayDisplayOptions
-    }));
-
-    expect(config).toEqual(expect.objectContaining ({
-      transactionData: expect.objectContaining(
-        state.options.digitalWallet.applePay.transactionData
-      ),
-      applePay: state.options.digitalWallet.applePay.applePayDisplayOptions
-    }));
-  });
-});
+    it('should add all instrument methods together', () => {
+        state.data.amountAndCurrency = {
+            test: 'key',
+        };
+        state.options = {
+            paymentInstruments: {
+                paypal: {
+                    test: 'key',
+                },
+            },
+            digitalWallet: {
+                googlePay: {
+                    transactionData: {
+                        test: 'key',
+                    },
+                    googlePayDisplayOptions: {
+                        test: 'key',
+                    },
+                },
+                applePay: {
+                    transactionData: {
+                        test: 'key',
+                    },
+                    applePayDisplayOptions: {
+                        test: 'key',
+                    },
+                },
+            },
+        };
+
+        const config = generateFramepayConfig({
+            state,
+            methodIds: ['pay-pal-billing-agreement', 'google-pay', 'apple-pay'],
+        });
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                transactionData: expect.objectContaining(
+                    state.data.amountAndCurrency,
+                ),
+                paypal: state.options.paymentInstruments.paypal,
+            }),
+        );
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                transactionData: expect.objectContaining(
+                    state.options.digitalWallet.googlePay.transactionData,
+                ),
+                googlePay:
+                    state.options.digitalWallet.googlePay
+                        .googlePayDisplayOptions,
+            }),
+        );
+
+        expect(config).toEqual(
+            expect.objectContaining({
+                transactionData: expect.objectContaining(
+                    state.options.digitalWallet.applePay.transactionData,
+                ),
+                applePay:
+                    state.options.digitalWallet.applePay.applePayDisplayOptions,
+            }),
+        );
+    });
+});

package/src/views/method-selector/get-method-data.js

@@ -2,11 +2,10 @@ import kebabCase from 'lodash.kebabcase';
 import camelCase from 'lodash.camelcase';
 
 export const getMethodData = (method) => {
-  const METHOD_ID = kebabCase(method.feature?.name || method.method);
-  const METHOD_TYPE = camelCase(method.feature?.name || method.method).replace(
-    '-',
-    ''
-  );
+    const METHOD_ID = kebabCase(method.feature?.name || method.method);
+    const METHOD_TYPE = camelCase(
+        method.feature?.name || method.method,
+    ).replace('-', '');
 
-  return { METHOD_ID, METHOD_TYPE };
+    return { METHOD_ID, METHOD_TYPE };
 };

package/src/views/method-selector/get-payment-methods.js

@@ -1,23 +1,25 @@
 import state from '../../state';
 
 export function getPaymentMethods() {
-  const result = {
-    expressMethods: [],
-    methods: []
-  };
+    const result = {
+        expressMethods: [],
+        methods: [],
+    };
 
-  state.data.readyToPay?.forEach((method) => {
-    if (method.metadata.isExpressMethod) {
-      result.expressMethods.push(method);
-    } else {
-      result.methods.push(method);
-    }
-  });
+    state.data.readyToPay?.forEach((method) => {
+        if (method.metadata.isExpressMethod) {
+            result.expressMethods.push(method);
+        } else {
+            result.methods.push(method);
+        }
+    });
 
-  if (!window.ApplePaySession) {
-    result.expressMethods = result.expressMethods.filter(method => method?.feature?.name !== 'Apple Pay');
-    state.loader.stopLoading({ id: 'applePay-express' });
-  } 
+    if (!window.ApplePaySession) {
+        result.expressMethods = result.expressMethods.filter(
+            (method) => method?.feature?.name !== 'Apple Pay',
+        );
+        state.loader.stopLoading({ id: 'applePay-express' });
+    }
 
-  return result;
+    return result;
 }

package/src/views/method-selector/get-payment-methods.spec.js

@@ -7,33 +7,35 @@ import { fetchReadyToPay } from '@/storefront/ready-to-pay';
 import state from '@/state';
 
 it('should only return the allowed methods', async () => {
-  StorefontTestingInstance();
-  when(
-    post(`${storefrontURL}/ready-to-pay`)
-  ).thenReturn(
-    ok([{
-      method: 'payment-card',
-      feature: {
-        name: 'Google Pay',
-        merchantName: 'google-pay-merchant-name',
-        merchantOrigin: 'google-pay-merchant-origin'
-      },
-      brands: ['Visa'],
-      filters: []
-    }, {
-      method: 'fake-method',
-      filters: []
-    }, {
-      method: 'payment-card',
-      brands: ['Visa'],
-      filters: []
-    }])
-  );
-  state.data.readyToPay = await fetchReadyToPay({});
+    StorefontTestingInstance();
+    when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(
+        ok([
+            {
+                method: 'payment-card',
+                feature: {
+                    name: 'Google Pay',
+                    merchantName: 'google-pay-merchant-name',
+                    merchantOrigin: 'google-pay-merchant-origin',
+                },
+                brands: ['Visa'],
+                filters: [],
+            },
+            {
+                method: 'fake-method',
+                filters: [],
+            },
+            {
+                method: 'payment-card',
+                brands: ['Visa'],
+                filters: [],
+            },
+        ]),
+    );
+    state.data.readyToPay = await fetchReadyToPay({});
 
-  const results = getPaymentMethods();
+    const results = getPaymentMethods();
 
-  expect(results.hasOwnProperty('expressMethods')).toEqual(true);
-  expect(results['expressMethods'].length).toEqual(1);
-  expect(results['methods'].length).toEqual(1);
+    expect(results.hasOwnProperty('expressMethods')).toEqual(true);
+    expect(results['expressMethods'].length).toEqual(1);
+    expect(results['methods'].length).toEqual(1);
 });