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

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

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

@@ -1,127 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import insertBanners from '../../../../../src/hooks/helpers/insert-banners';
-
-const id = 'ID';
-const getBanner = overrides => ({
-  type: 'banner',
-  id,
-  settings: {
-    baseAdunit: 'base',
-    interval: '2',
-    repeat: false,
-    ...overrides
-  }
-});
-const CARD = { type: 'card', id, settings: {} };
-const TEXTBLOCK = { type: 'textblock', id, settings: {} };
-const getItems = overrides => [
-  CARD,
-  CARD,
-  TEXTBLOCK,
-  TEXTBLOCK,
-  TEXTBLOCK,
-  TEXTBLOCK,
-  TEXTBLOCK,
-  getBanner(overrides)
-];
-const intervalBanners = (mockedProps, length) =>
-  Array.from({ length }, (_, i) => getBanner({ ...mockedProps, targetings: `posn=${i + 1}` }));
-
-describe('insertBanners function', () => {
-  it('should be defined', () => {
-    expect(insertBanners).toBeDefined();
-  });
-
-  it('should return correctly updated items if interval has no comma and repeat is not turned on', () => {
-    const updatedItems = [
-      CARD,
-      CARD,
-      getBanner({ targetings: 'posn=1' }),
-      TEXTBLOCK,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      TEXTBLOCK
-    ];
-    expect(insertBanners(getItems(), 7, getBanner())).toEqual(updatedItems);
-  });
-
-  it('should return correctly updated items if interval has no comma and repeat is turned on', () => {
-    const mockedProps = { repeat: true };
-    const banner = getBanner(mockedProps);
-    const [banner1, banner2, banner3] = intervalBanners(mockedProps, 3);
-
-    const updatedItems = [
-      CARD,
-      CARD,
-      banner1,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      banner2,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      banner3,
-      TEXTBLOCK
-    ];
-    expect(insertBanners(getItems(mockedProps), 7, banner)).toEqual(updatedItems);
-  });
-
-  it('should return correctly updated items if interval has comma and repeat is not turned on', () => {
-    const mockedProps = { interval: '2,5' };
-    const banner = getBanner(mockedProps);
-    const [banner1, banner2] = intervalBanners(mockedProps, 2);
-
-    const updatedItems = [
-      CARD,
-      CARD,
-      banner1,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      banner2,
-      TEXTBLOCK,
-      TEXTBLOCK
-    ];
-    expect(insertBanners(getItems(mockedProps), 7, banner)).toEqual(updatedItems);
-  });
-
-  it('should return correctly updated items if interval has comma and repeat is turned on', () => {
-    const mockedProps = { interval: '2,5', repeat: true };
-    const banner = getBanner(mockedProps);
-    const [banner1, banner2, banner3, banner4] = intervalBanners(mockedProps, 4);
-    const updatedItems = [
-      CARD,
-      CARD,
-      banner1,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      banner2,
-      TEXTBLOCK,
-      banner3,
-      TEXTBLOCK,
-      banner4,
-      TEXTBLOCK
-    ];
-    expect(insertBanners(getItems(mockedProps), 7, banner)).toEqual(updatedItems);
-  });
-
-  it('should return correctly updated items if interval has comma and repeat is turned on (different banner settings)', () => {
-    const mockedProps = { interval: '3,5,7', repeat: true };
-    const banner = getBanner(mockedProps);
-    const [banner1, banner2, banner3, banner4] = intervalBanners(mockedProps, 4);
-    const updatedItems = [
-      CARD,
-      CARD,
-      TEXTBLOCK,
-      banner1,
-      TEXTBLOCK,
-      TEXTBLOCK,
-      banner2,
-      TEXTBLOCK,
-      banner3,
-      TEXTBLOCK,
-      banner4
-    ];
-    expect(insertBanners(getItems(mockedProps), 7, banner)).toEqual(updatedItems);
-  });
-});

package/tests/unit/src/hooks/helpers/split-children.test.js

@@ -1,78 +0,0 @@
-import splitChildren from '../../../../../src/helpers/split-children';
-
-const mockedChildren = [
-  {
-    props: {
-      children: [
-        false,
-        [
-          { props: { component: { type: 'gtm-events', settings: {} } } },
-          { props: { component: { type: 'button', settings: {} } } }
-        ]
-      ]
-    }
-  },
-  {
-    props: {
-      children: [
-        false,
-        [{ props: { component: { type: 'banner' } } }, { props: { component: { type: 'image' } } }]
-      ]
-    }
-  }
-];
-
-const mockedParentData = {
-  name: 'parent data',
-  category: 'more data',
-  id: 'itemId',
-  __typename: 'PublishedPage'
-};
-const itemEntity = { PublishedPage: 'page' };
-
-describe('get list children', () => {
-  const { gtmChildren: withGtmChildren, regularChildren } = splitChildren(mockedChildren[0], []);
-  const { gtmChildren: noGtmChildren, regularChildren: moreRegularChildren } = splitChildren(
-    mockedChildren[1],
-    []
-  );
-  const { gtmChildren: noValueCaseGtm, regularChildren: noValueCase } = splitChildren(null, []);
-  const { regularChildren: arrayCase } = splitChildren([], []);
-  const { gtmChildren: gtmChildrenWithData } = splitChildren(
-    mockedChildren[0],
-    [mockedParentData],
-    itemEntity
-  );
-  it('should return children objects separated by gtm and non gtm', () => {
-    expect(Array.isArray(regularChildren.props.children[1])).toBe(true);
-    expect(Array.isArray(moreRegularChildren.props.children[1])).toBe(true);
-  });
-
-  it('should return object of gtm children if present', () => {
-    expect(Array.isArray(withGtmChildren.props.children[1])).toBe(true);
-  });
-
-  it('should return null if no gtm child is present', () => {
-    expect(noGtmChildren).toBe(null);
-  });
-
-  it('should return regular children even if no gtm is present', () => {
-    expect(regularChildren.props.children[1].length).toBe(1);
-  });
-
-  it('should return the same children prop passed if it is empty or not an iterable object', () => {
-    expect(noValueCase).toBe(null);
-    expect(noValueCaseGtm).toBe(undefined);
-    expect(Array.isArray(arrayCase)).toBe(true);
-  });
-
-  it('if parent data is passed gtm children should have it within once returned', () => {
-    expect(gtmChildrenWithData.props.children[1][0].props.component.settings.parentData).toEqual([
-      {
-        ...mockedParentData,
-        itemId: mockedParentData.id,
-        itemEntity: 'page'
-      }
-    ]);
-  });
-});

package/tests/unit/src/hooks/helpers/update-targetings.test.js

@@ -1,13 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import updateTargetings from '../../../../../src/hooks/helpers/update-targetings';
-
-describe('updateTargetings function', () => {
-  const mockedBanner = {
-    settings: { targetings: 'pos=12' }
-  };
-
-  it('should return banner with updated targetings', () => {
-    const updatedBanner = updateTargetings(mockedBanner, 12);
-    expect(updatedBanner).toEqual({ settings: { targetings: 'pos=12,posn=13' } });
-  });
-});

package/tests/unit/src/hooks/use-app-event-hook.test.js

@@ -1,64 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import { renderHook, waitFor } from '@testing-library/react';
-import { AppContext } from '@blaze-cms/nextjs-components';
-import { useAppEventHook } from '../../../../src/hooks';
-
-describe('useAppEventHook', () => {
-  const eventName = 'test-event';
-  const initialData = { foo: 'bar' };
-  const props = { prop1: 'val1' };
-  let blazeAppMock;
-
-  beforeEach(() => {
-    blazeAppMock = {
-      events: {
-        hasListeners: jest.fn(),
-        emitAsync: jest.fn().mockResolvedValue()
-      }
-    };
-  });
-
-  const wrapper = ({ children }) => (
-    <AppContext.Provider value={{ blazeApp: blazeAppMock }}>{children}</AppContext.Provider>
-  );
-
-  it('should not emit event if there are no listeners', () => {
-    blazeAppMock.events.hasListeners.mockReturnValue(false);
-
-    const { result } = renderHook(() => useAppEventHook({ eventName, data: initialData, props }), {
-      wrapper
-    });
-
-    expect(result.current.loading).toBe(false);
-    expect(result.current.data).toEqual(initialData); // Returns initial data immediately
-    expect(blazeAppMock.events.emitAsync).not.toHaveBeenCalled();
-  });
-
-  it('should emit async event if listeners exist', async () => {
-    blazeAppMock.events.hasListeners.mockReturnValue(true);
-
-    const { result } = renderHook(() => useAppEventHook({ eventName, data: initialData, props }), {
-      wrapper
-    });
-
-    // Initial state: loading is true because hasListeners is true
-    expect(result.current.loading).toBe(true);
-
-    await waitFor(() => {
-      expect(blazeAppMock.events.emitAsync).toHaveBeenCalledWith(
-        `plugin:page-builder:${eventName}`,
-        {
-          data: initialData,
-          props
-        }
-      );
-    });
-
-    // Loading should be false after emitAsync resolves
-    expect(result.current.loading).toBe(false);
-    expect(result.current.data).toEqual(initialData);
-  });
-});

package/tests/unit/src/hooks/use-app-sync-evet-hook.test.js

@@ -1,70 +0,0 @@
-import React from 'react';
-import { renderHook } from '@testing-library/react';
-import { AppContext } from '@blaze-cms/nextjs-components';
-import { useAppSyncEventHook } from '../../../../src/hooks';
-
-describe('useAppSyncEventHook', () => {
-  const eventName = 'testEvent';
-  const data = { key: 'value' };
-  const props = { someProp: 'value' };
-
-  const blazeAppMock = {
-    events: {
-      emit: jest.fn()
-    }
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  test('should emit event with correct event name and data', () => {
-    const wrapper = ({ children }) => (
-      <AppContext.Provider value={{ blazeApp: blazeAppMock }}>{children}</AppContext.Provider>
-    );
-
-    const { result } = renderHook(() => useAppSyncEventHook({ eventName, data, props }), {
-      wrapper
-    });
-
-    expect(blazeAppMock.events.emit).toHaveBeenCalledWith(`plugin:page-builder:${eventName}:sync`, {
-      data,
-      props
-    });
-
-    expect(result.current.data).toEqual(data);
-  });
-
-  test('should not emit event on render when using returnFunction', () => {
-    const wrapper = ({ children }) => (
-      <AppContext.Provider value={{ blazeApp: blazeAppMock }}>{children}</AppContext.Provider>
-    );
-
-    const { result } = renderHook(
-      () => useAppSyncEventHook({ eventName, data, props, returnFunction: true }),
-      {
-        wrapper
-      }
-    );
-
-    expect(blazeAppMock.events.emit).not.toHaveBeenCalled();
-
-    result.current.runHook();
-
-    expect(blazeAppMock.events.emit).toHaveBeenCalledWith(`plugin:page-builder:${eventName}:sync`, {
-      data,
-      props
-    });
-
-    expect(result.current.data).toEqual(data);
-  });
-
-  test('should return correct data', () => {
-    const wrapper = ({ children }) => (
-      <AppContext.Provider value={{ blazeApp: blazeAppMock }}>{children}</AppContext.Provider>
-    );
-    const { result } = renderHook(() => useAppSyncEventHook({ data }), { wrapper });
-
-    expect(result.current.data).toEqual(data);
-  });
-});

package/tests/unit/src/hooks/use-check-mobile-screen.test.js

@@ -1,47 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import { renderHook, waitFor, act } from '@testing-library/react';
-import { useCheckMobileScreen } from '../../../../src/hooks';
-// TODO fix breaking test
-describe('Check Mobile Screen hook', () => {
-  it('should server render will always be mobile', () => {
-    delete window.innerWidth;
-    const { result } = renderHook(() => useCheckMobileScreen());
-    expect(result.current).toBe(true);
-  });
-
-  it('should intial render on client will be mobile', () => {
-    const { result } = renderHook(() => useCheckMobileScreen());
-    expect(result.current).toBe(true);
-  });
-
-  it('should return false if on desktop', async () => {
-    const screenSize = 1080;
-    const isMobile = false;
-    await resizeCheck(screenSize, isMobile);
-  });
-
-  it('should return true if on mobile', async () => {
-    const screenSize = 600;
-    const isMobile = true;
-    await resizeCheck(screenSize, isMobile);
-  });
-});
-
-async function resizeCheck(screenSize, isMobile) {
-  const { result, rerender } = renderHook(() => useCheckMobileScreen());
-
-  act(() => {
-    Object.defineProperty(window, 'innerWidth', {
-      writable: true,
-      configurable: true,
-      value: screenSize
-    });
-    window.dispatchEvent(new Event('resize'));
-  });
-
-  await waitFor(() => {
-    expect(result.current).toBe(isMobile);
-  });
-}

package/tests/unit/src/hooks/use-get-entity-schema-as-obj.test.js

@@ -1,46 +0,0 @@
-import { useQuery } from '@apollo/client';
-import { useGetEntitySchemasAsObj } from '../../../../src/hooks';
-
-import { getMultipleSchema } from '../../../../src/application/query';
-
-jest.mock('@apollo/client', () => ({
-  useQuery: jest.fn(() => ({ data: {}, loading: false, error: null }))
-}));
-
-jest.mock('../../../../src/application/query', () => ({
-  getMultipleSchema: jest.fn(() => 'query')
-}));
-
-describe('useGetSingleEntitySchema hook', () => {
-  const identifiers = ['schema1', 'schema2'];
-  const mockQueryString = 'query';
-  const placeholderSchemaArray = ['placeholder'];
-
-  beforeEach(() => {
-    useQuery.mockClear();
-    getMultipleSchema.mockClear();
-  });
-  it('should return a single schema object', async () => {
-    expect(typeof useGetEntitySchemasAsObj).toEqual('function');
-  });
-
-  it('should skip getting schema when shouldSkip=true', async () => {
-    const shouldSkip = true;
-    useGetEntitySchemasAsObj(identifiers, shouldSkip);
-    expect(useQuery).toHaveBeenCalledWith(mockQueryString, { skip: shouldSkip });
-    expect(getMultipleSchema).toHaveBeenCalledWith(placeholderSchemaArray);
-  });
-
-  it('should skip when no identifiers', async () => {
-    useGetEntitySchemasAsObj([]);
-    expect(useQuery).toHaveBeenCalledWith(mockQueryString, { skip: true });
-    expect(getMultipleSchema).toHaveBeenCalledWith(placeholderSchemaArray);
-  });
-
-  it('should filter out duplicate and non truthy schema', async () => {
-    const dupSchema = 'dup_schema';
-    useGetEntitySchemasAsObj([dupSchema, dupSchema, null, undefined, '']);
-    expect(useQuery).toHaveBeenCalledWith(mockQueryString, { skip: false });
-    expect(getMultipleSchema).toHaveBeenCalledWith([dupSchema]);
-  });
-});