@rebilly/instruments 1.0.1-beta → 1.0.2-beta.10

package/src/storefront/products.spec.js

@@ -2,27 +2,21 @@ import { MockStorefront } from 'tests/mocks/storefront-mock';
 import { ok, get } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchProducts } from './products';
+import { fetchProducts } from './products';
 import ProductModel from './models/product-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Plan', () => {
   class TestProductsInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
+    constructor({ configs = {}, options = {} } = {}) {
       this.configs = configs;
       this.options = options;
       this.storefront = MockStorefront();
     }
-
-    FetchProducts(...args) {
-      return FetchProducts.apply(this, args);
-    }
   }
-  
-  it ('can fetch products', async () => {
-    const testProduct = {name: 'Test Product', id: 'test-product-id-1'};
+
+  it('can fetch products', async () => {
+    const testProduct = { name: 'Test Product', id: 'test-product-id-1' };
 
     when(get(`${storefrontURL}/products`)).thenReturn(ok([testProduct]));
 
@@ -30,7 +24,7 @@ describe('Storefront API Plan', () => {
 
     jest.spyOn(instance.storefront.products, 'getAll');
 
-    const response = await instance.FetchProducts({});
+    const response = await fetchProducts({ state: instance });
 
     expect(instance.storefront.products.getAll).toBeCalledTimes(1);
     expect(instance.storefront.products.getAll).toBeCalledWith({
@@ -41,20 +35,21 @@ describe('Storefront API Plan', () => {
     expect(response).toEqual([new ProductModel(testProduct)]);
   });
 
-  it ('can fetch products with filter', async () => {
+  it('can fetch products with filter', async () => {
     const instance = new TestProductsInstance();
 
     jest.spyOn(instance.storefront.products, 'getAll');
 
-    await instance.FetchProducts({
+    await fetchProducts({
+      state: instance,
       data: [
-          {
-            productId: 'test-product-1'
-          },
-          {
-            productId: 'test-product-2'
-          }
-      ],
+        {
+          productId: 'test-product-1'
+        },
+        {
+          productId: 'test-product-2'
+        }
+      ]
     });
 
     expect(instance.storefront.products.getAll).toBeCalledWith({
@@ -62,31 +57,25 @@ describe('Storefront API Plan', () => {
     });
   });
 
-  it ('should throw errors with no configs or options', () => {
-    const NoConfigOrOptionsError = new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
+  it('should throw errors with no configs or options', async () => {
     const noConfigOrOptionsInstance = new TestProductsInstance({
       configs: null,
-      options: null,
+      options: null
     });
+    await expectConfigurationError(
+      fetchProducts({ state: noConfigOrOptionsInstance })
+    );
+
     const noConfigInstance = new TestProductsInstance({
       configs: null,
-      options: {},
+      options: {}
     });
+    await expectConfigurationError(fetchProducts({ state: noConfigInstance }));
+
     const noOptionsInstance = new TestProductsInstance({
       configs: {},
-      options: null,
+      options: null
     });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.FetchProducts();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noConfigInstance.FetchProducts();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.FetchProducts();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    await expectConfigurationError(fetchProducts({ state: noOptionsInstance }));
   });
 });

package/src/storefront/purchase.js

@@ -1,19 +1,21 @@
-export async function PostPurchase (data) {
-  if (!this.storefront) {
+export async function postPurchase({ data, state }) {
+  if (!state.storefront) {
     throw new Error('Could not access rebilly-js-sdk instance');
   }
 
-  if (!this.configs || !this.options) {
-    throw new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
+  if (!state.configs || !state.options) {
+    throw new Error(
+      'Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data'
+    );
   }
 
   try {
     if (data._raw) {
       delete data._raw;
     }
-    const resp = await this.storefront.purchase.purchase({data});
+    const resp = await state.storefront.purchase.purchase({ data });
     return resp;
   } catch (error) {
     throw error;
   }
-};
+}

package/src/storefront/purchase.spec.js

@@ -2,39 +2,38 @@ import { MockStorefront } from 'tests/mocks/storefront-mock';
 import { ok, post } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { PostPurchase } from './purchase';
+import { postPurchase } from './purchase';
 
 describe('Storefront API Purchase', () => {
   class TestPurchaseInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
+    constructor({ configs = {}, options = {} } = {}) {
       this.configs = configs;
       this.options = options;
       this.storefront = MockStorefront();
     }
 
     postPurchase(...args) {
-      return PostPurchase.apply(this, args);
+      return postPurchase({ state: this, data: args });
     }
   }
 
-  it ('can make purchase', async () => {
+  it('can make purchase', async () => {
     const instance = new TestPurchaseInstance();
     const payload = {
       websiteId: 'test-website-id',
-      items: [{
-        planId: 'test-plan-id-1',
-        quantity: 1
-      }],
+      items: [
+        {
+          planId: 'test-plan-id-1',
+          quantity: 1
+        }
+      ],
       billingAddress: {
         firstName: 'Test',
         lastName: 'Customer'
       },
       paymentInstruction: {
-        token: 'test-token',
-      },
+        token: 'test-token'
+      }
     };
     const fields = {
       orderId: 'test-order-id',
@@ -44,17 +43,19 @@ describe('Storefront API Purchase', () => {
       transaction: {
         id: 'test-transaction-id'
       }
-    }
+    };
 
     when(post(`${storefrontURL}/purchase`)).thenReturn(ok(fields));
 
     jest.spyOn(instance.storefront.purchase, 'purchase');
 
-    const requestResponse = await instance.storefront.purchase.purchase(payload);
+    const requestResponse = await instance.storefront.purchase.purchase(
+      payload
+    );
 
     expect(instance.storefront.purchase.purchase).toBeCalledTimes(1);
     expect(instance.storefront.purchase.purchase).toBeCalledWith(payload);
-    
+
     expect(requestResponse.config).toBeInstanceOf(Object);
     expect(requestResponse.fields).toBeInstanceOf(Object);
     expect(requestResponse.response).toBeInstanceOf(Object);
@@ -62,4 +63,4 @@ describe('Storefront API Purchase', () => {
     expect(requestResponse.fields).toEqual(fields);
     expect(requestResponse.fields).toMatchObject(fields);
   });
-});
+});

package/src/storefront/ready-to-pay.js

@@ -1,22 +1,24 @@
 import { collectData } from '@rebilly/risk-data-collector';
 import ReadyToPayModel from './models/ready-to-pay-model';
 
-export async function FetchReadyToPay (riskMetadata = null) {
-  if (!this.storefront) {
+export async function fetchReadyToPay({ state, riskMetadata = null }) {
+  if (!state.storefront) {
     throw new Error('Could not access rebilly-js-sdk instance');
   }
 
-  if (!this.configs || !this.options) {
-    throw new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
+  if (!state.configs || !state.options) {
+    throw new Error(
+      'Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data'
+    );
   }
 
   try {
     if (!riskMetadata) {
-      const {riskMetadata: data} = await collectData();
+      const { riskMetadata: data } = await collectData();
       riskMetadata = data;
     }
-    const websiteId = this.configs?.websiteId || null;
-    const items = this.options?.intent?.items || [];
+    const websiteId = state.configs?.websiteId || null;
+    const items = state.options?.intent?.items || [];
 
     const data = {
       items,
@@ -24,13 +26,17 @@ export async function FetchReadyToPay (riskMetadata = null) {
       riskMetadata
     };
 
-    const {fields: readyToPayFields} = await this.storefront.purchase.readyToPay({data});
+    const { fields: readyToPayFields } =
+      await state.storefront.purchase.readyToPay({ data });
 
-    return Object.values(readyToPayFields).map((fields, index) => new ReadyToPayModel({
-        index,
-        ...fields,
-      }));
+    return Object.values(readyToPayFields).map(
+      (fields, index) =>
+        new ReadyToPayModel({
+          index,
+          ...fields
+        })
+    );
   } catch (error) {
     throw error;
   }
-};
+}

package/src/storefront/ready-to-pay.spec.js

@@ -2,32 +2,28 @@ import { MockStorefront } from 'tests/mocks/storefront-mock';
 import { ok, post } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchReadyToPay } from './ready-to-pay';
+import { fetchReadyToPay } from './ready-to-pay';
 import ReadyToPayModel from './models/ready-to-pay-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Ready to Pay', () => {
   class TestReadyToPayInstance {
-    constructor({
-      configs = {},
-      options = {}
-    } = {}) {
+    constructor({ configs = {}, options = {} } = {}) {
       this.configs = configs;
       this.options = options;
       this.storefront = MockStorefront();
     }
-
-    fetchReadyToPay(...args) {
-      return FetchReadyToPay.apply(this, args);
-    }
   }
-  
-  it ('can fetch ready to pay', async () => {
-    const readyToPayPayload = [{
-      method: 'payment-card',
-      feature:null,
-      brands: ['Visa'],
-      filters:[]
-    }];
+
+  it('can fetch ready to pay', async () => {
+    const readyToPayPayload = [
+      {
+        method: 'payment-card',
+        feature: null,
+        brands: ['Visa'],
+        filters: []
+      }
+    ];
     const configs = {
       websiteId: 'test-website-id'
     };
@@ -42,17 +38,20 @@ describe('Storefront API Ready to Pay', () => {
       }
     };
 
-    when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(ok(readyToPayPayload));
+    when(post(`${storefrontURL}/ready-to-pay`)).thenReturn(
+      ok(readyToPayPayload)
+    );
 
     const instance = new TestReadyToPayInstance({
       configs,
-      options,
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'readyToPay');
 
-    const response = await instance.fetchReadyToPay();
-    
+    const riskMetadata = null;
+    const response = await fetchReadyToPay({ state: instance, riskMetadata });
+
     expect(instance.storefront.purchase.readyToPay).toBeCalledTimes(1);
     expect(instance.storefront.purchase.readyToPay).toBeCalledWith({
       data: {
@@ -63,38 +62,39 @@ describe('Storefront API Ready to Pay', () => {
     });
     expect(response).toBeInstanceOf(Array);
     expect(response[0]).toBeInstanceOf(ReadyToPayModel);
-    expect(response)
-      .toEqual([new ReadyToPayModel({
+    expect(response).toEqual([
+      new ReadyToPayModel({
         index: 0,
         ...readyToPayPayload[0]
-      })]);
+      })
+    ]);
   });
 
-  it ('should throw errors with no configs or options', () => {
-    const NoConfigOrOptionsError = new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
+  it('should throw errors with no configs or options', async () => {
+    const riskMetadata = null;
+
     const noConfigOrOptionsInstance = new TestReadyToPayInstance({
       configs: null,
-      options: null,
+      options: null
     });
+    await expectConfigurationError(
+      fetchReadyToPay({ riskMetadata, state: noConfigOrOptionsInstance })
+    );
+
     const noConfigInstance = new TestReadyToPayInstance({
       configs: null,
-      options: {},
+      options: {}
     });
+    await expectConfigurationError(
+      fetchReadyToPay({ riskMetadata, state: noConfigInstance })
+    );
+
     const noOptionsInstance = new TestReadyToPayInstance({
       configs: {},
-      options: null,
+      options: null
     });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.fetchReadyToPay();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noConfigInstance.fetchReadyToPay();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.fetchReadyToPay();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    await expectConfigurationError(
+      fetchReadyToPay({ riskMetadata, state: noOptionsInstance })
+    );
   });
 });

package/src/storefront/storefront.spec.js

@@ -11,4 +11,4 @@ describe('Storefront application programming interface', () => {
     expect(storefront).toHaveProperty('purchase');
     expect(storefront.purchase).toHaveProperty('readyToPay');
   });
-});
+});

package/src/storefront/summary.js

@@ -1,37 +1,39 @@
 import SummaryModel from './models/summary-model';
 
-export async function FetchSummary ({
-  data = null
-} = {}) {
-  if (!this.storefront) {
+export async function fetchSummary({ data = null, state = null } = {}) {
+  if (!state.storefront) {
     throw new Error('Could not access rebilly-js-sdk instance');
   }
 
-  if (!this.configs || !this.options) {
-    throw new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
+  if (!state.configs || !state.options) {
+    throw new Error(
+      'Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data'
+    );
   }
 
   try {
-    const websiteId = this.configs?.websiteId || null;
-    const items = this.options?.intent?.items || [];
+    const websiteId = state.configs?.websiteId || null;
+    const items = state.options?.intent?.items || [];
 
     const payload = {
       data: {
         websiteId,
         items
       }
-    }
+    };
     if (data?.billingAddress) {
       payload.data.billingAddress = data.billingAddress;
     }
-    if(data?.deliveryAddress) {
+    if (data?.deliveryAddress) {
       payload.data.deliveryAddress = data.deliveryAddress;
     }
 
-    const {fields: summaryFields} = await this.storefront.purchase.preview(payload);
+    const { fields: summaryFields } = await state.storefront.purchase.preview(
+      payload
+    );
 
     return new SummaryModel(summaryFields);
   } catch (error) {
     throw error;
   }
-};
+}

package/src/storefront/summary.spec.js

@@ -2,27 +2,20 @@ import { MockStorefront } from 'tests/mocks/storefront-mock';
 import { ok, post } from 'msw-when-then';
 import { when } from 'tests/msw/server';
 import { storefrontURL } from 'tests/mocks/storefront-api-mock';
-import { FetchSummary } from './summary';
+import { fetchSummary } from './summary';
 import SummaryModel from '@/storefront/models/summary-model';
+import { expectConfigurationError } from 'tests/async-utilities';
 
 describe('Storefront API Summary', () => {
   class TestSummaryInstance {
-    constructor({
-      configs = {},
-      options = {},
-      storefront = null,
-    } = {}) {
+    constructor({ configs = {}, options = {}, storefront = null } = {}) {
       this.configs = configs;
       this.options = options;
       this.storefront = storefront === null ? MockStorefront() : storefront;
     }
-
-    fetchSummary(...args) {
-      return FetchSummary.apply(this, args);
-    }
   }
-  
-  it ('can fetch preview', async () => {
+
+  it('can fetch preview', async () => {
     const configs = {
       websiteId: 'test-website-id'
     };
@@ -42,7 +35,7 @@ describe('Storefront API Summary', () => {
         {
           description: 'test-plan-id-1',
           planId: 'test-plan-id-1',
-          quantity: 1,
+          quantity: 1
         }
       ]
     };
@@ -51,26 +44,25 @@ describe('Storefront API Summary', () => {
 
     const instance = new TestSummaryInstance({
       configs,
-      options,
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'preview');
 
-    const response = await instance.fetchSummary();
-    
+    const response = await fetchSummary({ state: instance });
+
     expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
     expect(instance.storefront.purchase.preview).toBeCalledWith({
       data: {
         items: options.intent.items,
-        websiteId: configs.websiteId,
+        websiteId: configs.websiteId
       }
     });
     expect(response).toBeInstanceOf(SummaryModel);
     expect(response).toEqual(new SummaryModel(testSummary));
-    
   });
 
-  it ('Adds billing address to preview payload', async () => {
+  it('Adds billing address to preview payload', async () => {
     const configs = {
       websiteId: 'test-website-id'
     };
@@ -90,28 +82,29 @@ describe('Storefront API Summary', () => {
     };
     const instance = new TestSummaryInstance({
       configs,
-      options,
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'preview');
 
-    await instance.fetchSummary({
+    await fetchSummary({
       data: {
-        billingAddress,
-      }
+        billingAddress
+      },
+      state: instance
     });
-    
+
     expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
     expect(instance.storefront.purchase.preview).toBeCalledWith({
       data: {
         items: options.intent.items,
         websiteId: configs.websiteId,
-        billingAddress,
+        billingAddress
       }
     });
   });
 
-  it ('Adds delivery address to preview payload', async () => {
+  it('Adds delivery address to preview payload', async () => {
     const configs = {
       websiteId: 'test-website-id'
     };
@@ -131,53 +124,47 @@ describe('Storefront API Summary', () => {
     };
     const instance = new TestSummaryInstance({
       configs,
-      options,
+      options
     });
 
     jest.spyOn(instance.storefront.purchase, 'preview');
 
-    await instance.fetchSummary({
+    await fetchSummary({
       data: {
-        deliveryAddress,
-      }
+        deliveryAddress
+      },
+      state: instance
     });
-    
+
     expect(instance.storefront.purchase.preview).toBeCalledTimes(1);
     expect(instance.storefront.purchase.preview).toBeCalledWith({
       data: {
         items: options.intent.items,
         websiteId: configs.websiteId,
-        deliveryAddress,
+        deliveryAddress
       }
     });
-    
   });
 
-  it ('should throw errors with no configs or options', () => {
-    const NoConfigOrOptionsError = new Error('Could not use Rebilly Instruments configurations or mount options to fetch Rebilly data');
+  it('should throw errors with no configs or options', async () => {
     const noConfigOrOptionsInstance = new TestSummaryInstance({
       configs: null,
-      options: null,
+      options: null
     });
+    await expectConfigurationError(
+      fetchSummary({ state: noConfigOrOptionsInstance })
+    );
+
     const noConfigInstance = new TestSummaryInstance({
       configs: null,
-      options: {},
+      options: {}
     });
+    await expectConfigurationError(fetchSummary({ state: noConfigInstance }));
+
     const noOptionsInstance = new TestSummaryInstance({
       configs: {},
-      options: null,
+      options: null
     });
-
-    expect(async () => {
-      await noConfigOrOptionsInstance.fetchSummary();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noConfigInstance.fetchSummary();
-    }).rejects.toEqual(NoConfigOrOptionsError);
-
-    expect(async () => {
-      await noOptionsInstance.fetchSummary();
-    }).rejects.toEqual(NoConfigOrOptionsError);
+    await expectConfigurationError(fetchSummary({ state: noOptionsInstance }));
   });
 });