@shopgate/pwa-ui-shared 7.32.0-beta.2 → 7.32.0-beta.21

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);
-    });
-  });
-});

package/Form/Builder/spec.js

@@ -1,309 +0,0 @@
-/* eslint-disable extra-rules/no-single-line-objects */
-import React from 'react';
-import { mount } from 'enzyme';
-import FormBuilder from '.';
-import { jsx as _jsx } from "react/jsx-runtime";
-jest.mock('@shopgate/engage/components');
-describe('<FormBuilder />', () => {
-  it('should render empty form', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(FormBuilder, {
-      config: {
-        fields: {}
-      },
-      name: "foo",
-      handleUpdate: () => {}
-    }));
-    expect(wrapper).toMatchSnapshot();
-  });
-  it('should render two text fields', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(FormBuilder, {
-      config: {
-        fields: {
-          firstName: {
-            label: 'foo',
-            type: 'text',
-            visible: true
-          },
-          lastName: {
-            label: 'bar',
-            type: 'text',
-            visible: true
-          }
-        }
-      },
-      name: "foo",
-      handleUpdate: () => {}
-    }));
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('TextField').length).toEqual(2);
-  });
-  it('should not render invisible field', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(FormBuilder, {
-      config: {
-        fields: {
-          firstName: {
-            label: 'foo',
-            type: 'text',
-            visible: false
-          }
-        }
-      },
-      name: "foo",
-      handleUpdate: () => {}
-    }));
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('TextField').length).toEqual(0);
-  });
-  it('should hide element if setVisibilty rule applies', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(FormBuilder, {
-      config: {
-        fields: {
-          foo: {
-            label: 'foo',
-            type: 'text',
-            visible: true
-          },
-          bar: {
-            label: 'bar',
-            type: 'text',
-            actions: [{
-              type: 'setVisibility',
-              rules: [{
-                context: 'foo',
-                type: 'notIn',
-                data: ['abc']
-              }]
-            }]
-          }
-        }
-      },
-      name: "foo",
-      handleUpdate: () => {}
-    }));
-
-    // Both should be visible at the beginning.
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('TextField').length).toEqual(2);
-
-    // Simulate user input to the text field.
-    wrapper.find('input').first().simulate('change', {
-      target: {
-        value: 'abc'
-      }
-    });
-
-    // Second field should be hidden now.
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('TextField').length).toEqual(1);
-  });
-  it('should reset value when rule applies', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(FormBuilder, {
-      config: {
-        fields: {
-          foo: {
-            label: 'foo',
-            type: 'text',
-            visible: true,
-            default: 'default'
-          },
-          bar: {
-            label: 'bar',
-            type: 'text',
-            default: 'default',
-            actions: [{
-              type: 'setValue',
-              params: {
-                value: 'cheat',
-                type: 'fixed'
-              },
-              rules: [{
-                context: 'foo',
-                type: 'notIn',
-                data: ['default']
-              }]
-            }]
-          }
-        }
-      },
-      name: "foo",
-      handleUpdate: () => {}
-    }));
-
-    // Default values should be in the inputs.
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('TextField').length).toEqual(2);
-    expect(wrapper.find('input').at(0).props().value).toEqual('default');
-    expect(wrapper.find('input').at(1).props().value).toEqual('default');
-
-    // Simulate text input to trigger rule.
-    wrapper.find('input').first().simulate('change', {
-      target: {
-        value: 'abc'
-      }
-    });
-    wrapper.update();
-
-    // Second field should be hidden now.
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('TextField').length).toEqual(2);
-    expect(wrapper.find('input').at(0).props().value).toEqual('abc');
-    expect(wrapper.find('input').at(1).props().value).toEqual('cheat');
-  });
-  it('should call onChange callback when input is changed', () => {
-    const handleUpdate = jest.fn();
-    const wrapper = mount(/*#__PURE__*/_jsx(FormBuilder, {
-      config: {
-        fields: {
-          foo: {
-            label: 'foo',
-            type: 'text',
-            visible: true,
-            default: 'default'
-          }
-        }
-      },
-      name: "foo",
-      id: "foo",
-      handleUpdate: handleUpdate
-    }));
-
-    // Should call with initial state.
-    expect(wrapper).toMatchSnapshot();
-    expect(handleUpdate).toHaveBeenCalledWith({
-      foo: 'default'
-    }, false);
-    handleUpdate.mockClear();
-
-    // Update input
-    wrapper.find('input').first().simulate('change', {
-      target: {
-        value: 'abc'
-      }
-    });
-
-    // Should call with updated state.
-    expect(handleUpdate).toHaveBeenCalledWith({
-      foo: 'abc'
-    }, false);
-  });
-  describe('FormBuilder::elementChangeHandler', () => {
-    it('should take the updated state from action listener', () => {
-      const handleUpdate = jest.fn();
-      const ref = /*#__PURE__*/React.createRef();
-      mount(/*#__PURE__*/_jsx(FormBuilder, {
-        ref: ref,
-        validationErrors: [],
-        config: {
-          fields: {
-            foo: {
-              label: 'foo',
-              type: 'text',
-              visible: true,
-              default: 'default'
-            }
-          }
-        },
-        name: "foo",
-        id: "foo",
-        handleUpdate: handleUpdate
-      }));
-      ref.current.actionListener.notify = () => ({
-        formData: {
-          foo: 'bar'
-        },
-        errors: {},
-        elementVisibility: {
-          foo: true
-        }
-      });
-
-      // Trigger update
-      ref.current.elementChangeHandler('foo', 'bar');
-
-      // Test
-      expect(handleUpdate).toHaveBeenCalledWith({
-        foo: 'bar'
-      }, false);
-    });
-    it('should consider backend validations', () => {
-      // Create mocked Form builder.
-      const handleUpdate = jest.fn();
-      const ref = /*#__PURE__*/React.createRef();
-      mount(/*#__PURE__*/_jsx(FormBuilder, {
-        ref: ref,
-        validationErrors: [{}],
-        config: {
-          fields: {
-            foo: {
-              label: 'foo',
-              type: 'text',
-              visible: true,
-              default: 'default'
-            }
-          }
-        },
-        name: "foo",
-        id: "foo",
-        handleUpdate: handleUpdate
-      }));
-      ref.current.actionListener.notify = () => ({
-        formData: {
-          foo: 'bar'
-        },
-        errors: {},
-        elementVisibility: {
-          foo: true
-        }
-      });
-
-      // Trigger update
-      ref.current.elementChangeHandler('foo', 'bar');
-
-      // Test
-      expect(handleUpdate).toHaveBeenCalledWith({
-        foo: 'bar'
-      }, true);
-    });
-  });
-  describe('FormBuilder::elementSortFunc', () => {
-    const builder = new FormBuilder({
-      validationErrors: [{}],
-      config: {
-        fields: {}
-      },
-      handleUpdate: jest.fn()
-    });
-    const field1 = {
-      id: 'foo',
-      label: 'foo'
-    };
-    const field2 = {
-      id: 'foo2',
-      label: 'foo2'
-    };
-    it('should keep sortOrder for undefined', () => {
-      expect([field2, field1].sort(builder.elementSortFunc)).toEqual([field2, field1]);
-    });
-    it('should sort elements', () => {
-      const fields = [{
-        ...field1,
-        sortOrder: 2
-      }, {
-        ...field2,
-        sortOrder: 1
-      }];
-      expect(fields.sort(builder.elementSortFunc)).toEqual(fields.reverse());
-    });
-    it('should keep sortOrder', () => {
-      const fields = [{
-        ...field2,
-        sortOrder: 1
-      }, {
-        ...field1,
-        sortOrder: 2
-      }];
-      expect(fields.sort(builder.elementSortFunc)).toEqual([].concat(fields));
-    });
-  });
-});
-/* eslint-enable extra-rules/no-single-line-objects */

package/Form/InfoField/spec.js

@@ -1,12 +0,0 @@
-import React from 'react';
-import { render } from '@testing-library/react';
-import InfoField from "./index";
-import { jsx as _jsx } from "react/jsx-runtime";
-describe('<InfoField>', () => {
-  it('should render info field', () => {
-    const wrapper = render(/*#__PURE__*/_jsx(InfoField, {
-      children: "Some info text"
-    }));
-    expect(wrapper.asFragment()).toMatchSnapshot();
-  });
-});

package/Form/Password/spec.js

@@ -1,39 +0,0 @@
-import React from 'react';
-import { mount } from 'enzyme';
-import Password from "./index";
-import { jsx as _jsx } from "react/jsx-runtime";
-const inputProps = {
-  name: 'test-input'
-};
-describe('<Password>', () => {
-  it('should render a password field', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(Password, {
-      ...inputProps
-    }));
-    expect(wrapper).toMatchSnapshot();
-    expect(wrapper.find('input[type="password"]').length).toBe(1);
-  });
-  it('should trigger the onChange callback', () => {
-    const onChangeMock = jest.fn();
-    const wrapper = mount(/*#__PURE__*/_jsx(Password, {
-      ...inputProps,
-      onChange: onChangeMock
-    }));
-    wrapper.find('input').simulate('change', {
-      target: {
-        value: 'a'
-      }
-    });
-    expect(onChangeMock).toHaveBeenCalledTimes(2);
-    expect(wrapper.find('input').props().value).toEqual('a');
-  });
-  it('should toggle password visibility', () => {
-    const wrapper = mount(/*#__PURE__*/_jsx(Password, {
-      ...inputProps
-    }));
-    const input = wrapper.find('ToggleIcon');
-    expect(wrapper.find('input[type="password"]').length).toBe(1);
-    input.simulate('click');
-    expect(wrapper.find('input[type="text"]').length).toBe(1);
-  });
-});