@ordergroove/offers 2.44.0 → 2.44.1-alpha-PR-1166-3.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordergroove/offers",
-  "version": "2.44.0",
+  "version": "2.44.1-alpha-PR-1166-3.30+930d1b8c",
   "description": "offer state component",
   "author": "Eugenio Lattanzio <eugenio63@gmail.com>",
   "homepage": "https://github.com/ordergroove/plush-toys#readme",
@@ -49,5 +49,5 @@
     "@ordergroove/offers-templates": "^0.9.7",
     "@types/lodash.memoize": "^4.1.9"
   },
-  "gitHead": "6920106790e66edb68d2f452825f9dc4be5911d4"
+  "gitHead": "930d1b8c0307645ab97fbbc3a59ed98fae26bd6d"
 }

package/src/components/FrequencyStatus.js

@@ -1,9 +1,12 @@
 import { html, css } from 'lit-element';
 import {
-  makeProductFrequencySelector,
+  makeProductFrequencyOptedInSelector,
   makeOptedinSelector,
-  configSelector,
+  getFallbackValue,
   templatesSelector,
+  makeProductSpecificDefaultFrequencySelector,
+  makeProductFrequenciesSelector,
+  makeProductFrequencyOptionsSelector,
   makeProductDefaultFrequencySelector
 } from '../core/selectors';
 import { connect } from '../core/connect';
@@ -89,14 +92,14 @@ export class FrequencyStatus extends withProduct(TemplateElement) {
 
 export const mapStateToProps = (state, ownProps) => ({
   subscribed: makeOptedinSelector(ownProps.product)(state),
-  frequency: makeProductFrequencySelector(ownProps.product)(state),
-  productDefaultFrequency: makeProductDefaultFrequencySelector((ownProps.product || {}).id)(state),
-  configDefaultFrequency: state.config?.defaultFrequency,
-  frequenciesText: state.config?.frequenciesText,
-  config: state.config,
-  ...configSelector(state, ownProps, 'frequencies'),
-  ...configSelector(state, ownProps, 'defaultFrequency'),
-  ...templatesSelector(state, ownProps)
+  frequency: makeProductFrequencyOptedInSelector(ownProps.product)(state),
+  productDefaultFrequency: makeProductSpecificDefaultFrequencySelector((ownProps.product || {}).id)(state),
+  frequencies:
+    makeProductFrequencyOptionsSelector(ownProps.product?.id)(state) || getFallbackValue(ownProps, 'frequencies'),
+  defaultFrequency:
+    makeProductDefaultFrequencySelector(ownProps.product?.id)(state) || getFallbackValue(ownProps, 'defaultFrequency'),
+  ...templatesSelector(state, ownProps),
+  productFrequencies: makeProductFrequenciesSelector(ownProps.product)(state)
 });
 
 export const ConnectedFrequencyStatus = connect(mapStateToProps)(FrequencyStatus);

package/src/components/Offer.js

@@ -12,14 +12,16 @@ import {
 } from '../core/actions';
 import {
   isSameProduct,
-  configSelector,
+  getFallbackValue,
   templatesSelector,
   makeOptedoutSelector,
-  makeProductFrequencySelector,
-  makeProductDefaultFrequencySelector,
+  makeProductFrequencyOptedInSelector,
+  makeProductSpecificDefaultFrequencySelector,
   optedinSelector,
   autoshipSelector,
-  makeOptedinSelector
+  makeOptedinSelector,
+  kebabCase,
+  makeProductDefaultFrequencySelector
 } from '../core/selectors';
 import { product as productProp, auth as authProp } from '../core/props';
 import { TemplateElement } from '../core/base';
@@ -339,12 +341,6 @@ export class Offer extends TemplateElement {
       }
     }
 
-    // product-specific frequency lists are not supported in cart offers
-    if (this.isCart && this.config?.hasProductSpecificFrequencies) {
-      logProductSpecificFrequencyListWarning();
-      return false;
-    }
-
     return true;
   }
 
@@ -368,7 +364,27 @@ export class Offer extends TemplateElement {
       return freq.currentFrequency;
     }
 
-    return this.getOption('defaultFrequency');
+    // not certain if this logic was used or not -- the following code was inlined from a shared function that was only used here
+    const attributeValue = this.getValueFromAttribute('defaultFrequency');
+    if (attributeValue) {
+      return attributeValue;
+    }
+
+    if (this.template && this.template.config && typeof this.template.config.defaultFrequency !== 'undefined') {
+      return this.template.config.defaultFrequency;
+    }
+
+    return this.configDefaultFrequency;
+  }
+
+  getValueFromAttribute(key) {
+    const attrName = kebabCase(key);
+    if (this.hasAttribute(attrName)) {
+      const attr = this.getAttribute(attrName);
+      if (attr.toString().toLowerCase() === 'true') return true;
+      if (attr.toString().toLowerCase() === 'false') return false;
+      return attr;
+    }
   }
 }
 
@@ -376,9 +392,12 @@ export const mapStateToProps = (state, ownProps) => ({
   config: state.config,
   auth: state.auth,
   offerId: ((state.productOffer || {})[(ownProps.product || {}).id] || [])[0],
-  productFrequency: makeProductFrequencySelector(ownProps.product)(state),
-  productDefaultFrequency: makeProductDefaultFrequencySelector((ownProps.product || {}).id)(state),
-  ...configSelector(state, ownProps, 'autoshipByDefault', autoshipSelector(state)[(ownProps.product || {}).id]),
+  configDefaultFrequency: makeProductDefaultFrequencySelector(ownProps.product?.id)(state),
+  productFrequency: makeProductFrequencyOptedInSelector(ownProps.product)(state),
+  productDefaultFrequency: makeProductSpecificDefaultFrequencySelector((ownProps.product || {}).id)(state),
+  autoshipByDefault:
+    (state.config && state.config.autoshipByDefault) ||
+    getFallbackValue(ownProps, 'autoshipByDefault', autoshipSelector(state)[(ownProps.product || {}).id]),
   ...(makeOptedoutSelector(ownProps.product)(state) && { autoshipByDefault: false }),
   optedin: optedinSelector(state),
   subscribed: makeOptedinSelector(ownProps.product)(state),

package/src/components/OptinButton.js

@@ -21,7 +21,7 @@ export class OptinButton extends OptinStatus {
     if (changed.has('subscribed') || changed.has('frequencies')) {
       if (platform.shopify_selling_plans && this.store) {
         let buttonFreq = this.getAttribute('default-frequency');
-        buttonFreq = frequencyToSellingPlan(buttonFreq, this.store.getState().config);
+        buttonFreq = frequencyToSellingPlan(buttonFreq, this.productFrequencies);
         this.sellingPlanFreq = buttonFreq;
       }
       this.frequencyMatch = this.frequency === this.optinFrequency;
@@ -40,7 +40,7 @@ export class OptinButton extends OptinStatus {
       freq = this.offer ? this.offer.defaultFrequency : this.defaultFrequency;
     }
     if (platform.shopify_selling_plans && this.store) {
-      freq = frequencyToSellingPlan(freq, this.store.getState().config);
+      freq = frequencyToSellingPlan(freq, this.productFrequencies);
     }
 
     return freq;

package/src/components/OptinSelect.js

@@ -5,7 +5,7 @@ import { OptinStatus, mapStateToProps as mapStateToPropsOptinStatus } from './Op
 import { mapStateToProps, frequencyText } from './FrequencyStatus';
 import { connect } from '../core/connect';
 import { defaultFrequency } from '../core/props';
-import { configSelector } from '../core/selectors';
+import { getFallbackValue, makeProductFrequencyOptionsSelector } from '../core/selectors';
 
 export class OptinSelect extends withChildOptions(OptinStatus) {
   static get properties() {
@@ -51,14 +51,13 @@ export class OptinSelect extends withChildOptions(OptinStatus) {
     const { options: childOptions } = this.childOptions;
     let options;
     if (this.frequencies?.length) {
+      const { frequenciesText } = this.productFrequencies;
       options = [
         ...([childOptions.find(option => option.value === 'optedOut')] || []),
         ...this.frequencies.map((value, ix) => ({
           value,
           text:
-            this.frequenciesText && ix in this.frequenciesText
-              ? this.frequenciesText[ix]
-              : frequencyText(value, this.defaultFrequency)
+            frequenciesText && ix in frequenciesText ? frequenciesText[ix] : frequencyText(value, this.defaultFrequency)
         }))
       ];
     } else {
@@ -79,7 +78,8 @@ export const ConnectedOptinSelect = connect(
   (state, ownProps) => ({
     ...mapStateToPropsOptinStatus(state, ownProps),
     ...mapStateToProps(state, ownProps),
-    ...configSelector(state, ownProps, 'frequencies')
+    frequencies:
+      makeProductFrequencyOptionsSelector(ownProps.product?.id)(state) || getFallbackValue(ownProps, 'frequencies')
   }),
   { productChangeFrequency, optoutProduct }
 )(OptinSelect);

package/src/components/OptinStatus.js

@@ -1,11 +1,14 @@
 import { html, css } from 'lit-element';
 import {
   makeOptedinSelector,
-  makeProductDefaultFrequencySelector,
+  makeProductSpecificDefaultFrequencySelector,
   makeProductPrepaidShipmentsOptedInSelector,
-  makeProductFrequencySelector,
-  configSelector,
-  templatesSelector
+  makeProductFrequencyOptedInSelector,
+  getFallbackValue,
+  templatesSelector,
+  makeProductFrequenciesSelector,
+  makeProductDefaultFrequencySelector,
+  makeProductFrequencyOptionsSelector
 } from '../core/selectors';
 import { connect } from '../core/connect';
 import { subscribed } from '../core/props';
@@ -130,12 +133,15 @@ export class OptinStatus extends withProduct(TemplateElement) {
 
 export const mapStateToProps = (state, ownProps = {}) => ({
   subscribed: makeOptedinSelector(ownProps.product)(state),
-  frequency: makeProductFrequencySelector(ownProps.product)(state),
-  productDefaultFrequency: makeProductDefaultFrequencySelector((ownProps.product || {}).id)(state),
+  frequency: makeProductFrequencyOptedInSelector(ownProps.product)(state),
+  productDefaultFrequency: makeProductSpecificDefaultFrequencySelector((ownProps.product || {}).id)(state),
   prepaidShipmentsOptedIn: makeProductPrepaidShipmentsOptedInSelector(ownProps.product)(state),
-  ...configSelector(state, ownProps, 'defaultFrequency'),
-  ...configSelector(state, ownProps, 'frequencies'),
-  ...templatesSelector(state, ownProps)
+  defaultFrequency:
+    makeProductDefaultFrequencySelector(ownProps.product?.id)(state) || getFallbackValue(ownProps, 'defaultFrequency'),
+  frequencies:
+    makeProductFrequencyOptionsSelector(ownProps.product?.id)(state) || getFallbackValue(ownProps, 'frequencies'),
+  ...templatesSelector(state, ownProps),
+  productFrequencies: makeProductFrequenciesSelector(ownProps.product)(state)
 });
 
 export const ConnectedOptinStatus = connect(mapStateToProps)(OptinStatus);

package/src/components/Price.js

@@ -3,7 +3,7 @@ import { connect } from '../core/connect';
 
 import { withProduct } from '../core/resolveProperties';
 import { TemplateElement } from '../core/base';
-import { makeProductFrequencySelector } from '../core/selectors';
+import { makeProductDefaultFrequencySelector, makeProductFrequencyOptedInSelector } from '../core/selectors';
 import { safeProductId } from '../core/utils';
 
 export class Price extends withProduct(TemplateElement) {
@@ -81,8 +81,8 @@ export class Price extends withProduct(TemplateElement) {
 }
 const mapStateToProps = (state, ownProps) => ({
   productPlans: state.productPlans,
-  configDefaultFrequency: state.config?.defaultFrequency,
-  frequency: makeProductFrequencySelector(ownProps.product)(state)
+  configDefaultFrequency: makeProductDefaultFrequencySelector(ownProps.product?.id)(state),
+  frequency: makeProductFrequencyOptedInSelector(ownProps.product)(state)
 });
 
 export default connect(mapStateToProps)(Price);

package/src/components/SelectFrequency.js

@@ -65,8 +65,12 @@ export class SelectFrequency extends withChildOptions(FrequencyStatus) {
     }
 
     // this runs for shopify selling plans translated to freq
-    if (this.config?.frequencies?.length && result && this.config?.frequenciesEveryPeriod?.length) {
-      return frequencyToSellingPlan(result, this.config);
+    if (
+      this.productFrequencies?.frequencies?.length &&
+      result &&
+      this.productFrequencies?.frequenciesEveryPeriod?.length
+    ) {
+      return frequencyToSellingPlan(result, this.productFrequencies);
     }
 
     return result;
@@ -90,10 +94,11 @@ export class SelectFrequency extends withChildOptions(FrequencyStatus) {
     if (this.frequencies?.length) {
       options = this.frequencies.map((value, ix) => {
         let text;
-        if (this.config.frequenciesEveryPeriod && ix in this.config.frequenciesEveryPeriod) {
-          text = frequencyText(this.config.frequenciesEveryPeriod[ix], defaultFrequency);
-        } else if (this.frequenciesText && ix in this.frequenciesText) {
-          text = this.frequenciesText[ix];
+        const { frequenciesEveryPeriod, frequenciesText } = this.productFrequencies;
+        if (frequenciesEveryPeriod && ix in frequenciesEveryPeriod) {
+          text = frequencyText(frequenciesEveryPeriod[ix], defaultFrequency);
+        } else if (frequenciesText && ix in frequenciesText) {
+          text = frequenciesText[ix];
         } else {
           text = frequencyText(value, this.defaultFrequency);
         }

package/src/components/TestWizard.js

@@ -194,50 +194,54 @@ export class TestWizard extends LitElement {
       const offer = document.querySelectorAll('og-offer')[ix];
       const productId = offer.product.id;
       offer.store.dispatch(
-        actions.receiveOffer({
-          in_stock: { [productId]: inStock },
-          eligibility_groups: { [productId]: groups },
-          result: 'success',
-          autoship: { [productId]: autoship },
-          module_view: { regular: '58a01e9aacbe40389b5c7325d79091bb' },
-          modifiers: {},
-          incentives_display: {
-            '47c01e9aacbe40389b5c7325d79091aa': {
-              field: 'sub_total',
-              object: 'order',
-              type: 'Discount Percent',
-              value: 5
+        actions.receiveOffer(
+          {
+            in_stock: { [productId]: inStock },
+            eligibility_groups: { [productId]: groups },
+            result: 'success',
+            autoship: { [productId]: autoship },
+            module_view: { regular: '58a01e9aacbe40389b5c7325d79091bb' },
+            modifiers: {},
+            incentives_display: {
+              '47c01e9aacbe40389b5c7325d79091aa': {
+                field: 'sub_total',
+                object: 'order',
+                type: 'Discount Percent',
+                value: 5
+              },
+              e6534b9d877f41e586c37b7d8abc3a58: {
+                field: 'total_price',
+                object: 'item',
+                type: 'Discount Percent',
+                value: 5
+              },
+              f35e842710b24929922db4a529eecd40: {
+                field: 'total_price',
+                object: 'item',
+                type: 'Discount Percent',
+                value: 10
+              },
+              '5be321d7c17f4e18a757212b9a20bfcc': {
+                field: 'total_price',
+                object: 'item',
+                type: 'Discount Percent',
+                value: 1
+              }
             },
-            e6534b9d877f41e586c37b7d8abc3a58: {
-              field: 'total_price',
-              object: 'item',
-              type: 'Discount Percent',
-              value: 5
-            },
-            f35e842710b24929922db4a529eecd40: {
-              field: 'total_price',
-              object: 'item',
-              type: 'Discount Percent',
-              value: 10
-            },
-            '5be321d7c17f4e18a757212b9a20bfcc': {
-              field: 'total_price',
-              object: 'item',
-              type: 'Discount Percent',
-              value: 1
+            incentives: {
+              [productId]: {
+                initial: ['5be321d7c17f4e18a757212b9a20bfcc'],
+                ongoing: [
+                  'e6534b9d877f41e586c37b7d8abc3a58',
+                  '47c01e9aacbe40389b5c7325d79091aa',
+                  'f35e842710b24929922db4a529eecd40'
+                ]
+              }
             }
           },
-          incentives: {
-            [productId]: {
-              initial: ['5be321d7c17f4e18a757212b9a20bfcc'],
-              ongoing: [
-                'e6534b9d877f41e586c37b7d8abc3a58',
-                '47c01e9aacbe40389b5c7325d79091aa',
-                'f35e842710b24929922db4a529eecd40'
-              ]
-            }
-          }
-        })
+          {},
+          productId
+        )
       );
       this.runTests();
     };

package/src/components/UpsellModal.js

@@ -2,7 +2,12 @@ import { html } from 'lit-element';
 import { concludeUpsell, createIu } from '../core/actions';
 import { connect } from '../core/connect';
 import { auth, defaultFrequency } from '../core/props';
-import { makeOptedinSelector, makeProductFrequencySelector, configSelector } from '../core/selectors';
+import {
+  makeOptedinSelector,
+  makeProductFrequencyOptedInSelector,
+  getFallbackValue,
+  makeProductDefaultFrequencySelector
+} from '../core/selectors';
 import { withProduct } from '../core/resolveProperties';
 import { TemplateElement } from '../core/base';
 
@@ -102,8 +107,9 @@ export const mapStateToProps = (state, ownProps) => ({
   auth: state.auth,
   offerId: state.offerId,
   subscribed: makeOptedinSelector(ownProps.product)(state),
-  frequency: makeProductFrequencySelector(ownProps.product)(state),
-  ...configSelector(state, ownProps, 'defaultFrequency'),
+  frequency: makeProductFrequencyOptedInSelector(ownProps.product)(state),
+  defaultFrequency:
+    makeProductDefaultFrequencySelector(ownProps.product?.id)(state) || getFallbackValue(ownProps, 'defaultFrequency'),
   nextUpcomingOrder: state.previewUpsellOffer ? { public_id: 'preview-order-id' } : state.nextUpcomingOrder,
   isPreview: state.previewUpsellOffer
 });

package/src/components/__tests__/Offer.spec.js

@@ -369,22 +369,3 @@ describe('multi-currency', () => {
     assertOfferShown(element);
   });
 });
-
-describe('product specific frequencies', () => {
-  it('should hide the offer when on cart', async () => {
-    const element = await getOfferElement({
-      hasProductSpecificFrequencies: true
-    });
-    element.isCart = true;
-    await element.updateComplete;
-
-    assertOfferHidden(element);
-  });
-
-  it('should show the offer when not on cart', async () => {
-    const element = await getOfferElement({
-      hasProductSpecificFrequencies: true
-    });
-    assertOfferShown(element);
-  });
-});

package/src/components/__tests__/OptinStatus.spec.js

@@ -29,10 +29,23 @@ describe('OptinStatus', () => {
 describe('mapStateToProps', () => {
   it('should pick defaultFrequency from config', () => {
     expect(
-      mapStateToProps({
-        config: { defaultFrequency: 'foo from config' },
-        locale: { defaultFrequency: 'foo from locale' }
-      })
+      mapStateToProps(
+        {
+          config: {
+            productFrequencies: {
+              123: {
+                defaultFrequency: 'foo from config'
+              }
+            }
+          },
+          locale: { defaultFrequency: 'foo from locale' }
+        },
+        {
+          product: {
+            id: '123'
+          }
+        }
+      )
     ).toEqual(jasmine.objectContaining({ defaultFrequency: 'foo from config' }));
   });
 

package/src/core/__tests__/actions.spec.js

@@ -19,7 +19,8 @@ import {
   receiveCreateOneTime,
   createIu,
   requestConvertOneTimeToSubscription,
-  receiveConvertOneTime
+  receiveConvertOneTime,
+  productChangePrepaidShipments
 } from '../actions';
 import * as constants from '../constants';
 import { api } from '../api';
@@ -246,6 +247,51 @@ describe('redux actions', function () {
       expect(dispatch.calls.argsFor(1)[0]).toEqual(unauthorized(new Error('some reason')));
     });
   });
+
+  describe('actions.productChangePrepaidShipments', () => {
+    function changePrepaidShipments(prepaidShipments) {
+      const getState = jasmine.createSpy('getState').and.returnValue({
+        config: {
+          prepaidSellingPlans: {
+            'yum prepaid id': [
+              { numberShipments: 3, sellingPlan: 'yum prepaid selling plan id 1' },
+              {
+                numberShipments: 4,
+                sellingPlan: 'yum prepaid selling plan id 2'
+              }
+            ]
+          },
+          productFrequencies: {
+            'yum prepaid id': {
+              frequencies: ['yum selling plan id 1']
+            }
+          }
+        }
+      });
+      const dispatch = jasmine.createSpy('dispatch');
+      productChangePrepaidShipments(
+        {
+          id: 'yum prepaid id'
+        },
+        prepaidShipments,
+        {}
+      )(dispatch, getState);
+
+      return {
+        dispatchedFrequency: dispatch.calls.argsFor(0)[0]?.payload.frequency
+      };
+    }
+
+    it('sets frequency to the corresponding selling plan', () => {
+      const { dispatchedFrequency } = changePrepaidShipments(4);
+      expect(dispatchedFrequency).toEqual('yum prepaid selling plan id 2');
+    });
+
+    it('sets frequency to the first frequency when prepaidShipments is null', () => {
+      const { dispatchedFrequency } = changePrepaidShipments(null);
+      expect(dispatchedFrequency).toEqual('yum selling plan id 1');
+    });
+  });
 });
 
 describe('actions.iu', () => {

package/src/core/__tests__/base.spec.js

@@ -10,84 +10,7 @@ class MockElement extends TemplateElement {
 
 customElements.define('og-test-element', MockElement);
 describe('TemplateElement', () => {
-  describe('getOption', () => {
-    it('should get option from attribute', () => {
-      const el = new MockElement();
-      el.setAttribute('foo', 'bar');
-      expect(el.getOption('foo')).toEqual('bar');
-    });
-
-    it('should return undefined given element does not have attribute', () => {
-      const el = new MockElement();
-      el.setAttribute('yum', 'egg');
-      expect(el.getOption('clam')).toBeUndefined();
-    });
-
-    it('should return boolean given element has attribute with true string', () => {
-      [
-        ['one', 'true'],
-        ['two', 'True']
-      ].forEach(([attrName, attrValue]) => {
-        const el = new MockElement();
-        el.setAttribute(attrName, attrValue);
-        expect(el.getOption(attrName)).toBe(true);
-      });
-    });
-
-    it('should return boolean given element has attribute with false string', () => {
-      [
-        ['three', 'false'],
-        ['four', 'False']
-      ].forEach(([attrName, attrValue]) => {
-        const el = new MockElement();
-        el.setAttribute(attrName, attrValue);
-        expect(el.getOption(attrName)).toBe(false);
-      });
-    });
-
-    it('should get option from attribute in kebabCase', () => {
-      const el = new MockElement();
-      el.setAttribute('foo-bar', 'bar');
-      expect(el.getOption('fooBar')).toEqual('bar');
-    });
-
-    it('should get option from config', () => {
-      const el = new MockElement();
-      el.config = { fooBar: 'bar' };
-      expect(el.getOption('fooBar')).toEqual('bar');
-    });
-
-    it('should get option from template.config', () => {
-      const el = new MockElement();
-      el.template = { config: { fooBar: 'bar' } };
-      expect(el.getOption('fooBar')).toEqual('bar');
-    });
-
-    it('should template.config take precedence over config', () => {
-      const el = new MockElement();
-      el.config = { fooBar: 'baz' };
-      el.template = { config: { fooBar: 'bar' } };
-      expect(el.getOption('fooBar')).toEqual('bar');
-    });
-
-    it('should attribute take precedence over template.config', () => {
-      const el = new MockElement();
-      el.setAttribute('foo-bar', 'foo');
-      el.config = { fooBar: 'baz' };
-      el.template = { config: { fooBar: 'bar' } };
-      expect(el.getOption('fooBar')).toEqual('foo');
-    });
-  });
-
   describe('applyTemplate', () => {
-    it('should attribute take precedence over template.config', () => {
-      const el = new MockElement();
-      el.setAttribute('foo-bar', 'foo');
-      el.config = { fooBar: 'baz' };
-      el.template = { config: { fooBar: 'bar' } };
-      expect(el.getOption('fooBar')).toEqual('foo');
-    });
-
     it('should only set innerHTML if change from prev', () => {
       const el = new MockElement();
       /* eslint no-underscore-dangle: ["error", { "allow": ["_templateMarkup"] }] */

package/src/core/__tests__/offerRequest.spec.js

@@ -4,6 +4,7 @@ import { environment, merchantId, offer, sessionId } from '../reducer';
 import { requestOffer } from '../actions';
 import { createStore, combineReducers, applyMiddleware } from 'redux';
 import { FETCH_RESPONSE_ERROR } from '../constants';
+import thunk from 'redux-thunk';
 
 const mockOfferResponse = (productId, inStock = true, autoship = true, defaultFrequency) => {
   return Promise.resolve({
@@ -44,7 +45,7 @@ describe('offerRequest', () => {
         sessionId: 'x.y.z',
         lastError: null
       },
-      applyMiddleware(offerRequestMiddleware)
+      applyMiddleware(offerRequestMiddleware, thunk)
     );
   });
 

package/src/core/__tests__/selectors.spec.js

@@ -3,7 +3,7 @@ import {
   makeOptedinSelector,
   isSameProduct,
   templatesSelector,
-  makeProductDefaultFrequencySelector,
+  makeProductSpecificDefaultFrequencySelector,
   makeProductPrepaidShipmentOptionsSelector
 } from '../selectors';
 import { stringifyFrequency } from '../api';
@@ -61,25 +61,25 @@ describe('templatesSelector', () => {
   });
 });
 
-describe('makeProductDefaultFrequencySelector', () => {
+describe('makeProductSpecificDefaultFrequencySelector', () => {
   it('should return memoized function', () => {
-    const firsCall = makeProductDefaultFrequencySelector(123);
+    const firsCall = makeProductSpecificDefaultFrequencySelector(123);
     expect(firsCall).toEqual(jasmine.any(Function));
-    expect(firsCall).toBe(makeProductDefaultFrequencySelector(123));
+    expect(firsCall).toBe(makeProductSpecificDefaultFrequencySelector(123));
   });
 
   it('should return null by default', () => {
-    const selectProductDefaultFrequency = makeProductDefaultFrequencySelector(123);
+    const selectProductDefaultFrequency = makeProductSpecificDefaultFrequencySelector(123);
     expect(selectProductDefaultFrequency({})).toEqual(null);
   });
 
   it('should select the product default frequency if there is one', () => {
-    const selectProductDefaultFrequency = makeProductDefaultFrequencySelector(123);
+    const selectProductDefaultFrequency = makeProductSpecificDefaultFrequencySelector(123);
     expect(selectProductDefaultFrequency({ defaultFrequencies: { 123: '2_w' } })).toEqual('2_w');
   });
 
   it('should select the product default frequency if there is one (object frequency)', () => {
-    const selectProductDefaultFrequency = makeProductDefaultFrequencySelector(123);
+    const selectProductDefaultFrequency = makeProductSpecificDefaultFrequencySelector(123);
     const frequency = { every: '2', period: 'w' };
     expect(selectProductDefaultFrequency({ defaultFrequencies: { 123: frequency } })).toEqual(
       stringifyFrequency(frequency)