@shopgate/pwa-ui-shared 7.32.0-beta.8 → 7.32.0

package/FavoritesButton/spec.js

@@ -1,131 +0,0 @@
-import React from 'react';
-import { act } from 'react-dom/test-utils';
-import { Provider } from 'react-redux';
-import configureStore from 'redux-mock-store';
-import { mount } from 'enzyme';
-import mockRenderOptions from '@shopgate/pwa-common/helpers/mocks/mockRenderOptions';
-import appConfig from '@shopgate/pwa-common/helpers/config';
-import FavoritesButton from "./index";
-import { mockedStateEmpty, mockedStateOnList, mockedStateNotOnList } from "./mock";
-import { jsx as _jsx } from "react/jsx-runtime";
-const mockedStore = configureStore();
-const dispatcher = jest.fn();
-jest.mock('@shopgate/pwa-common/helpers/config');
-jest.mock('@shopgate/pwa-common-commerce/favorites/selectors/index', () => ({
-  isFetching: () => false
-}));
-beforeEach(() => {
-  jest.resetModules();
-});
-describe('<FavoritesButton />', () => {
-  let component = null;
-
-  /**
-   * Creates component with provided store state.
-   * @param {Object} mockedState Mocked stage.
-   * @param {Object} props Additional props.
-   * @return {ReactWrapper}
-   */
-  const createComponent = (mockedState, props = {
-    active: false
-  }) => {
-    const store = mockedStore(mockedState);
-    store.dispatch = dispatcher;
-    return mount(/*#__PURE__*/_jsx(Provider, {
-      store: store,
-      children: /*#__PURE__*/_jsx(FavoritesButton, {
-        ...props
-      })
-    }), mockRenderOptions);
-  };
-  beforeEach(() => {
-    dispatcher.mockReset();
-  });
-  it('should only render when no favorites set', () => {
-    component = createComponent(mockedStateEmpty);
-    expect(component).toMatchSnapshot();
-    expect(component.find('Heart').exists()).toBe(false);
-    expect(component.find('HeartOutline').exists()).toBe(true);
-    component.find('button').simulate('click');
-  });
-  it('should render when favorites set', () => {
-    component = createComponent(mockedStateOnList, {
-      active: true
-    });
-    expect(component).toMatchSnapshot();
-    expect(component.find('Heart').exists()).toBe(true);
-    expect(component.find('HeartOutline').exists()).toBe(false);
-  });
-  it('should add to favorites on click', () => {
-    component = createComponent(mockedStateNotOnList, {
-      productId: '1',
-      active: false
-    });
-    expect(component.find('Heart').exists()).toBe(false);
-    expect(component.find('HeartOutline').exists()).toBe(true);
-    component.find('button').simulate('click');
-    component.update();
-    expect(dispatcher).toHaveBeenCalled();
-  });
-  it('should remove from favorites on click', done => {
-    component = createComponent(mockedStateOnList, {
-      productId: '1',
-      active: true
-    });
-    expect(component.find('Heart').exists()).toBe(true);
-    expect(component.find('HeartOutline').exists()).toBe(false);
-    component.find('button').simulate('click');
-    component.update();
-    setTimeout(() => {
-      expect(dispatcher).toHaveBeenCalled();
-      done();
-    }, 0);
-  });
-  it('should process ripple complete callback', async () => {
-    const onRippleComplete = jest.fn();
-    component = createComponent(mockedStateOnList, {
-      productId: '1',
-      active: true,
-      onRippleComplete
-    });
-    await act(async () => {
-      component.find('Ripple').invoke('onComplete')();
-    });
-    component.update();
-    expect(onRippleComplete).toHaveBeenCalled();
-  });
-  it('should only react on first click', done => {
-    component = createComponent(mockedStateOnList, {
-      once: true,
-      productId: '1',
-      active: false
-    });
-    component.find('button').simulate('click');
-    component.update();
-    component.find('button').simulate('click');
-    component.update();
-    setTimeout(() => {
-      expect(dispatcher.mock.calls.length).toBe(1);
-      done();
-    }, 1);
-  });
-  it('should only react on both clicks', done => {
-    component = createComponent(mockedStateOnList, {
-      productId: '1',
-      active: false
-    });
-    component.find('button').simulate('click');
-    component.update();
-    component.find('button').simulate('click');
-    component.update();
-    setTimeout(() => {
-      expect(dispatcher.mock.calls.length).toBe(2);
-      done();
-    }, 1);
-  });
-  it('should render null when feature flag is off', () => {
-    jest.spyOn(appConfig, 'hasFavorites', 'get').mockReturnValue(false);
-    component = createComponent(mockedStateOnList);
-    expect(component.isEmptyRender()).toBe(true);
-  });
-});

package/Form/Builder/classes/ActionListener/spec.js

@@ -1,323 +0,0 @@
-import ActionListener from "./index";
-import { ACTION_TYPE_SET_VISIBILITY, ACTION_TYPE_SET_VALUE, ACTION_TYPE_TRANSFORM, ACTION_SET_VALUE_COPY_FROM, ACTION_RULE_TYPE_ONE_OF } from "./constants";
-jest.mock('@shopgate/pwa-core/helpers', () => ({
-  logger: {
-    error: () => {}
-  }
-}));
-
-/**
- * Mock for provinces
- * @returns {{ST: string}}
- */
-const mockGetProvincesList = () => ({
-  ST: 'State',
-  DF: 'Default-State'
-});
-describe('ActionListener', () => {
-  describe('createSetVisibilityHandler', () => {
-    it('should handle visibility changes correctly', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'province'
-      };
-      const action = {
-        type: ACTION_TYPE_SET_VISIBILITY,
-        rules: [{
-          context: 'country',
-          type: ACTION_RULE_TYPE_ONE_OF,
-          data: ['US']
-        }]
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handler = actionListener.createSetVisibilityHandler(element, action);
-      let nextState;
-      let expected;
-
-      // Perform "make visible" test
-      nextState = {
-        formData: {
-          country: 'US'
-        }
-      };
-      expected = {
-        formData: {
-          country: 'US'
-        },
-        elementVisibility: {
-          province: true
-        }
-      };
-      expect(handler({}, nextState)).toEqual(expected);
-
-      // Perform "make invisible" test
-      nextState = {
-        formData: {
-          country: ''
-        }
-      };
-      expected = {
-        formData: {
-          country: ''
-        },
-        elementVisibility: {
-          province: false
-        }
-      };
-      expect(handler({}, nextState)).toEqual(expected);
-    });
-    it('should handle call follow up changes correctly when visibility changed', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'province'
-      };
-      const action = {
-        type: ACTION_TYPE_SET_VISIBILITY,
-        rules: [{
-          context: 'country',
-          type: ACTION_RULE_TYPE_ONE_OF,
-          data: ['US']
-        }]
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handleVisibility = actionListener.createSetVisibilityHandler(element, action);
-
-      // Province element is supposed to be hidden and therefore the follow up
-      const followUpHandler = jest.fn();
-      actionListener.register('province', followUpHandler);
-      const prevState = {
-        formData: {
-          province: 'to be changed'
-        }
-      };
-      const nextStateBeforeVisibilityChange = {
-        formData: {
-          country: '',
-          province: 'to be changed'
-        }
-      };
-      const nextStateAfterVisibilityChange = {
-        elementVisibility: {
-          province: false
-        },
-        formData: {
-          country: ''
-        }
-      };
-      handleVisibility(prevState, nextStateBeforeVisibilityChange);
-      expect(followUpHandler).toHaveBeenCalledWith(prevState, nextStateAfterVisibilityChange);
-    });
-  });
-  describe('updateProvinceElementHandler', () => {
-    it('should select the first province in the list, when country changes and no default is ' + 'available', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'province',
-        required: true
-      };
-      const action = {
-        type: 'update',
-        rules: [{
-          context: 'country'
-        }]
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handler = actionListener.createUpdateProvinceElementHandler(element, action);
-      const prevState = {
-        formData: {
-          province: ''
-        }
-      };
-      const nextState = {
-        formData: {
-          country: 'US'
-        }
-      };
-      // eslint-disable-next-line extra-rules/no-single-line-objects
-      const expected = {
-        formData: {
-          country: 'US',
-          province: 'ST'
-        }
-      };
-      expect(handler(prevState, nextState)).toEqual(expected);
-    });
-    it('should select the default province in the list on country changes when a match with ' + 'default is available', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const provinceElement = {
-        id: 'province',
-        default: 'DF',
-        required: true
-      };
-      const countryElement = {
-        id: 'country',
-        default: 'US'
-      };
-      const action = {
-        type: 'update',
-        rules: [{
-          context: countryElement.id
-        }]
-      };
-      const prevState = {};
-      const nextState = {
-        formData: {
-          [countryElement.id]: countryElement.default
-        }
-      };
-      const expected = {
-        formData: {
-          [provinceElement.id]: provinceElement.default,
-          [countryElement.id]: countryElement.default
-        }
-      };
-
-      // Defaults matches the same object structure as 'formData'
-      const actionListener = new ActionListener(mockGetProvincesList, expected.formData);
-      const handler = actionListener.createUpdateProvinceElementHandler(provinceElement, action);
-
-      // Expects the handler to take over the defaults in this test
-      expect(handler(prevState, nextState)).toEqual(expected);
-    });
-  });
-  describe('setValueHandler', () => {
-    it('should create copy the referenced element value into the current element', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'street2'
-      };
-      const action = {
-        type: ACTION_TYPE_SET_VALUE,
-        params: {
-          type: ACTION_SET_VALUE_COPY_FROM,
-          value: 'street'
-        }
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handler = actionListener.createSetValueHandler(element, action);
-
-      // eslint-disable-next-line extra-rules/no-single-line-objects
-      const prevState = {
-        formData: {
-          street: '',
-          street2: ''
-        }
-      };
-      // eslint-disable-next-line extra-rules/no-single-line-objects
-      const nextState = {
-        formData: {
-          street: 'Street 1',
-          street2: ''
-        }
-      };
-      // eslint-disable-next-line extra-rules/no-single-line-objects
-      const expected = {
-        formData: {
-          street: 'Street 1',
-          street2: 'Street 1'
-        }
-      };
-      expect(handler(prevState, nextState)).toEqual(expected);
-    });
-  });
-  describe('transformHandler', () => {
-    it('should apply the transformHandler correctly for "String" operations', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'street'
-      };
-      const action = {
-        type: ACTION_TYPE_TRANSFORM,
-        params: {
-          type: 'toUpperCase'
-        }
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handler = actionListener.createTransformHandler(element, action);
-      const prevState = {
-        formData: {
-          street: ''
-        }
-      };
-      const nextState = {
-        formData: {
-          street: 'Street'
-        }
-      };
-      const expected = {
-        formData: {
-          street: 'STREET'
-        }
-      };
-      expect(handler(prevState, nextState)).toEqual(expected);
-    });
-    it('should apply the transformHandler correctly for "Boolean" operations', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'boolTest'
-      };
-      const action = {
-        type: ACTION_TYPE_TRANSFORM,
-        params: {
-          type: 'toString'
-        }
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handler = actionListener.createTransformHandler(element, action);
-      const prevState = {
-        formData: {
-          boolTest: true
-        }
-      };
-      const nextState = {
-        formData: {
-          boolTest: true
-        }
-      };
-      const expected = {
-        formData: {
-          boolTest: 'true'
-        }
-      };
-      expect(handler(prevState, nextState)).toEqual(expected);
-    });
-    it('should apply the transformHandler correctly for "Number" operations', () => {
-      // -------------------------------------------------------------------------------------------
-
-      const element = {
-        id: 'numberTest'
-      };
-      const action = {
-        type: ACTION_TYPE_TRANSFORM,
-        params: {
-          type: 'isInteger'
-        }
-      };
-      const actionListener = new ActionListener(mockGetProvincesList, {});
-      const handler = actionListener.createTransformHandler(element, action);
-      const prevState = {
-        formData: {
-          numberTest: 7.88
-        }
-      };
-      const nextState = {
-        formData: {
-          numberTest: 7.88
-        }
-      };
-      const expected = {
-        formData: {
-          numberTest: false
-        }
-      };
-      expect(handler(prevState, nextState)).toEqual(expected);
-    });
-  });
-});