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

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

package/tests/unit/src/hooks/helpers/inject-textblock-banners.test.js

@@ -1,125 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import injectTextblockBanners from '../../../../../src/hooks/helpers/inject-textblock-banners';
-import setInitialBannerCounters from '../../../../../src/BannerContext/helpers/set-initial-banner-counters';
-
-jest.mock('../../../../../src/hooks/helpers/getComponent', () => jest.fn(() => 'Banner'));
-
-const mockedBanner = {
-  name: 'testBanner',
-  type: 'banner',
-  settings: { repeatEvery: 2, startingPoint: 1, maxRepetitions: 6 }
-};
-
-const defaultBanners = [mockedBanner];
-
-const props = { children: true };
-const pTag = { type: 'p', props };
-const emptyTag = '\n';
-const hTag = { type: 'h2', props };
-const ulTag = { type: 'ul', props };
-const nonStandardTag = { type: Symbol('non standard'), props }; // similar to parsed <br> tag
-
-const textBlockType = 'textblock';
-const siblings = [
-  { name: 'comp 1', type: textBlockType, parsedTextBlock: [hTag, emptyTag, pTag, pTag] },
-  { name: 'comp 2', type: 'image' },
-  { name: 'comp 3', type: textBlockType, parsedTextBlock: [pTag, ulTag, pTag, pTag] },
-  {
-    name: 'comp 4',
-    type: textBlockType,
-    parsedTextBlock: [pTag, hTag, pTag, pTag, nonStandardTag]
-  },
-  { name: 'comp 5', type: 'carousel' },
-  { name: 'comp 6', type: textBlockType, parsedTextBlock: [pTag, pTag] },
-  { name: 'comp 7', type: textBlockType, parsedTextBlock: [hTag, pTag] },
-  { name: 'comp 8', type: textBlockType, parsedTextBlock: [pTag] },
-  { name: 'comp 9', type: textBlockType, parsedTextBlock: [pTag, pTag] }
-];
-
-const getBannerContent = (banners = defaultBanners) => ({
-  bannerCounters: setInitialBannerCounters(banners),
-  banners,
-  siblings,
-  pbOptions: { options: true },
-  bannerPositionCounter: { counter: 0 },
-  blockTracker: { lastBlockType: null }
-});
-
-describe('injectTextblockBanners function', () => {
-  describe('Injection with core settings', () => {
-    const bannerContext = getBannerContent();
-    let updatedBlocks;
-
-    it('should inject banner after the first P tag', () => {
-      updatedBlocks = callWithComponent(siblings[0], bannerContext);
-      checkIsBanner(updatedBlocks[3], 1);
-    });
-
-    it('should inject another banner after two more html tags', () => {
-      updatedBlocks = callWithComponent(siblings[2], bannerContext);
-      checkIsBanner(updatedBlocks[1], 2);
-      checkIsBanner(updatedBlocks[4], 3);
-    });
-
-    it('should inject before H tag but not before non standard tags', () => {
-      updatedBlocks = callWithComponent(siblings[3], bannerContext);
-      const expectedBannerPosition = 1;
-      checkIsBanner(updatedBlocks[expectedBannerPosition], 4);
-      expect(updatedBlocks[expectedBannerPosition + 4]).toBe(
-        siblings[3].parsedTextBlock[expectedBannerPosition + 3]
-      );
-    });
-
-    it('should not inject when next to an image/carousel components', () => {
-      updatedBlocks = callWithComponent(siblings[5], bannerContext);
-      checkIsBanner(updatedBlocks[1], 5);
-    });
-
-    it('should not inject banner after to an H tag', () => {
-      updatedBlocks = callWithComponent(siblings[6], bannerContext);
-      expect(updatedBlocks).toEqual(siblings[6].parsedTextBlock);
-    });
-
-    it('should not insert after maxRepetitions reached', () => {
-      updatedBlocks = callWithComponent(siblings[7], bannerContext);
-      checkIsBanner(updatedBlocks[0], 6);
-
-      updatedBlocks = callWithComponent(siblings[8], bannerContext);
-      expect(updatedBlocks).toEqual(siblings[8].parsedTextBlock);
-    });
-  });
-
-  describe('Injection without repeat', () => {
-    const mockedBannerWithNoRepeat = {
-      name: 'testBanner',
-      settings: { startingPoint: 1 }
-    };
-    const bannerContext = getBannerContent([mockedBannerWithNoRepeat]);
-    let updatedBlocks;
-
-    it('should inject only once', () => {
-      updatedBlocks = callWithComponent(siblings[0], bannerContext);
-      checkIsBanner(updatedBlocks[3]);
-
-      updatedBlocks = callWithComponent(siblings[2], bannerContext);
-      expect(updatedBlocks).toEqual(siblings[2].parsedTextBlock);
-    });
-  });
-});
-
-function checkIsBanner(banner, posn) {
-  expect(banner).toHaveProperty('props.name', mockedBanner.name);
-  if (posn) {
-    expect(banner).toHaveProperty('props.targetings', `posn=${posn}`);
-  } else {
-    expect(banner).not.toHaveProperty('props.targetings');
-  }
-}
-
-function callWithComponent({ name: componentName, parsedTextBlock }, bannerContext) {
-  return injectTextblockBanners({
-    bannerContext,
-    parsedTextBlock,
-    componentName
-  });
-}