@blaze-cms/react-page-builder 0.146.0-rc-eagle.0 → 0.146.0-rc-eagle-3.0

package/tests/unit/src/helpers/remove-unwanted-characters.test.js

@@ -1,70 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import removeUnwantedCharacters from '../../../../src/helpers/remove-unwanted-characters';
-
-const mockedArgs = [
-  'withNoChange',
-  '| remove from start',
-  'remove from end |',
-  '| remove from both |'
-];
-
-const mockedResults = ['remove from start', 'remove from end', 'remove from both'];
-
-const objectValue = { keyField: 'name', name: mockedArgs[3] };
-const objectResults = {
-  ...objectValue,
-  name: mockedResults[2]
-};
-
-describe('remove unwanted characters from string', () => {
-  it('should be a function', () => {
-    expect(typeof removeUnwantedCharacters).toEqual('function');
-  });
-
-  it('should return the same string if no match is found', () => {
-    const noChange = removeUnwantedCharacters(mockedArgs[0]);
-    expect(noChange).toEqual(mockedArgs[0]);
-  });
-
-  it('should remove characters if found at the start of the string', () => {
-    const fromStart = removeUnwantedCharacters(mockedArgs[1]);
-    expect(fromStart).toEqual(mockedResults[0]);
-  });
-
-  it('should remove characters if found at the end of the string', () => {
-    const fromEnd = removeUnwantedCharacters(mockedArgs[2]);
-    expect(fromEnd).toEqual(mockedResults[1]);
-  });
-
-  it('should remove characters if found at the end AND start of the string', () => {
-    const fromBoth = removeUnwantedCharacters(mockedArgs[3]);
-    expect(fromBoth).toEqual(mockedResults[2]);
-  });
-
-  it('should return a string', () => {
-    expect(removeUnwantedCharacters(12345)).toEqual('12345');
-  });
-
-  it('should return empty string for null/undefined', () => {
-    expect(removeUnwantedCharacters(null)).toEqual('');
-    expect(removeUnwantedCharacters(undefined)).toEqual('');
-  });
-
-  it('should handle array', () => {
-    expect(removeUnwantedCharacters(mockedArgs)).toEqual([mockedArgs[0], ...mockedResults]);
-    expect(removeUnwantedCharacters([1, null, 'a'])).toEqual(['1', '', 'a']);
-  });
-
-  it('should handle objects', () => {
-    expect(removeUnwantedCharacters(objectValue)).toEqual(objectResults);
-  });
-
-  it('should return object untouched if no keyField', () => {
-    const value = { name: mockedArgs[3] };
-    expect(removeUnwantedCharacters(value)).toEqual(value);
-  });
-
-  it('should handle array of objects', () => {
-    expect(removeUnwantedCharacters([objectValue])).toEqual([objectResults]);
-  });
-});

package/tests/unit/src/helpers/render-children.test.js

@@ -1,73 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import '@testing-library/jest-dom/extend-expect';
-import renderChildren from '../../../../src/helpers/render-children';
-
-const mocks = [
-  <span className="span-child" data-modifier="has-modifier">
-    Span Child
-  </span>,
-  <div className="div-child">Div Child</div>
-];
-
-const mockedResults = [
-  { type: 'span', className: 'span-child', 'data-modifier': 'has-modifier' },
-  { type: 'div', className: 'div-child' }
-];
-
-describe('render children helper', () => {
-  const withChildren = renderChildren(mocks, {});
-
-  it('should be a function', () => {
-    expect(typeof renderChildren).toEqual('function');
-  });
-
-  it('should return null if null is passed as arguments', () => {
-    const withNull = renderChildren(null);
-    expect(withNull).toEqual(null);
-  });
-
-  it('should return undefined if nothing or undefined is passed as arguments', () => {
-    const withUndefined = renderChildren();
-    expect(withUndefined).toEqual(undefined);
-  });
-
-  it('should return corresponding react jsx elements', () => {
-    expect(Array.isArray(withChildren)).toBeTruthy();
-    withChildren.forEach(({ type, props: childProps }, i) => {
-      expect(type).toEqual(mockedResults[i].type);
-      expect(childProps.className).toEqual(mockedResults[i].className);
-      if (mockedResults[i]['data-modifier']) {
-        expect(childProps['data-modifier']).toEqual(mockedResults[i]['data-modifier']);
-      }
-    });
-  });
-
-  it('should map nested children', () => {
-    const nestedMocks = [
-      <div className="div-child">
-        <span className="span-child" data-modifier="has-modifier">
-          Span Child 1
-        </span>
-        <span className="span-child" data-modifier="has-modifier">
-          Span Child 2
-        </span>
-      </div>
-    ];
-
-    const withNestedChildren = renderChildren(nestedMocks);
-    expect(withNestedChildren).toEqual.false;
-  });
-
-  it('should map nested children of type array', () => {
-    const elementReact = [<div />];
-    const childrenElements = [false, elementReact];
-    const nestedMocksArray = [<div className="div-child">{childrenElements}</div>];
-
-    const withNestedArray = renderChildren(nestedMocksArray, {});
-
-    expect(withNestedArray).toHaveLength(1);
-  });
-});

package/tests/unit/src/helpers/should-render-waypoint.test.js

@@ -1,23 +0,0 @@
-import shouldRenderWaypoint from '../../../../src/helpers/should-render-waypoint';
-
-describe('shouldRenderWaypoint helper', () => {
-  it('should return false if no props are passed', async () => {
-    const noValues = shouldRenderWaypoint();
-    expect(noValues).toEqual(false);
-  });
-
-  it('should return false if the current element is the penultimate in the current page but there is no more to fetch', async () => {
-    const noMoreToFetch = shouldRenderWaypoint(3, 5, 5, 5);
-    expect(noMoreToFetch).toEqual(false);
-  });
-
-  it('should return true if the current element is the annte peultimate element in a page', async () => {
-    const notFinalItem = shouldRenderWaypoint(2, 5, 3, 10);
-    expect(notFinalItem).toEqual(true);
-  });
-
-  it('should return false if the current element isnt the penultimate in the current page and there are more items to fetch', async () => {
-    const shoudlFetch = shouldRenderWaypoint(4, 5, 5, 10);
-    expect(shoudlFetch).toEqual(false);
-  });
-});

package/tests/unit/src/helpers/should-show-property.test.js

@@ -1,20 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import shouldShowProperty from '../../../../src/helpers/should-show-property';
-
-describe('shouldShowProperty function', () => {
-  it('should be a function', () => {
-    expect(typeof shouldShowProperty).toEqual('function');
-  });
-
-  it('should return false if isDisplayed is false', () => {
-    expect(shouldShowProperty({ isDisplayed: false, value: 'some value' })).toBeFalsy();
-  });
-
-  it('should return true if isDisplayed is true & has value', () => {
-    expect(shouldShowProperty({ isDisplayed: true, value: 'some value' })).toBeTruthy();
-  });
-
-  it('should return false if isDisplayed is true & has no value', () => {
-    expect(shouldShowProperty({ isDisplayed: true, value: null })).toBeFalsy();
-  });
-});

package/tests/unit/src/helpers/sort-response-data.test.js

@@ -1,24 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import sortResponseData from '../../../../src/helpers/sort-response-data';
-import { MOCKED_SORT_DATA, MOCKED_SORT_IDS, MOCKED_SORT_RESULTS } from '../../../helpers/mocks';
-
-describe('sort response data function', () => {
-  const sortedWithAllMatching = sortResponseData(MOCKED_SORT_DATA, MOCKED_SORT_IDS);
-  const sortedWithNoIds = sortResponseData(MOCKED_SORT_DATA);
-  const sortedWithNoData = sortResponseData();
-
-  it('should be a function', () => {
-    expect(typeof sortResponseData).toEqual('function');
-  });
-
-  it('should return always an array', () => {
-    expect(Array.isArray(sortedWithAllMatching)).toBe(true);
-    expect(Array.isArray(sortedWithNoIds)).toBe(true);
-    expect(Array.isArray(sortedWithNoData)).toBe(true);
-  });
-  it('should return the sorted array depending on the data passed', () => {
-    expect(sortedWithAllMatching).toEqual(MOCKED_SORT_RESULTS[0]);
-    expect(sortedWithNoIds).toEqual(MOCKED_SORT_DATA);
-    expect(sortedWithNoData).toEqual([]);
-  });
-});

package/tests/unit/src/helpers/update-childrens-parent.test.js

@@ -1,41 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import updateChildrensParent from '../../../../src/helpers/update-childrens-parent';
-
-const id = 'some_id';
-const entity = 'page';
-const searchFilter = { type: 'searchfilter', settings: {} };
-const children = {
-  props: {
-    children: [
-      false,
-      [
-        {
-          props: {
-            options: {
-              parent: { itemId: 'id', itemEntity: 'article' },
-              searchFilter
-            }
-          }
-        },
-        { props: { options: { parent: { itemId: 'another_id', itemEntity: 'document' } } } }
-      ]
-    ]
-  }
-};
-
-describe("update children's parent", () => {
-  updateChildrensParent(children, id, entity);
-
-  it('should be a function', () => {
-    expect(typeof updateChildrensParent).toEqual('function');
-  });
-
-  it('should update the parent itemId, itemEntity and not override other props', () => {
-    expect(children.props.children[1][0].props.options.parent.itemId).toEqual(id);
-    expect(children.props.children[1][0].props.options.parent.itemEntity).toEqual(entity);
-    expect(children.props.children[1][1].props.options.parent.itemId).toEqual(id);
-    expect(children.props.children[1][1].props.options.parent.itemEntity).toEqual(entity);
-
-    expect(children.props.children[1][0].props.options.searchFilter).toEqual(searchFilter);
-  });
-});

package/tests/unit/src/hooks/helpers/StoreImages.test.js

@@ -1,26 +0,0 @@
-/**
- * @jest-environment node
- */
-import StoreImages from '../../../../../src/hooks/helpers/StoreImages';
-
-describe('StoreImages for GlobalLightbox', () => {
-  it('should be able to add images and duplicates removed', () => {
-    const image1 = { imageId: 1 };
-    const image2 = { imageId: 2 };
-    const images = [image1, image2];
-    StoreImages.addImages(images);
-    expect(StoreImages.images.length).toEqual(2);
-
-    StoreImages.addImages([image1]);
-    expect(StoreImages.images.length).toEqual(2);
-
-    expect(StoreImages.images).toEqual(images);
-  });
-
-  it('should be able to reset images', () => {
-    expect(StoreImages.images.length).toEqual(2);
-
-    StoreImages.resetImages();
-    expect(StoreImages.images.length).toEqual(0);
-  });
-});

package/tests/unit/src/hooks/helpers/append-gtm-classname.test.js

@@ -1,50 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import appendGtmClassName from '../../../../../src/hooks/helpers/append-gtm-classname';
-import {
-  MOCKED_GTM_CHILD_COMPONENTS,
-  MOCKED_GTM_CLASSNAME_SETTINGS
-} from '../../../../helpers/mocks';
-
-describe('appendGtmClassName function', () => {
-  const withGtmClassname = appendGtmClassName(
-    MOCKED_GTM_CLASSNAME_SETTINGS,
-    MOCKED_GTM_CHILD_COMPONENTS[0]
-  );
-  const withNoGtmClassname = appendGtmClassName(
-    MOCKED_GTM_CLASSNAME_SETTINGS,
-    MOCKED_GTM_CHILD_COMPONENTS[1]
-  );
-  const withNoChildren = appendGtmClassName(MOCKED_GTM_CLASSNAME_SETTINGS);
-  const withNoGtmValues = appendGtmClassName(
-    MOCKED_GTM_CLASSNAME_SETTINGS,
-    MOCKED_GTM_CHILD_COMPONENTS[1]
-  );
-
-  it('should be defined', () => {
-    expect(appendGtmClassName).toBeDefined();
-  });
-
-  it('should always return an object', () => {
-    expect(Array.isArray(withGtmClassname)).toBeFalsy();
-    expect(Array.isArray(withNoGtmClassname)).toBeFalsy();
-    expect(Array.isArray(withNoChildren)).toBeFalsy();
-    expect(Array.isArray(withNoGtmValues)).toBeFalsy();
-    expect(typeof withGtmClassname).toEqual('object');
-    expect(typeof withNoGtmClassname).toEqual('object');
-    expect(typeof withNoChildren).toEqual('object');
-    expect(typeof withNoGtmValues).toEqual('object');
-  });
-
-  it('should always return the initial settings if no children are passed', () => {
-    expect(withNoChildren).toEqual(MOCKED_GTM_CLASSNAME_SETTINGS);
-  });
-
-  it('should always return the initial settings if no gtm children or no gtmClassnames found', () => {
-    expect(withNoGtmValues).toEqual(MOCKED_GTM_CLASSNAME_SETTINGS);
-    expect(withNoGtmClassname).toEqual(MOCKED_GTM_CLASSNAME_SETTINGS);
-  });
-
-  it('should always return updated settings with the gtmClassName apended to the modifiers', () => {
-    expect(withGtmClassname.modifier).toEqual('gtm-classname');
-  });
-});

package/tests/unit/src/hooks/helpers/check-banner-insertion-set.test.js

@@ -1,48 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import checkBannerInsertionSet from '../../../../../src/hooks/helpers/check-banner-insertion-set';
-
-const id = 'ID';
-const getBanner = overrides => ({
-  type: 'banner',
-  id,
-  settings: {
-    baseAdunit: 'base',
-    ...overrides
-  }
-});
-const items = [
-  { type: 'card', id, settings: {} },
-  { type: 'list', id, settings: {} },
-  { type: 'textblock', id, settings: {} }
-];
-
-describe('checkBannerInsertionSet function', () => {
-  it('should be defined', () => {
-    expect(checkBannerInsertionSet).toBeDefined();
-  });
-
-  it('should return null when there are no items', () => {
-    expect(checkBannerInsertionSet([])).toEqual(null);
-  });
-
-  it('should return null when there is no banner', () => {
-    expect(checkBannerInsertionSet(items)).toEqual(null);
-  });
-
-  it('should return null when there is a banner but no interval set', () => {
-    items.push(getBanner());
-    expect(checkBannerInsertionSet(items)).toEqual(null);
-  });
-
-  it('should return banner element when there is a banner with interval set but also an insertionType', () => {
-    const banner = getBanner({ interval: '3', insertionType: 'textblock' });
-    items.push(banner);
-    expect(checkBannerInsertionSet(items)).toEqual(null);
-  });
-
-  it('should return banner element when there is a banner with interval set', () => {
-    const banner = getBanner({ interval: '3' });
-    items.push(banner);
-    expect(checkBannerInsertionSet(items)).toEqual(banner);
-  });
-});

package/tests/unit/src/hooks/helpers/check-collisions.test.js

@@ -1,44 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import {
-  checkIfHasCollided,
-  getCollisions
-} from '../../../../../src/hooks/helpers/check-collisions';
-
-const mockedSiblings = [
-  { type: 'banner', name: 'bannerComp' },
-  { type: 'carousel', name: 'carouselComp' },
-  { type: 'button', name: 'testCollider' },
-  { type: 'button', name: 'testCollider2' },
-  { type: 'image', name: 'imageComp2' },
-  { type: 'button', name: 'testCollider3' },
-  { type: 'image', name: 'imageComp3' }
-];
-describe('checkIfHasCollided and getCollisions functions', () => {
-  it('checkIfHasCollided should return true if collision occured', () => {
-    const collidedFirst = checkIfHasCollided(0, 12, true, false);
-    const collidedLast = checkIfHasCollided(12, 12, false, true);
-    const noCollisionMidle = checkIfHasCollided(6, 9, false, true);
-    const noCollision = checkIfHasCollided(6, 9, false, false);
-
-    expect(collidedFirst).toEqual(true);
-    expect(collidedLast).toEqual(true);
-    expect(noCollisionMidle).toEqual(false);
-    expect(noCollision).toEqual(false);
-  });
-
-  it('getCollisions should return if collided with any invalid components', () => {
-    const collidedBefore = getCollisions('testCollider', mockedSiblings);
-    const collidedAfter = getCollisions('testCollider2', mockedSiblings);
-    const collidedAfter2 = getCollisions('bannerComp', mockedSiblings);
-    const collidedOnBothEnds = getCollisions('testCollider3', mockedSiblings);
-    const noCollision = getCollisions('testCollider', []);
-    const noCollision2 = getCollisions('imageComp3', mockedSiblings);
-
-    expect(collidedBefore).toEqual([true, false]);
-    expect(collidedAfter).toEqual([false, true]);
-    expect(collidedAfter2).toEqual([false, true]);
-    expect(collidedOnBothEnds).toEqual([true, true]);
-    expect(noCollision).toEqual([false, false]);
-    expect(noCollision2).toEqual([false, false]);
-  });
-});

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

@@ -1,39 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getBannerIndex from '../../../../../src/hooks/helpers/get-banner-index';
-
-const id = 'ID';
-const BANNER = {
-  type: 'banner',
-  id,
-  settings: {
-    baseAdunit: 'base'
-  }
-};
-const items = [
-  { type: 'card', id, settings: {} },
-  { type: 'list', id, settings: {} },
-  BANNER,
-  { type: 'textblock', id, settings: {} }
-];
-
-describe('getBannerIndex function', () => {
-  const bannerIndex = getBannerIndex(items, BANNER);
-
-  it('should be defined', () => {
-    expect(getBannerIndex).toBeDefined();
-  });
-
-  it('should return correct index', () => {
-    expect(bannerIndex).toEqual(2);
-  });
-
-  it('should return -1 when there are no items', () => {
-    const bannerIndexNoItems = getBannerIndex([], BANNER);
-    expect(bannerIndexNoItems).toEqual(-1);
-  });
-
-  it('should return -1 when there is no banner', () => {
-    const bannerIndexNoItems = getBannerIndex(items, {});
-    expect(bannerIndexNoItems).toEqual(-1);
-  });
-});

package/tests/unit/src/hooks/helpers/get-components-to-insert-by-type.test.js

@@ -1,38 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getComponentsToInsertByType from '../../../../../src/hooks/helpers/get-components-to-insert-by-type';
-
-const id = 'ID';
-const mockBanner = {
-  type: 'banner',
-  id,
-  settings: {
-    baseAdunit: 'base',
-    insertionType: 'element'
-  }
-};
-
-const items = [
-  { type: 'card', id, settings: {} },
-  { type: 'list', id, settings: {} },
-  { type: 'textblock', id, settings: {} }
-];
-
-describe('getComponentsToInsertByType function', () => {
-  it('should return false and empty array when there are no items', () => {
-    const [noChildren, banner] = getComponentsToInsertByType();
-    expect(noChildren).toEqual(false);
-    expect(banner).toEqual([]);
-  });
-
-  it('should return false and empty array when there is no banner', () => {
-    const [hasBanner, banner] = getComponentsToInsertByType(items, 'element');
-    expect(hasBanner).toEqual(false);
-    expect(banner).toEqual([]);
-  });
-
-  it('should return banner element when there is a banner of specified type', () => {
-    const [hasBanner, banner] = getComponentsToInsertByType([...items, mockBanner], 'element');
-    expect(hasBanner).toEqual(true);
-    expect(banner).toEqual(banner);
-  });
-});

package/tests/unit/src/hooks/helpers/getComponent.test.js

@@ -1,30 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import '@testing-library/jest-dom/extend-expect';
-import getComponent from '../../../../../src/hooks/helpers/getComponent';
-import { componentMap } from '../../../../../src/utils';
-
-describe('getComponent function', () => {
-  const componentDetails = {
-    key: 'Button',
-    component: () => <div />
-  };
-  componentMap.add(componentDetails);
-
-  it('should be defined', () => {
-    expect(getComponent).toBeDefined();
-  });
-
-  it('should return a Component if exists', () => {
-    const Button = getComponent(componentDetails.key);
-    expect(Button).toBe(componentDetails.component);
-    expect(React.isValidElement(<Button />)).toEqual(true);
-  });
-
-  it('should return null if component do not exist', () => {
-    const FakeComponent = getComponent('FakeComponent');
-    expect(FakeComponent).toBeFalsy();
-  });
-});

package/tests/unit/src/hooks/helpers/inject-element-components.test.js

@@ -1,103 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import injectElementComponents from '../../../../../src/hooks/helpers/inject-element-components';
-
-const mockedChildren = [
-  { type: 'banner', name: 'bannerComp' },
-  { type: 'image', name: 'imageComp' },
-  { type: 'button', name: 'testCollider' },
-  { type: 'button', name: 'testCollider2' },
-  { type: 'image', name: 'imageComp2' },
-  { type: 'button', name: 'testCollider3' },
-  { type: 'image', name: 'imageComp3' }
-];
-
-const mockedResults = [
-  [
-    { type: 'banner', name: 'bannerComp' },
-    { type: 'image', name: 'imageComp' },
-    { type: 'button', name: 'testCollider' },
-    {
-      name: 'testBanner',
-      type: 'banner',
-      settings: {
-        repeatEvery: 1,
-        startingPoint: 0,
-        maxRepetitions: 4,
-        targetings: 'pos=999,posn=1'
-      }
-    },
-    { type: 'button', name: 'testCollider2' },
-    { type: 'image', name: 'imageComp2' },
-    { type: 'button', name: 'testCollider3' },
-    { type: 'image', name: 'imageComp3' }
-  ],
-  [
-    { type: 'banner', name: 'bannerComp' },
-    { type: 'image', name: 'imageComp' },
-    { type: 'button', name: 'testCollider' },
-    {
-      name: 'testBanner',
-      type: 'banner',
-      settings: {
-        repeatEvery: 1,
-        startingPoint: 0,
-        maxRepetitions: 1,
-        targetings: 'pos=999,posn=1'
-      }
-    },
-    { type: 'button', name: 'testCollider2' },
-    { type: 'image', name: 'imageComp2' },
-    { type: 'button', name: 'testCollider3' },
-    { type: 'image', name: 'imageComp3' }
-  ]
-];
-
-const mockedBanner = {
-  name: 'testBanner',
-  type: 'banner',
-  settings: { repeatEvery: 4, startingPoint: 4, maxRepetitions: 1, targetings: 'pos=999' }
-};
-
-describe('injectElementComponents function', () => {
-  it('should return the same children without banners if no banners can be injected', () => {
-    const noBannersInjected = injectElementComponents([mockedBanner], mockedChildren);
-    expect(noBannersInjected).toEqual(mockedChildren);
-  });
-
-  it('should return a modified array with injected banners', () => {
-    const withInjectedBanners = injectElementComponents(
-      [
-        {
-          ...mockedBanner,
-          settings: {
-            ...mockedBanner.settings,
-            startingPoint: 0,
-            repeatEvery: 1,
-            maxRepetitions: 4
-          }
-        }
-      ],
-      mockedChildren
-    );
-    expect(withInjectedBanners).toEqual(mockedResults[0]);
-  });
-
-  it('should not inject more banners than its max repetitions', () => {
-    const withSingleBanner = injectElementComponents(
-      [
-        {
-          ...mockedBanner,
-          settings: {
-            ...mockedBanner.settings,
-            startingPoint: 0,
-            repeatEvery: 1,
-            maxRepetitions: 1
-          }
-        }
-      ],
-      mockedChildren
-    );
-
-    expect(withSingleBanner).toEqual(mockedResults[1]);
-  });
-});