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

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

package/tests/unit/src/hooks/use-get-image-id-from-relation.test.js

@@ -1,92 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import { renderHook } from '@testing-library/react';
-import { MockedProvider } from '@apollo/client/testing';
-
-import useGetImageIdFromRelation from '../../../../src/hooks/use-get-image-id-from-relation';
-import * as query from '../../../../src/application/query';
-import { GET_IMAGE_ID_FROM_RELATION_MOCK } from '../../../helpers/mocks';
-
-const expectedIdFromRelation = 'e222e300-e211-11ea-bb57-75eb5a4f187b';
-
-const mockProps = {
-  id: expectedIdFromRelation,
-  imageRelation: ['publishedPages.imageId'],
-  actions: {
-    create: 'createPage',
-    update: 'updatePage',
-    delete: 'deletePage',
-    deleteAll: 'deletePages',
-    undefined: 'doPublishPage',
-    publish: 'publishPage',
-    unpublish: 'unpublishPage',
-    get: 'getPage',
-    getAll: 'getPages',
-    countAll: 'countPages',
-    getPublished: 'getPublishedPage',
-    getAllPublished: 'getPublishedPages',
-    countAllPublished: 'countPublishedPages'
-  },
-  isUsingRelationImage: true,
-  isPreview: false
-};
-
-const wrapper = ({ children }) => (
-  <MockedProvider mocks={GET_IMAGE_ID_FROM_RELATION_MOCK}>{children}</MockedProvider>
-);
-
-describe('useGetImageIdFromRelation', () => {
-  it('should use `get` query when preview is true', async () => {
-    const spy = jest.spyOn(query, 'generateSingleItemQuery');
-
-    renderHook(() => useGetImageIdFromRelation(mockProps.id, [], mockProps.actions, true, true), {
-      wrapper
-    });
-
-    expect(spy).toHaveBeenCalledWith('getPage', 'id');
-  });
-
-  it('should use `getPublished` query when preview is false', async () => {
-    const spy = jest.spyOn(query, 'generateSingleItemQuery');
-
-    renderCustomHook();
-
-    expect(spy).toHaveBeenCalledWith('getPublishedPage', 'publishedPages { imageId }');
-  });
-
-  it('should skip when isUsingRelationImage is false', async () => {
-    const { result } = renderHook(
-      () =>
-        useGetImageIdFromRelation(
-          mockProps.id,
-          mockProps.imageRelation,
-          mockProps.actions,
-          false,
-          false
-        ),
-      { wrapper }
-    );
-
-    expect(result.current.loading).toBeFalsy();
-    expect(result.current.error).toBeUndefined();
-    expect(result.current.data).toEqual({});
-  });
-});
-
-function renderCustomHook() {
-  const { result } = renderHook(
-    () =>
-      useGetImageIdFromRelation(
-        mockProps.id,
-        mockProps.imageRelation,
-        mockProps.actions,
-        true,
-        false
-      ),
-    { wrapper }
-  );
-
-  return { result };
-}

package/tests/unit/src/hooks/use-get-images.test.js

@@ -1,167 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import '@testing-library/jest-dom/extend-expect';
-import { MockedProvider } from '@apollo/client/testing';
-import { renderHook, waitFor } from '@testing-library/react';
-import { useGetImages } from '../../../../src/hooks';
-import { getFiles, getFileById } from '../../../../src/application/query';
-
-const id1 = 'test-id-1';
-const id2 = 'test-id-2';
-const resultData = [
-  {
-    id: id1,
-    url: 'test-url-1',
-    data: {
-      caption: 'test-caption-1'
-    }
-  },
-  {
-    id: id2,
-    url: 'test-url-2',
-    data: null
-  }
-];
-
-const ARRAY_MOCK = [
-  {
-    request: {
-      query: getFiles,
-      variables: { where: { id: { _in: [id1, id2] } } }
-    },
-    result: {
-      data: {
-        getFiles: resultData
-      }
-    }
-  },
-  {
-    request: {
-      query: getFiles,
-      variables: { where: { id: { _in: [id1] } } }
-    },
-    result: {
-      data: {
-        getFiles: [resultData[0]]
-      }
-    }
-  }
-];
-
-const STRING_MOCK = [
-  {
-    request: {
-      query: getFileById,
-      variables: { id: id1 }
-    },
-    result: {
-      data: {
-        getFile: resultData[0]
-      }
-    }
-  }
-];
-
-describe('UseGetImages hook', () => {
-  const arrayWrapper = ({ children }) => (
-    <MockedProvider mocks={ARRAY_MOCK}>{children}</MockedProvider>
-  );
-
-  it('should return expected value (id is an array)', async () => {
-    const wrapper = ({ children }) => (
-      <MockedProvider mocks={ARRAY_MOCK}>{children}</MockedProvider>
-    );
-    const ids = [id1, id2];
-    const hasMultipleIds = true;
-    const { result } = renderHook(() => useGetImages(ids, hasMultipleIds), {
-      wrapper
-    });
-
-    expect(result.current.loading).toEqual(true);
-
-    await waitFor(() => {
-      const { loading } = result.current;
-      expect(loading).toBe(false);
-    });
-
-    expect(result.current).toEqual({
-      data: {
-        getFiles: resultData
-      },
-      error: undefined,
-      loading: false
-    });
-  });
-
-  it('should return expected value (id is an array) when id is string', async () => {
-    const { result } = renderHook(() => useGetImages(id1, true), {
-      wrapper: arrayWrapper
-    });
-
-    expect(result.current.loading).toEqual(true);
-
-    await waitFor(() => {
-      const { loading } = result.current;
-      expect(loading).toBe(false);
-    });
-
-    expect(result.current).toEqual({
-      data: {
-        getFiles: [resultData[0]]
-      },
-      error: undefined,
-      loading: false
-    });
-  });
-
-  it('should skip useQuery if no id data set', async () => {
-    const expectedResults = {
-      data: {},
-      error: undefined,
-      loading: false
-    };
-
-    const { result: resultForArray } = renderHook(() => useGetImages(null, true), {
-      wrapper: arrayWrapper
-    });
-
-    const { result: resultForEmptyArray } = renderHook(() => useGetImages([], true), {
-      wrapper: arrayWrapper
-    });
-
-    const { result: resultForSingle } = renderHook(() => useGetImages(null, false), {
-      wrapper: arrayWrapper
-    });
-
-    expect(resultForArray.current).toEqual(expectedResults);
-    expect(resultForEmptyArray.current).toEqual(expectedResults);
-    expect(resultForSingle.current).toEqual(expectedResults);
-  });
-
-  it('should return expected value (id is a string)', async () => {
-    const wrapper = ({ children }) => (
-      <MockedProvider mocks={STRING_MOCK}>{children}</MockedProvider>
-    );
-
-    const { result } = renderHook(() => useGetImages(id1), {
-      wrapper
-    });
-
-    expect(result.current.loading).toEqual(true);
-
-    await waitFor(() => {
-      const { loading } = result.current;
-      expect(loading).toBe(false);
-    });
-
-    expect(result.current).toEqual({
-      data: {
-        getFile: resultData[0]
-      },
-      error: undefined,
-      loading: false
-    });
-  });
-});

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

@@ -1,80 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import { renderHook, waitFor } from '@testing-library/react';
-import { MockedProvider } from '@apollo/client/testing';
-import { useGetSingleEntitySchema } from '../../../../src/hooks';
-import { getSingleEntitySchema } from '../../../../src/application/query';
-
-const mockQueryResults = {
-  id: 'page',
-  identifier: 'page',
-  properties: {},
-  dynamicProperties: {},
-  actions: {},
-  interfaces: {},
-  relations: {},
-  __typename: 'DataEntitySchemaDefinition'
-};
-
-const getSingleEntitySchemaMock = {
-  request: {
-    query: getSingleEntitySchema,
-    variables: {
-      id: 'page'
-    }
-  },
-  result: {
-    data: {
-      getEntitySchema: {
-        id: 'page',
-        identifier: 'page',
-        properties: {},
-        dynamicProperties: {},
-        actions: {},
-        interfaces: {},
-        relations: {},
-        __typename: 'DataEntitySchemaDefinition'
-      }
-    }
-  }
-};
-
-const wrapper = ({ children }) => (
-  <MockedProvider mocks={[getSingleEntitySchemaMock]}>{children}</MockedProvider>
-);
-
-describe('useGetSingleEntitySchema hook', () => {
-  it('should return a single schema object', async () => {
-    const { result } = renderHook(() => useGetSingleEntitySchema('page'), {
-      wrapper
-    });
-
-    await waitFor(() => {
-      const { loading } = result.current;
-      expect(loading).toBe(false);
-    });
-
-    expect(result.current).toEqual({
-      data: {
-        getEntitySchema: mockQueryResults
-      },
-      error: undefined,
-      loading: false
-    });
-  });
-
-  it('should skip the query if skip is true', async () => {
-    const { result } = renderHook(() => useGetSingleEntitySchema('page', true), {
-      wrapper
-    });
-
-    expect(result.current.loading).toEqual(false);
-    expect(result.current).toEqual({
-      data: undefined,
-      error: undefined,
-      loading: false
-    });
-  });
-});

package/tests/unit/src/utils/component-map.test.js

@@ -1,56 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import '@testing-library/jest-dom/extend-expect';
-import { componentMap } from '../../../../src/utils';
-
-describe('component map function', () => {
-  const buttonComponentDetails = {
-    key: 'Button',
-    component: () => <div />
-  };
-
-  it('should return an object with random id and three methods', () => {
-    expect(typeof componentMap).toEqual('object');
-    expect(typeof componentMap.add).toEqual('function');
-    expect(typeof componentMap.get).toEqual('function');
-    expect(typeof componentMap.getAll).toEqual('function');
-    expect(typeof componentMap.id).toEqual('number');
-  });
-
-  it('should throw error if we try to add an object with no key', () => {
-    const emptyKey = {
-      component: () => <div />
-    };
-    expect(() => componentMap.add(emptyKey)).toThrow('Component requires key and component');
-  });
-
-  it('should throw error if we try to add an object with no component', () => {
-    const emptyComponent = {
-      key: 'Button'
-    };
-    expect(() => componentMap.add(emptyComponent)).toThrow('Component requires key and component');
-  });
-
-  it('should add component', () => {
-    const randomComponentDetails = {
-      key: 'Random',
-      component: () => <div />
-    };
-
-    componentMap.add(buttonComponentDetails);
-    componentMap.add(randomComponentDetails);
-    const element = componentMap.get('Button');
-    expect(element).toEqual(buttonComponentDetails.component);
-  });
-
-  it('should return correct number of entries', () => {
-    const entries = componentMap.getAll();
-    expect(entries.length).toEqual(2);
-  });
-
-  it('should throw error if we try to add an object that has already been added', () => {
-    expect(() => componentMap.add(buttonComponentDetails)).toThrow('Component already exist');
-  });
-});

package/tests/unit/src/utils/get-class-modifiers.test.js

@@ -1,116 +0,0 @@
-import { getClassModifiers } from '../../../../src/utils';
-
-describe('get class modifiers', () => {
-  const parallaxClass = 'image--parallax';
-  const mockedProps = {
-    desktop: true,
-    mobile: false,
-    tablet: false,
-    modifier: 'modify',
-    width: 'boxed'
-  };
-  const classModifiers = getClassModifiers('row', mockedProps);
-
-  it('should be a function', () => {
-    expect(typeof getClassModifiers).toEqual('function');
-  });
-
-  it('should always return a string', () => {
-    expect(typeof classModifiers).toBe('string');
-  });
-
-  it('should return correct class based on arguments passed to function', () => {
-    expect(classModifiers).toEqual('row--boxed hide-tablet hide-mobile modify');
-  });
-
-  it('should retun blank space when props do not contain a supported prop for the type', () => {
-    const notSupportedProp = getClassModifiers('not-supported', mockedProps);
-    expect(notSupportedProp).toEqual('');
-  });
-
-  it('should return button--icon class when props include icon & icon has value', () => {
-    const iconMockedProps = {
-      icon: 'test icon'
-    };
-    const iconModifiers = getClassModifiers('button', iconMockedProps);
-    expect(iconModifiers).toContain('button--icon');
-  });
-
-  it('should not add supported prop when propvalue is default', () => {
-    const defaultMockedProps = {
-      modifier: 'alignment',
-      alignment: 'default'
-    };
-    const defaultModifiers = getClassModifiers('button', defaultMockedProps);
-    expect(defaultModifiers).not.toContain('default');
-  });
-
-  it('should return alignment value', () => {
-    const alignmentProps = {
-      modifier: 'alignment',
-      alignment: 'center'
-    };
-    const alignmentModifiers = getClassModifiers('button', alignmentProps);
-    expect(alignmentModifiers).toContain('button--center');
-  });
-
-  it('should return gtmClassName value ', () => {
-    const alignmentProps = {
-      gtmClassName: 'gtm--test--classname'
-    };
-    const gtmModifiers = getClassModifiers('button', alignmentProps);
-    expect(gtmModifiers).toContain('gtm--test--classname');
-  });
-
-  it('should return string based on type & value if not match with any of the conditions', () => {
-    const alignmentProps = {
-      alignment: 'center'
-    };
-    const gtmModifiers = getClassModifiers('button', alignmentProps);
-    expect(gtmModifiers).toContain('button--center');
-  });
-
-  it('should return string based on type if prop is sticky & propValue is true', () => {
-    const columnMockedProps = {
-      sticky: true
-    };
-    const columnModifiers = getClassModifiers('column', columnMockedProps);
-    expect(columnModifiers).toContain('column--sticky');
-  });
-
-  it('should return empty string if prop is sticky & propValue is false', () => {
-    const columnMockedProps = {
-      sticky: false
-    };
-    const columnModifiers = getClassModifiers('column', columnMockedProps);
-    expect(columnModifiers).toContain('');
-  });
-
-  it('should return default values when nothing has been set', () => {
-    const unsetProps = {
-      type: null,
-      style: null,
-      size: null,
-      alignment: null
-    };
-    const defaultProps = getClassModifiers('button', unsetProps);
-    expect(defaultProps).toContain('button--center alignment');
-  });
-
-  it('should add parallax settings', () => {
-    const imageMockedProps = {
-      parallax: true
-    };
-    expect(getClassModifiers('image', imageMockedProps)).toContain(parallaxClass);
-  });
-
-  it('should not add parallax if false or not present', () => {
-    const imageMockedProps = {
-      parallax: false
-    };
-    expect(getClassModifiers('image', imageMockedProps)).not.toContain(parallaxClass);
-
-    delete imageMockedProps.parallax;
-    expect(getClassModifiers('image', imageMockedProps)).not.toContain(parallaxClass);
-  });
-});

package/tests/unit/src/utils/get-image-data.test.js

@@ -1,54 +0,0 @@
-import { getImageData } from '../../../../src/utils';
-
-describe('get image data', () => {
-  const altText = 'altText-test-prop';
-  const caption = 'caption-test-prop';
-  const credits = 'credits-test-prop';
-  const mockedProps = {
-    alt: altText,
-    caption,
-    credits
-  };
-
-  const mockedData = {
-    altText: 'altText-test-data',
-    caption: 'caption-test-data',
-    hrefUrl: 'hrefUrl-test-data',
-    credits: 'credits-test-data'
-  };
-
-  it('should be a function', () => {
-    expect(typeof getImageData).toEqual('function');
-  });
-
-  it('should always return an object', () => {
-    expect(typeof getImageData({}, {})).toBe('object');
-  });
-
-  it('should return expected value if has props', () => {
-    const imageData = getImageData(mockedProps, {});
-    const expected = {
-      credits,
-      altText,
-      caption,
-      hrefUrl: ''
-    };
-    expect(imageData).toEqual(expected);
-  });
-
-  it('should return expected value if has data', () => {
-    const imageData = getImageData({}, mockedData);
-    expect(imageData).toEqual(mockedData);
-  });
-
-  it('should return expected value if has props & data', () => {
-    const imageData = getImageData(mockedProps, mockedData);
-    const expected = {
-      altText,
-      caption,
-      hrefUrl: 'hrefUrl-test-data',
-      credits
-    };
-    expect(imageData).toEqual(expected);
-  });
-});

package/tests/unit/src/utils/get-props-to-display-modifiers.test.js

@@ -1,14 +0,0 @@
-import { getPropsToDisplayModifiers } from '../../../../src/utils';
-
-describe('getPropsToDisplayModifiers function', () => {
-  const mockedPropsToDisplay = [
-    { name: 'prop1', modifier: 'modifier 1' },
-    { slug: '/pro-2' },
-    { title: 'prop 3', modifier: 'modifier 3' }
-  ];
-
-  it('should return an array of modifiers', () => {
-    const expected = ['modifier 1', '', 'modifier 3'];
-    expect(getPropsToDisplayModifiers(mockedPropsToDisplay)).toEqual(expected);
-  });
-});

package/tests/unit/src/utils/is-object-empty.test.js

@@ -1,22 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import { isObjectEmpty } from '../../../../src/utils';
-
-describe('checks if an object is empty', () => {
-  it('should return true when empty object is passed as parameter', () => {
-    const emptyObject = {};
-    const response = isObjectEmpty(emptyObject);
-    expect(typeof response).toBe('boolean');
-    expect(response).toBeTruthy();
-  });
-  it('should return false when not empty object is passed as parameter', () => {
-    const variable = { a: 1 };
-    const response = isObjectEmpty(variable);
-    expect(typeof response).toBe('boolean');
-    expect(response).toBeFalsy();
-  });
-  it('should return false when no parameter is passed', () => {
-    const response = isObjectEmpty();
-    expect(typeof response).toBe('boolean');
-    expect(response).toBeFalsy();
-  });
-});

package/tests/unit/src/utils/variant-handler.test.js

@@ -1,46 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import '@testing-library/jest-dom/extend-expect';
-import { variantHandler } from '../../../../src/utils';
-
-describe('variantHandler function', () => {
-  it('should return an object with random id and three methods', () => {
-    expect(typeof variantHandler).toEqual('object');
-    expect(typeof variantHandler.add).toEqual('function');
-    expect(typeof variantHandler.get).toEqual('function');
-    expect(typeof variantHandler.getAll).toEqual('function');
-  });
-
-  it('should throw error if we try to add an object with no key', () => {
-    expect(() => variantHandler.add()).toThrow('Variant requires key and component');
-  });
-
-  it('should throw error if we try to add an object with no component', () => {
-    expect(() => variantHandler.add('EmptyVariant')).toThrow('Variant requires key and component');
-  });
-
-  it('should add variant', () => {
-    variantHandler.add('RandomVariant', () => <div />);
-    variantHandler.add('RandomVariant2', () => <div />);
-    const element = variantHandler.get('RandomVariant2');
-    expect(element).toBeDefined();
-  });
-
-  it('should return correct number of entries', () => {
-    const entries = variantHandler.getAll();
-    expect(entries.length).toEqual(2);
-  });
-
-  it('should call console.warn error if we try to add an object that has already been added', () => {
-    const { warn } = console;
-    // eslint-disable-next-line no-console
-    console.warn = jest.fn();
-    variantHandler.add('RandomVariant', () => <div />);
-    // eslint-disable-next-line no-console
-    expect(console.warn).toHaveBeenCalledWith('Variant already exists: RandomVariant');
-    // eslint-disable-next-line no-console
-    console.warn = warn;
-  });
-});