@ordergroove/offers 2.26.10 → 2.27.1-alpha-PR-634-2.3

package/src/shopify/__tests__/shopifyMiddleware.spec.js

@@ -0,0 +1,126 @@
+import fetchMock from 'fetch-mock';
+import { CART_UPDATED_EVENT, OPTIN_PRODUCT, SETUP_CART } from '../../core/constants';
+import { getOrCreateHidden, synchronizeCartOptin } from '../shopifyMiddleware';
+
+function makeForm(addInput = true) {
+  const element = document.createElement('form');
+  if (addInput) {
+    element.innerHTML = `
+  <input value="123456" name="selling_plan" type="hidden">
+  `;
+  }
+  document.body.appendChild(element);
+  return element;
+}
+
+describe('getOrCreateHidden', () => {
+  it('should update the input value for an existing input', () => {
+    const formElement = makeForm(true);
+    getOrCreateHidden(formElement, 'selling_plan', '098765');
+    const newInput = formElement.querySelector(`[name="selling_plan"]`);
+    expect(newInput.getAttribute('value')).toEqual('098765');
+  });
+
+  it('should create an input with the correct value when a value is provided and no input exists', () => {
+    const formElement = makeForm(false);
+    getOrCreateHidden(formElement, 'selling_plan', '098765');
+    const newInput = formElement.querySelector(`[name="selling_plan"]`);
+    expect(newInput.getAttribute('value')).toEqual('098765');
+  });
+
+  it('should remove the input if it exists but an empty value is passed', () => {
+    const formElement = makeForm(true);
+    getOrCreateHidden(formElement, 'selling_plan', null);
+    const newInput = formElement.querySelector(`[name="selling_plan"]`);
+    expect(newInput).toBeNull();
+  });
+
+  it('should do nothing if there is no input and there is no value passed', () => {
+    const formElement = makeForm(false);
+    getOrCreateHidden(formElement, 'selling_plan', null);
+    const newInput = formElement.querySelector(`[name="selling_plan"]`);
+    expect(newInput).toBeNull();
+  });
+});
+
+describe('synchronizeCartOptin', () => {
+  let store, offer, frequency, product;
+  beforeEach(() => {
+    store = { dispatch: jasmine.createSpy('dispatch') };
+    offer = document.createElement('some-fake-og-offer');
+
+    offer.isCart = true;
+    offer.setAttribute('product', '38995975209111:original-hash');
+
+    frequency = '1234';
+    product = { id: '38995975209111:original-hash' };
+
+    fetchMock.once(
+      'cart.js',
+      {
+        attributes: {},
+        items: [
+          {
+            quantity: 4,
+            key: '38995975209111:original-hash'
+          }
+        ]
+      },
+      { method: 'GET' }
+    );
+
+    fetchMock.once(
+      'cart/change.js',
+      {
+        attributes: {},
+        items: [
+          {
+            quantity: 4,
+            key: '38995975209111:new-hash'
+          }
+        ]
+      },
+      { method: 'POST' }
+    );
+  });
+
+  afterEach(() => {
+    fetchMock.restore();
+    offer.remove();
+  });
+
+  it('should set new has product id', async () => {
+    await synchronizeCartOptin({ type: OPTIN_PRODUCT, payload: { offer, frequency, product } }, store);
+
+    expect(store.dispatch).toHaveBeenCalledWith({
+      type: SETUP_CART,
+      payload: { attributes: {}, items: [{ quantity: 4, key: '38995975209111:new-hash' }] }
+    });
+    expect(offer.getAttribute('product')).toEqual('38995975209111:new-hash');
+  });
+
+  it('should dispatch cart updated event', async () => {
+    let called;
+    document.addEventListener(CART_UPDATED_EVENT, ev => {
+      called = true;
+    });
+
+    document.body.appendChild(offer);
+
+    await synchronizeCartOptin({ type: OPTIN_PRODUCT, payload: { offer, frequency, product } }, store);
+
+    expect(called).toBeTruthy();
+  });
+
+  it('should pass closest section to shopify api', async () => {
+    const sectionDiv = document.createElement('div');
+    sectionDiv.id = 'shopify-section-123456789';
+    sectionDiv.classList.add('shopify-section');
+    sectionDiv.appendChild(offer);
+    document.body.appendChild(sectionDiv);
+
+    await synchronizeCartOptin({ type: OPTIN_PRODUCT, payload: { offer, frequency, product } }, store);
+    expect(fetchMock.lastOptions().body).toContain('"sections":["123456789"]');
+    sectionDiv.remove();
+  });
+});

package/src/shopify/__tests__/shopifyReducer.spec.js

@@ -0,0 +1,489 @@
+import * as constants from '../../core/constants';
+import * as coreReducers from '../../core/reducer';
+import {
+  autoshipEligible,
+  config,
+  inStock,
+  offer,
+  offerId,
+  optedin,
+  productOffer,
+  productPlans
+} from '../shopifyReducer';
+
+describe('autoshipEligible', () => {
+  it('should return true for each id given action RECEIVE_PRODUCT_PLANS', () => {
+    const actual = autoshipEligible(
+      {},
+      {
+        type: constants.RECEIVE_PRODUCT_PLANS,
+        payload: {
+          'yum product id 1': {},
+          'yum product id 2': {}
+        }
+      }
+    );
+    expect(actual).toEqual({ 'yum product id 1': true, 'yum product id 2': true });
+  });
+
+  it('should return null for each key in items given action SETUP_CART', () => {
+    const actual = autoshipEligible(
+      {},
+      {
+        type: constants.SETUP_CART,
+        payload: {
+          items: [
+            {
+              key: 'yum key 1'
+            },
+            {
+              key: 'yum key 2'
+            }
+          ]
+        }
+      }
+    );
+    expect(actual).toEqual({ 'yum key 1': null, 'yum key 2': null });
+  });
+
+  it('should return true for each product and variant given action SETUP_PRODUCT and products have selling plan allocations', () => {
+    const actual = autoshipEligible(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          id: 'yum product id',
+          selling_plan_allocations: [{ 'yum key': 'yum value' }],
+          variants: [
+            {
+              id: 'yum variant id',
+              selling_plan_allocations: [{ 'yum key': 'yum value' }]
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual({ 'yum product id': true, 'yum variant id': true });
+  });
+
+  it('should return false for each product and variant given action SETUP_PRODUCT and products have no selling plan allocations', () => {
+    const actual = autoshipEligible(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          id: 'yum product id',
+          selling_plan_allocations: [],
+          variants: [
+            {
+              id: 'yum variant id',
+              selling_plan_allocations: []
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual({ 'yum product id': false, 'yum variant id': false });
+  });
+
+  it('should return unmodified state given unsupported action', () => {
+    const actual = autoshipEligible(
+      { 'yum existing key': 'yum existing value' },
+      {
+        type: 'yum unsupported action',
+        payload: {}
+      }
+    );
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});
+
+describe('config', () => {
+  it('should return unique frequencies given action RECEIVE_PRODUCT_PLANS', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.RECEIVE_PRODUCT_PLANS,
+        payload: {
+          'product plan id': { '1_1': {}, '3_1': {} }
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequencies: ['1_1', '3_1']
+      })
+    );
+  });
+
+  it('should return first selling plan id as default frequency given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          selling_plan_groups: [
+            {
+              name: 'Subscribe and Save',
+              selling_plans: [
+                {
+                  id: 'yum selling plan id 1'
+                },
+                {
+                  id: 'yum selling plan id 2'
+                }
+              ]
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        defaultFrequency: 'yum selling plan id 1'
+      })
+    );
+  });
+
+  it('should return selling plan ids as frequencies given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          selling_plan_groups: [
+            {
+              name: 'Subscribe and Save',
+              selling_plans: [
+                {
+                  id: 'yum selling plan id 1'
+                },
+                {
+                  id: 'yum selling plan id 2'
+                }
+              ]
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequencies: ['yum selling plan id 1', 'yum selling plan id 2']
+      })
+    );
+  });
+
+  it('should return values of first OG selling plan group as frequencies text given action SETUP_PRODUCT', () => {
+    const actual = config(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          selling_plan_groups: [
+            {
+              name: 'Old Selling Plan Group',
+              options: [{ values: 'old yum values' }],
+              selling_plans: [
+                {
+                  id: 'old yum selling plan id'
+                }
+              ]
+            },
+            {
+              name: 'Subscribe and Save',
+              options: [{ values: 'yum values' }],
+              selling_plans: [
+                {
+                  id: 'yum selling plan id'
+                }
+              ]
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual(
+      jasmine.objectContaining({
+        frequenciesText: 'yum values'
+      })
+    );
+  });
+
+  it('should return unmodified state given unsupported action', () => {
+    const actual = config(
+      { 'yum existing key': 'yum existing value' },
+      {
+        type: 'yum unsupported action',
+        payload: {}
+      }
+    );
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});
+
+describe('inStock', () => {
+  it('should return true for each id given action RECEIVE_PRODUCT_PLANS', () => {
+    const actual = inStock(
+      {},
+      {
+        type: constants.RECEIVE_PRODUCT_PLANS,
+        payload: {
+          'yum product id 1': {},
+          'yum product id 2': {}
+        }
+      }
+    );
+    expect(actual).toEqual({ 'yum product id 1': true, 'yum product id 2': true });
+  });
+
+  it('should return null item key given action SETUP_CART', () => {
+    const actual = inStock(
+      {},
+      {
+        type: constants.SETUP_CART,
+        payload: {
+          items: [{ key: 'yum item key 1' }, { key: 'yum item key 2' }]
+        }
+      }
+    );
+    expect(actual).toEqual({ 'yum item key 1': null, 'yum item key 2': null });
+  });
+
+  it('should return true for each available product and variant given action SETUP_PRODUCT', () => {
+    const actual = inStock(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          id: 'yum product id',
+          available: true,
+          variants: [
+            {
+              id: 'yum variant id',
+              available: true
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual({
+      'yum product id': true,
+      'yum variant id': true
+    });
+  });
+
+  it('should return false for each unavailable product and variant given action SETUP_PRODUCT', () => {
+    const actual = inStock(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          id: 'yum product id',
+          available: false,
+          variants: [
+            {
+              id: 'yum variant id',
+              available: false
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual({
+      'yum product id': false,
+      'yum variant id': false
+    });
+  });
+
+  it('should return unmodified state given unsupported action', () => {
+    const actual = inStock(
+      { 'yum existing key': 'yum existing value' },
+      {
+        type: 'yum unsupported action',
+        payload: {}
+      }
+    );
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});
+
+describe('offer', () => {
+  it('should return unmodified state', () => {
+    const actual = offer({ 'yum existing key': 'yum existing value' });
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});
+
+describe('offerId', () => {
+  it('should return shopify constant', () => {
+    const actual = offerId();
+
+    expect(actual).toEqual('native-shopify-offer');
+  });
+});
+
+describe('optedin', () => {
+  it('should return optins given action SETUP_CART', () => {
+    const actual = optedin(
+      {},
+      {
+        type: constants.SETUP_CART,
+        payload: {
+          items: [
+            {
+              key: 'yum item key 1',
+              selling_plan_allocation: {
+                selling_plan: {
+                  id: 'yum selling plan id 1'
+                }
+              }
+            },
+            {
+              key: 'yum item key 2',
+              selling_plan_allocation: {
+                selling_plan: {
+                  id: 'yum selling plan id 2'
+                }
+              }
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual([
+      {
+        id: 'yum item key 1',
+        frequency: 'yum selling plan id 1'
+      },
+      {
+        id: 'yum item key 2',
+        frequency: 'yum selling plan id 2'
+      }
+    ]);
+  });
+
+  it('should return unmodified state given unsupported action', () => {
+    const actual = optedin(
+      { 'yum existing key': 'yum existing value' },
+      {
+        type: 'yum unsupported action',
+        payload: {}
+      }
+    );
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});
+
+describe('productOffer', () => {
+  it('should return unmodified state', () => {
+    const actual = productOffer({ 'yum existing key': 'yum existing value' });
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});
+
+describe('productPlans', () => {
+  it('should product plans with formatted discounts given action SETUP_PRODUCT', () => {
+    const actual = productPlans(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          id: 'yum product id',
+          selling_plan_allocations: [
+            {
+              selling_plan_id: 'yum selling plan id 1',
+              compare_at_price: 100,
+              price: 50,
+              price_adjustments: [
+                {
+                  value: 50,
+                  value_type: 'percentage'
+                }
+              ]
+            }
+          ],
+          variants: [
+            {
+              id: 'yum variant id 1',
+              selling_plan_allocations: [
+                {
+                  selling_plan_id: 'yum selling plan id 2',
+                  compare_at_price: 50,
+                  price: 25,
+                  price_adjustments: [
+                    {
+                      value: 25
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              id: 'yum variant id 2',
+              selling_plan_allocations: [
+                {
+                  selling_plan_id: 'yum selling plan id 3',
+                  compare_at_price: 10,
+                  price: 8,
+                  price_adjustments: []
+                }
+              ]
+            }
+          ]
+        }
+      }
+    );
+
+    expect(actual).toEqual({
+      'yum product id': { 'yum selling plan id 1': ['$1.00', '50%', '$.50'] },
+      'yum variant id 1': {
+        'yum selling plan id 2': ['$.50', '$.25', '$.25']
+      },
+      'yum variant id 2': { 'yum selling plan id 3': ['$.10', '$2', '$8'] }
+    });
+  });
+
+  it('should return payload given action RECEIVE_PRODUCT_PLANS', () => {
+    const actual = productPlans(
+      {},
+      {
+        type: constants.RECEIVE_PRODUCT_PLANS,
+        payload: {
+          'yum key': 'yum value'
+        }
+      }
+    );
+
+    expect(actual).toEqual({
+      'yum key': 'yum value'
+    });
+  });
+
+  it('should return unmodified state given unsupported action', () => {
+    const actual = productPlans(
+      { 'yum existing key': 'yum existing value' },
+      {
+        type: 'yum unsupported action',
+        payload: {}
+      }
+    );
+
+    expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
+  });
+});