@blaze-cms/react-page-builder 0.146.0-translations.8 → 0.147.0-rc-eagle.4

package/tests/unit/src/helpers/build-search-values-checkbox-select.test.js

@@ -1,174 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import { AND, OR } from '../../../../src/constants';
-import buildSearchValuesCheckboxSelect from '../../../../src/helpers/build-search-values-checkbox-select';
-
-const mockedArgs = {
-  query: {
-    metaTitle: 'something',
-    name: ['test', 'other']
-  },
-  rangeFiltersEmpty: [],
-  checkboxFiltersEmpty: [],
-  selectFiltersEmpty: []
-};
-
-const mockedQueryCheckboxOneValue = {
-  metaTitle: 'something',
-  name: 'other'
-};
-
-const mockedSearchArray = {
-  values: [{ match: { 'name.keyword': 'other' } }],
-  valuesOr: []
-};
-
-const mockedQueryRandomData = {
-  test: 'random-value'
-};
-
-const mockedCheckboxFilters = operator => [
-  { propsToDisplay: ['name'], type: 'checkbox', operator }
-];
-
-describe('build search values for checkbox & select', () => {
-  const { query, rangeFiltersEmpty, checkboxFiltersEmpty, selectFiltersEmpty } = mockedArgs;
-  const searchValuesCheckboxSelect = buildSearchValuesCheckboxSelect(
-    query,
-    rangeFiltersEmpty,
-    checkboxFiltersEmpty,
-    selectFiltersEmpty
-  );
-
-  it('should be a function', () => {
-    expect(typeof buildSearchValuesCheckboxSelect).toEqual('function');
-  });
-
-  it('should always return an object', () => {
-    expect(typeof searchValuesCheckboxSelect).toBe('object');
-  });
-
-  it('should return an array with range filter', () => {
-    const searchArray = {
-      values: [
-        {
-          range: {
-            price: {
-              gte: 1,
-              lte: 123
-            }
-          }
-        }
-      ],
-      valuesOr: []
-    };
-    const queryRange = {
-      price: '1-123',
-      metaTitle: 'something',
-      name: ['test', 'other']
-    };
-    const rangeFilters = [{ propsToDisplay: ['price'], type: 'range' }];
-    const searchValuesWithRange = buildSearchValuesCheckboxSelect(
-      queryRange,
-      rangeFilters,
-      checkboxFiltersEmpty,
-      selectFiltersEmpty
-    );
-    expect(searchValuesWithRange).toEqual(searchArray);
-    expect(searchValuesWithRange.values.length).toBe(1);
-  });
-
-  it('should return an array with correct data when checkbox filter has OR operator selected', () => {
-    const searchValuesCheckboxWithOrSelect = buildSearchValuesCheckboxSelect(
-      query,
-      rangeFiltersEmpty,
-      mockedCheckboxFilters(OR),
-      selectFiltersEmpty
-    );
-    const searchArray = {
-      values: [],
-      valuesOr: [{ match: { 'name.keyword': 'test' } }, { match: { 'name.keyword': 'other' } }]
-    };
-    expect(searchValuesCheckboxWithOrSelect).toEqual(searchArray);
-    expect(searchValuesCheckboxWithOrSelect.values.length).toBe(0);
-    expect(searchValuesCheckboxWithOrSelect.valuesOr.length).toBe(2);
-  });
-
-  it('should return an array with correct data when checkbox filter has AND operator selected', () => {
-    const searchValuesCheckboxWithOrSelect = buildSearchValuesCheckboxSelect(
-      query,
-      rangeFiltersEmpty,
-      mockedCheckboxFilters(AND),
-      selectFiltersEmpty
-    );
-    const searchArray = {
-      values: [{ match: { 'name.keyword': 'test' } }, { match: { 'name.keyword': 'other' } }],
-      valuesOr: []
-    };
-    expect(searchValuesCheckboxWithOrSelect).toEqual(searchArray);
-    expect(searchValuesCheckboxWithOrSelect.values.length).toBe(2);
-    expect(searchValuesCheckboxWithOrSelect.valuesOr.length).toBe(0);
-  });
-
-  it('should return an array with correct data when checkbox filter has only one value checked + AND operator', () => {
-    const searchValuesCheckboxWithOrSelect = buildSearchValuesCheckboxSelect(
-      mockedQueryCheckboxOneValue,
-      rangeFiltersEmpty,
-      mockedCheckboxFilters(AND),
-      selectFiltersEmpty
-    );
-
-    expect(searchValuesCheckboxWithOrSelect).toEqual(mockedSearchArray);
-    expect(searchValuesCheckboxWithOrSelect.values.length).toBe(1);
-    expect(searchValuesCheckboxWithOrSelect.valuesOr.length).toBe(0);
-  });
-
-  it('should return an array with correct data when checkbox filter has only one value checked + OR operator', () => {
-    const searchValuesCheckboxWithOrSelect = buildSearchValuesCheckboxSelect(
-      mockedQueryCheckboxOneValue,
-      rangeFiltersEmpty,
-      mockedCheckboxFilters(OR),
-      selectFiltersEmpty
-    );
-
-    expect(searchValuesCheckboxWithOrSelect).toEqual(mockedSearchArray);
-    expect(searchValuesCheckboxWithOrSelect.values.length).toBe(1);
-    expect(searchValuesCheckboxWithOrSelect.valuesOr.length).toBe(0);
-  });
-
-  it('should return an empty object if query params set but no filters', () => {
-    const searchValuesEmpty = buildSearchValuesCheckboxSelect(
-      mockedQueryRandomData,
-      rangeFiltersEmpty,
-      checkboxFiltersEmpty,
-      selectFiltersEmpty
-    );
-
-    expect(searchValuesEmpty).toEqual({ values: [], valuesOr: [] });
-  });
-
-  it('should return an empty object if query params set but they dont match any filters', () => {
-    const searchValuesEmpty = buildSearchValuesCheckboxSelect(
-      mockedQueryRandomData,
-      rangeFiltersEmpty,
-      mockedCheckboxFilters(AND),
-      selectFiltersEmpty
-    );
-
-    expect(searchValuesEmpty.values.length).toBe(0);
-    expect(searchValuesEmpty.valuesOr.length).toBe(0);
-  });
-
-  it('should remove query with keys named "search-term"', () => {
-    const querySearchTerm = { search_term: 'test-search-term', other: 'other-test' };
-
-    const searchQuerySearchTerm = buildSearchValuesCheckboxSelect(
-      querySearchTerm,
-      rangeFiltersEmpty,
-      checkboxFiltersEmpty,
-      selectFiltersEmpty
-    );
-
-    expect(searchQuerySearchTerm.values.length).toBe(0);
-    expect(searchQuerySearchTerm.valuesOr.length).toBe(0);
-  });
-});

package/tests/unit/src/helpers/build-search-values-text.test.js

@@ -1,57 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import buildSearchValuesText from '../../../../src/helpers/build-search-values-text';
-
-const mockedArgs = {
-  textFilter: {
-    propsToDisplay: ['name', 'metaTitle']
-  },
-  query: {
-    search_term: 'something'
-  }
-};
-
-describe('build search values for text input', () => {
-  const { textFilter, query } = mockedArgs;
-  const searchValues = buildSearchValuesText(textFilter, query);
-  const searchValuesEmpty = buildSearchValuesText({ propsToDisplay: [] }, query);
-  const searchValuesNoQueryParams = buildSearchValuesText(textFilter, {});
-  const searchValuesEmptyArgs = buildSearchValuesText();
-
-  it('should always return an array', () => {
-    [searchValues, searchValuesEmpty, searchValuesEmptyArgs].forEach(searchValue => {
-      expect(Array.isArray(searchValue.should)).toEqual(true);
-      expect(Array.isArray(searchValue.must)).toEqual(true);
-    });
-  });
-
-  it('should handle empty values', () => {
-    [searchValues, searchValuesEmpty, searchValuesEmptyArgs].forEach(searchValue => {
-      expect(Array.isArray(searchValue.should)).toEqual(true);
-      expect(Array.isArray(searchValue.must)).toEqual(true);
-    });
-  });
-
-  it('should have no filters set', () => {
-    expect(searchValuesEmpty.should.length).toEqual(0);
-    expect(searchValuesEmpty.must.length).toEqual(0);
-  });
-
-  it('should return an array with correct data', () => {
-    const searchArray = {
-      should: [
-        {
-          match: { pageBuilderIndexed: { query: 'something', fuzziness: 'AUTO', prefix_length: 3 } }
-        }
-      ],
-      must: [
-        { match: { name: { query: 'something', fuzziness: 'AUTO', prefix_length: 3 } } },
-        { match: { metaTitle: { query: 'something', fuzziness: 'AUTO', prefix_length: 3 } } }
-      ]
-    };
-    expect(searchValues).toEqual(searchArray);
-    expect(searchValuesEmpty).toEqual({ should: [], must: [] });
-    expect(searchValues.must.length).toBe(2);
-    expect(searchValuesEmpty.must.length).toBe(0);
-    expect(searchValuesNoQueryParams.must.length).toBe(0);
-  });
-});

package/tests/unit/src/helpers/build-set-filters.test.js

@@ -1,84 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import buildSetFilters from '../../../../src/helpers/build-set-filters';
-
-const tagFilterByProperty = 'tagIds/tag';
-const getMockedArgs = overrides => ({
-  filterBy: ['tagIds/id1', 'tagIds/id2'],
-  filterByProperty: [tagFilterByProperty],
-  filterByFeatured: null,
-  filterBySponsored: null,
-  ...overrides
-});
-
-describe('build set filters', () => {
-  const filters = buildSetFilters(getMockedArgs());
-
-  it('should be a function', () => {
-    expect(typeof buildSetFilters).toEqual('function');
-  });
-
-  it('should always return an object', () => {
-    expect(typeof filters).toBe('object');
-  });
-
-  it('should return correct data with only filter values for one field', () => {
-    const { checkboxFilters, listFilterValues } = filters;
-
-    expect(checkboxFilters).toEqual([]);
-    expect(listFilterValues).toEqual({ tagIds: ['id1', 'id2'] });
-  });
-
-  it('should return correct data with filter values for more than one field', () => {
-    const { checkboxFilters, listFilterValues } = buildSetFilters(
-      getMockedArgs({
-        filterByProperty: [tagFilterByProperty, 'categoryId/category'],
-        filterBy: ['tagIds/id1', 'tagIds/id2', 'categoryId/cat1']
-      })
-    );
-
-    expect(checkboxFilters).toEqual([]);
-    expect(listFilterValues).toEqual({ tagIds: ['id1', 'id2'], categoryId: ['cat1'] });
-  });
-
-  it('should handle filter values with forward slash', () => {
-    const tagWithSlash = 'tag/with/slash';
-    const { listFilterValues } = buildSetFilters(
-      getMockedArgs({
-        filterByProperty: [tagFilterByProperty],
-        filterBy: [`tagIds/${tagWithSlash}`]
-      })
-    );
-    expect(listFilterValues).toEqual({ tagIds: [tagWithSlash] });
-  });
-
-  it('should return correct data with only one checkbox filter', () => {
-    const { checkboxFilters, listFilterValues } = buildSetFilters(
-      getMockedArgs({
-        filterByProperty: [],
-        filterBy: [],
-        filterBySponsored: true
-      })
-    );
-
-    expect(checkboxFilters).toEqual(['sponsored']);
-    expect(listFilterValues).toEqual({});
-  });
-
-  it('should return correct data with both both filter values and checkbox filters', () => {
-    const { checkboxFilters, listFilterValues } = buildSetFilters(
-      getMockedArgs({
-        filterByFeatured: true,
-        filterBySponsored: true
-      })
-    );
-
-    expect(checkboxFilters).toEqual(['featured', 'sponsored']);
-    expect(listFilterValues).toEqual({ tagIds: ['id1', 'id2'] });
-  });
-
-  it('should take default empty array value when filterBy is not defined', () => {
-    const { checkboxFilters, listFilterValues } = buildSetFilters({});
-    expect(checkboxFilters).toEqual([]);
-    expect(listFilterValues).toEqual({});
-  });
-});

package/tests/unit/src/helpers/build-sort-values.test.js

@@ -1,54 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import buildSortValues from '../../../../src/helpers/build-sort-values';
-
-describe('buildSortValues helper function', () => {
-  it('should return an object with empty sort array if no sortFilters are passed', () => {
-    const noSort = buildSortValues();
-    const emptySortFilters = buildSortValues([]);
-    expect(noSort).toEqual({ sort: [] });
-    expect(emptySortFilters).toEqual({ sort: [] });
-  });
-
-  it('should return null if no sortFilters are passed and useSortObject is true', () => {
-    const noSortUseSortObject = buildSortValues(null, [], [], true);
-    const emptySortFiltersUseSortObject = buildSortValues([], [], [], true);
-    expect(noSortUseSortObject).toEqual(null);
-    expect(emptySortFiltersUseSortObject).toEqual(null);
-  });
-
-  it('should return sort object if useSortObject is true and sortFilters match', () => {
-    const withUseSortObject = buildSortValues(
-      [
-        {
-          propsToDisplay: ['slug'],
-          sort: 'ASC',
-          label: ''
-        }
-      ],
-      [],
-      ['name', 'slug', 'metaTitle'],
-      true
-    );
-    expect(withUseSortObject).toEqual({ 'slug.keyword': 'asc' });
-  });
-
-  it('should filter out duplicate sort values', () => {
-    const sort = buildSortValues(
-      [
-        {
-          propsToDisplay: ['slug'],
-          sort: 'ASC',
-          label: ''
-        },
-        {
-          propsToDisplay: ['slug'],
-          sort: 'ASC',
-          label: ''
-        }
-      ],
-      [],
-      ['name', 'slug', 'metaTitle']
-    );
-    expect(sort).toEqual({ sort: 'slug.keyword:asc' });
-  });
-});

package/tests/unit/src/helpers/check-for-error.test.js

@@ -1,33 +0,0 @@
-import checkForError from '../../../../src/helpers/check-for-error';
-
-const mockedResults = [
-  { hasErr: false, errMsg: undefined },
-  { hasErr: true, errMsg: 'hasError' },
-  { hasErr: true, errMsg: 'shouldDisplayErr' },
-  { hasErr: true, errMsg: 'shouldDisplayThisErr' }
-];
-
-const mockedProps = [
-  [{ message: 'hasError' }],
-  [{ message: 'shouldDisplayErr' }, { message: 'noShow' }, { message: 'noShow' }],
-  [{}, { message: 'shouldDisplayThisErr' }, { message: 'noShow' }]
-];
-
-describe('Get updated filter by helper function', () => {
-  it('should be a function', () => {
-    expect(typeof checkForError).toEqual('function');
-  });
-
-  it('should return false and no message if nothing is passed', () => {
-    expect(checkForError()).toEqual(mockedResults[0]);
-  });
-
-  it('should return true and the error message', () => {
-    expect(checkForError(mockedProps[0])).toEqual(mockedResults[1]);
-  });
-
-  it('should return true and the the first error msg if multiple errs are passed', () => {
-    expect(checkForError(mockedProps[1])).toEqual(mockedResults[2]);
-    expect(checkForError(mockedProps[2])).toEqual(mockedResults[3]);
-  });
-});

package/tests/unit/src/helpers/check-props-to-use.test.js

@@ -1,32 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import checkPropsToUse from '../../../../src/helpers/check-props-to-use';
-
-const mockedPropsArr = ['prop1', 'prop2'];
-const mockedPropsObj = [
-  { propertiesToDisplay: ['prop1', 'prop2'], prop2: 3 },
-  { propertiesToDisplay: ['prop3', 'prop4'], prop2: 4 }
-];
-const mockedResult = ['prop1', 'prop2', 'prop3', 'prop4'];
-
-describe('check props to use function', () => {
-  const withPropsArr = checkPropsToUse(mockedPropsArr);
-  const withPropsObj = checkPropsToUse(mockedPropsObj);
-
-  it('should be a function', () => {
-    expect(typeof checkPropsToUse).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(withPropsArr)).toBe(true);
-    expect(Array.isArray(withPropsObj)).toBe(true);
-  });
-
-  it('should return the propertiesToDisplay values in a flat array', () => {
-    expect(withPropsObj).toEqual(mockedResult);
-  });
-
-  it('should return empty array if no props to display are passed as argument', () => {
-    expect(Array.isArray(checkPropsToUse())).toBeTruthy();
-    expect(checkPropsToUse().length).toEqual(0);
-  });
-});

package/tests/unit/src/helpers/get-banner-data.test.js

@@ -1,32 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getBannerData from '../../../../src/helpers/get-banner-data';
-
-const mockedParams = {
-  banner: {
-    someBannerKey: 'someBannerKey'
-  },
-  options: {
-    parent: { itemEntity: 12 },
-    limit: 4
-  }
-};
-
-describe('Get banner data object', () => {
-  const { banner, options } = mockedParams;
-  const bannerData = getBannerData(banner, options);
-
-  it('should return an object', () => {
-    expect(typeof bannerData).toBe('object');
-  });
-
-  it('should return object merged with parent and limit', () => {
-    expect(bannerData).toHaveProperty('someBannerKey');
-    expect(bannerData).toHaveProperty('parent');
-    expect(bannerData).toHaveProperty('limit');
-  });
-
-  it('should set entity as parentEntity if none is set on banner', () => {
-    expect(bannerData).toHaveProperty('entity');
-    expect(bannerData.entity).toEqual(12);
-  });
-});

package/tests/unit/src/helpers/get-card-entities.test.js

@@ -1,27 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getEntitiesWithBanner from '../../../../src/helpers/get-entities-with-banner';
-
-const getMockedEntities = entities => [...Array(entities).keys()];
-const banner = {
-  adunit: 'someBannerId',
-  sizes: '300x250, 300x600',
-  interval: 2,
-  repeat: true
-};
-
-describe('Get card entities', () => {
-  const mockedEntities = getMockedEntities(10);
-  const entities = getEntitiesWithBanner(mockedEntities, { hasBanner: true, banner });
-  it('should be a function', () => {
-    expect(typeof getEntitiesWithBanner).toEqual('function');
-  });
-
-  it('should return an array', () => {
-    expect(Array.isArray(entities)).toBeTruthy();
-  });
-
-  it('should return an array with a banner injected', () => {
-    const foundBanner = entities.filter(entity => entity.adunit);
-    expect(foundBanner.length).toBeTruthy();
-  });
-});

package/tests/unit/src/helpers/get-checkbox-filters.test.js

@@ -1,33 +0,0 @@
-import getCheckboxFilters from '../../../../src/helpers/get-checkbox-filters';
-
-describe('getCheckboxFilters helper', () => {
-  it('adds [name, value] to checkboxFilters when value is a non-"off" string', () => {
-    const checkboxFilters = [];
-    getCheckboxFilters(checkboxFilters, 'filterName', 'on');
-    expect(checkboxFilters).toEqual([['filterName', 'on']]);
-  });
-
-  it('does not add to checkboxFilters when value is "off"', () => {
-    const checkboxFilters = [];
-    getCheckboxFilters(checkboxFilters, 'filterName', 'off');
-    expect(checkboxFilters).toEqual([]);
-  });
-
-  it('does not add to checkboxFilters when value is falsy', () => {
-    const checkboxFilters = [];
-    getCheckboxFilters(checkboxFilters, 'filterName', null);
-    expect(checkboxFilters).toEqual([]);
-  });
-
-  it('adds name to checkboxFilters when value is truthy and not a string', () => {
-    const checkboxFilters = [];
-    getCheckboxFilters(checkboxFilters, 'filterName', true);
-    expect(checkboxFilters).toEqual(['filterName']);
-  });
-
-  it('adds name to checkboxFilters when value is truthy and not a string', () => {
-    const checkboxFilters = [];
-    getCheckboxFilters(checkboxFilters, 'filterName', true);
-    expect(checkboxFilters).toEqual(['filterName']);
-  });
-});

package/tests/unit/src/helpers/get-click-wrapper-options.test.js

@@ -1,81 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getClickWrapperOptions from '../../../../src/helpers/get-click-wrapper-options';
-
-const mockedChildrenProp = {
-  props: {
-    children: [
-      null,
-      [
-        {
-          props: {
-            component: {
-              settings: {
-                gtmEvents: [
-                  {
-                    eventTrigger: 'onClick'
-                  },
-                  {
-                    eventTrigger: 'inView'
-                  },
-                  {
-                    eventTrigger: 'onLoad'
-                  },
-                  {
-                    eventTrigger: 'onClick'
-                  }
-                ]
-              }
-            }
-          }
-        }
-      ]
-    ]
-  }
-};
-const mockedComponentProps = { name: 'compName', tag: 'compTag' };
-
-describe('getClickWrapperOptions function', () => {
-  const noPropsPassed = getClickWrapperOptions();
-  const nullChildren = getClickWrapperOptions(null);
-  const noClickWrapper = getClickWrapperOptions({}, {});
-  const withClickWrapper = getClickWrapperOptions(mockedChildrenProp, {});
-  const withClickWrapperAndComponentProps = getClickWrapperOptions(
-    mockedChildrenProp,
-    mockedComponentProps
-  );
-
-  it('should always return an object', () => {
-    expect(typeof noPropsPassed).toBe('object');
-    expect(typeof nullChildren).toBe('object');
-    expect(typeof noClickWrapper).toBe('object');
-    expect(typeof withClickWrapper).toBe('object');
-    expect(typeof withClickWrapperAndComponentProps).toBe('object');
-  });
-
-  it('should return shouldUseClickWrapper as false if no gtm child with onClick event trigger is found', () => {
-    const { shouldUseClickWrapper } = noClickWrapper;
-    expect(shouldUseClickWrapper).toBe(false);
-  });
-
-  it('should return shouldUseClickWrapper as true if a gtm child with onClick event trigger is found', () => {
-    const { shouldUseClickWrapper } = withClickWrapper;
-    expect(shouldUseClickWrapper).toBe(true);
-  });
-
-  it('should return componentProps if shouldUseClickWrapper is true and componentProps are passed', () => {
-    const { wrapperProps } = withClickWrapperAndComponentProps;
-    const expectedComponentProps = {
-      gtmChildren: mockedChildrenProp,
-      ...mockedComponentProps,
-      id: null
-    };
-    const { gtmEvents } = wrapperProps.gtmChildren.props.children[1][0].props.component.settings;
-    expect(wrapperProps).toEqual(expectedComponentProps);
-    expect(gtmEvents).toEqual([
-      { eventTrigger: 'onClick' },
-      { eventTrigger: 'inView' },
-      { eventTrigger: 'onLoad' },
-      { eventTrigger: 'onClick' }
-    ]);
-  });
-});

package/tests/unit/src/helpers/get-component-id.test.js

@@ -1,36 +0,0 @@
-import cssesc from 'cssesc';
-import getComponentId from '../../../../src/helpers/get-component-id';
-import { COMPONENT_ID_PREFIX } from '../../../../src/constants';
-
-jest.mock('cssesc');
-
-describe('Get component Id', () => {
-  beforeEach(() => {
-    cssesc.mockClear();
-  });
-
-  it('should call cssesc with correct arguments', () => {
-    cssesc.mockReturnValue('escapedId');
-    const componentName = 'MyComponent';
-    const expectedInput = `${COMPONENT_ID_PREFIX}${componentName}`;
-    const result = getComponentId(componentName);
-
-    expect(cssesc).toHaveBeenCalledWith(expectedInput, { isIdentifier: true });
-    expect(result).toBe('escapedId');
-  });
-
-  it('should handle special characters in component name', () => {
-    cssesc.mockImplementation(str => `escaped:${str}`);
-    const componentName = 'My$Component#1';
-    const expectedInput = `${COMPONENT_ID_PREFIX}${componentName}`;
-    const result = getComponentId(componentName);
-
-    expect(result).toBe(`escaped:${expectedInput}`);
-  });
-
-  it('should return a string', () => {
-    cssesc.mockReturnValue('someId');
-    const result = getComponentId('Test');
-    expect(typeof result).toBe('string');
-  });
-});