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

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

@@ -1,104 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getQueryFilters from '../../../../src/helpers/get-query-filters';
-
-const searchFilter = {
-  settings: {
-    filters: [
-      {
-        propsToDisplay: ['name'],
-        type: 'checkbox',
-        operator: 'OR'
-      },
-      {
-        propsToDisplay: ['metaTitle'],
-        type: 'checkbox',
-        operator: 'AND'
-      },
-      {
-        propsToDisplay: ['price'],
-        type: 'range'
-      },
-      {
-        propsToDisplay: ['category.name'],
-        type: 'select'
-      }
-    ]
-  }
-};
-
-const query = {
-  'category.name': 'test'
-};
-
-describe('get query filters', () => {
-  const queryFilters = getQueryFilters(searchFilter, query);
-
-  it('should be a function', () => {
-    expect(typeof getQueryFilters).toEqual('function');
-  });
-
-  it('should always return an object', () => {
-    expect(typeof queryFilters).toBe('object');
-  });
-
-  it('should return empty search filter values if no search filter', () => {
-    const queryFiltersEmpty = getQueryFilters({}, query);
-    const { valuesAnd, valuesOr } = queryFiltersEmpty;
-    expect(valuesAnd.length).toBe(0);
-    expect(valuesOr.length).toBe(0);
-  });
-
-  it('should return empty search filter values if no query', () => {
-    const queryFiltersEmpty = getQueryFilters(searchFilter, {});
-    const { valuesAnd, valuesOr } = queryFiltersEmpty;
-    expect(valuesAnd.length).toBe(0);
-    expect(valuesOr.length).toBe(0);
-  });
-
-  it('should return an object with just select filter value', () => {
-    const { valuesAnd, valuesOr } = queryFilters;
-    expect(valuesAnd).toEqual([{ match: { 'category.name.keyword': 'test' } }]);
-    expect(valuesOr).toEqual([]);
-  });
-
-  it('should return an object with select filter value and checkbox with OR operator', () => {
-    const queryFiltersMoreData = getQueryFilters(searchFilter, {
-      'category.name': 'test',
-      name: ['some', 'more names']
-    });
-    const { valuesAnd, valuesOr } = queryFiltersMoreData;
-    expect(valuesAnd).toEqual([{ match: { 'category.name.keyword': 'test' } }]);
-    expect(valuesOr).toEqual([
-      { match: { 'name.keyword': 'some' } },
-      { match: { 'name.keyword': 'more names' } }
-    ]);
-  });
-
-  it('should return an object with select filter value and checkbox with AND operator', () => {
-    const queryFiltersMoreData = getQueryFilters(searchFilter, {
-      'category.name': 'test',
-      metaTitle: 'metas'
-    });
-    const { valuesAnd, valuesOr } = queryFiltersMoreData;
-    expect(valuesAnd).toEqual([
-      { match: { 'category.name.keyword': 'test' } },
-      { match: { 'metaTitle.keyword': 'metas' } }
-    ]);
-    expect(valuesOr).toEqual([]);
-  });
-
-  it('should return an object with select, checkbox and range filter values', () => {
-    const queryFiltersMoreData = getQueryFilters(searchFilter, {
-      'category.name': 'test',
-      metaTitle: 'metas',
-      price: '11-200'
-    });
-    const { valuesAnd, valuesOr } = queryFiltersMoreData;
-    expect(valuesAnd).toEqual([
-      { match: { 'category.name.keyword': 'test' } },
-      { match: { 'metaTitle.keyword': 'metas' } },
-      { range: { price: { gte: 11, lte: 200 } } }
-    ]);
-    expect(valuesOr).toEqual([]);
-  });
-});

package/tests/unit/src/helpers/get-query-props.test.js

@@ -1,45 +0,0 @@
-import { MOCKED_SCHEMA_FOR_FILTERS } from '../../../helpers/mocks';
-import getQueryProps from '../../../../src/helpers/get-query-props';
-
-const inheritedFilters = ['category.name/category'];
-const inheritedFiltersMoreData = ['authors.firstname/author', 'tags.name/tag'];
-const inheritedFiltersMoreDataEntityItself = [
-  'metaDescription/page',
-  'image.name/image',
-  'user.name/user'
-];
-const inheritedFilterEntityItself = ['exhibitorIds/exhibitor', 'price/exhibitor', 'tagIds/tag'];
-
-describe('get query props', () => {
-  const queryProps = getQueryProps(inheritedFilters, MOCKED_SCHEMA_FOR_FILTERS);
-  const queryPropsMoreData = getQueryProps(inheritedFiltersMoreData, MOCKED_SCHEMA_FOR_FILTERS);
-  const queryPropsNoData = getQueryProps([], MOCKED_SCHEMA_FOR_FILTERS);
-  const queryPropsEntityItself = getQueryProps(
-    inheritedFiltersMoreDataEntityItself,
-    MOCKED_SCHEMA_FOR_FILTERS
-  );
-  const queryPropsEntityItselfDifferentData = getQueryProps(
-    inheritedFilterEntityItself,
-    MOCKED_SCHEMA_FOR_FILTERS
-  );
-
-  it('should be a function', () => {
-    expect(typeof getQueryProps).toEqual('function');
-  });
-
-  it('should always return a string', () => {
-    expect(typeof queryProps).toBe('string');
-    expect(typeof queryPropsMoreData).toBe('string');
-    expect(typeof queryPropsNoData).toBe('string');
-    expect(typeof queryPropsEntityItself).toBe('string');
-    expect(typeof queryPropsEntityItselfDifferentData).toBe('string');
-  });
-
-  it('should always return the correct string', () => {
-    expect(queryProps).toEqual(`id category { name } `);
-    expect(queryPropsMoreData).toEqual(`id tags { name } `);
-    expect(queryPropsNoData).toEqual('id');
-    expect(queryPropsEntityItself).toEqual(`id metaDescription `);
-    expect(queryPropsEntityItselfDifferentData).toEqual(`id exhibitorIds `);
-  });
-});

package/tests/unit/src/helpers/get-required-schemas.test.js

@@ -1,56 +0,0 @@
-import getRequiredSchemas from '../../../../src/helpers/get-required-schemas';
-
-describe('Get card entities', () => {
-  const id = 'page';
-  const properties = {
-    anObjectProperty: {
-      type: 'object'
-    }
-  };
-  const dynamicProperties = {
-    aDynamicObjectProperty: {
-      type: 'object'
-    }
-  };
-  const relation = {
-    entityIdentifier: 'article',
-    localField: 'articles'
-  };
-  const relations = [
-    {
-      localField: 'anotherRelation'
-    },
-    relation
-  ];
-  const schema = {
-    id,
-    properties,
-    dynamicProperties,
-    relations
-  };
-
-  it('should be a function', () => {
-    expect(typeof getRequiredSchemas).toEqual('function');
-  });
-
-  it('should return an empty array when data not ready', () => {
-    expect(getRequiredSchemas([])).toEqual([]);
-  });
-
-  it('should just current the id of the schema', () => {
-    expect(getRequiredSchemas([], { id })).toEqual([id]);
-  });
-
-  it('should check only nested properties', () => {
-    expect(getRequiredSchemas(['aProperty'], { id })).toEqual([id]);
-  });
-
-  it('should return schema for matching relations', () => {
-    expect(
-      getRequiredSchemas(
-        ['aProperty', 'anObjectProperty.name', 'aDynamicObjectProperty.name', 'articles.name'],
-        schema
-      )
-    ).toEqual([id, relation.entityIdentifier]);
-  });
-});

package/tests/unit/src/helpers/get-sanitized-prop-values.test.js

@@ -1,26 +0,0 @@
-import getSanitizedPropValues from '../../../../src/helpers/get-sanitized-prop-values';
-
-describe('getSanitizedPropValues helper', () => {
-  const mockedValues = [
-    'PANTHOURS',
-    [],
-    '2019-11-29T10:12:22.000Z',
-    '',
-    ['MYSEA, ', 'CSO Yachts'],
-    ['Franco & Anna Della Role']
-  ];
-
-  it('should always return an array', () => {
-    expect(getSanitizedPropValues([])).toEqual([]);
-  });
-
-  it('should return array of values separated by comma', () => {
-    const expected = [
-      [['PANTHOURS', ', ', '2019-11-29T10:12:22.000Z'], ', ', ['MYSEA, ', 'CSO Yachts']],
-      ', ',
-      ['Franco & Anna Della Role']
-    ];
-
-    expect(getSanitizedPropValues(mockedValues)).toEqual(expected);
-  });
-});

package/tests/unit/src/helpers/get-search-filter-type.test.js

@@ -1,47 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getSearchFilterType from '../../../../src/helpers/get-search-filter-type';
-
-const mockedArgs = {
-  searchFilter: {
-    settings: {
-      filters: [{ type: 'text-search' }, { type: 'select' }, { type: 'select' }]
-    }
-  },
-  type: 'text-search'
-};
-
-describe('get search filter type', () => {
-  const { searchFilter, type } = mockedArgs;
-  const searchFilterReturned = getSearchFilterType(searchFilter, type);
-  const searchFilterEmpty = getSearchFilterType(
-    {
-      settings: {}
-    },
-    type
-  );
-
-  it('should be a function', () => {
-    expect(typeof getSearchFilterType).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(searchFilterReturned)).toEqual(true);
-    expect(Array.isArray(searchFilterEmpty)).toEqual(true);
-  });
-
-  it('should return correct number of elements', () => {
-    const searchFilterSelect = getSearchFilterType(searchFilter, 'select');
-    expect(searchFilterReturned.length).toBe(1);
-    expect(searchFilterEmpty.length).toBe(0);
-    expect(searchFilterSelect.length).toBe(2);
-  });
-
-  it('should return empty array if no settings have been passed', () => {
-    const mockedNoSettings = {
-      searchFilter: {}
-    };
-    const noSettingsSearchFilter = getSearchFilterType(mockedNoSettings, 'select');
-    expect(Array.isArray(noSettingsSearchFilter)).toEqual(true);
-    expect(noSettingsSearchFilter.length).toBe(0);
-  });
-});

package/tests/unit/src/helpers/get-sort-by-field-name.test.js

@@ -1,57 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getSortbyFieldName from '../../../../src/helpers/get-sort-by-field-name';
-
-const CATEGORY_FIELD = 'category.name';
-const PRICE_FIELD = 'price';
-const AUTHOR_IDENTIFIER = 'author';
-const CATEGORY_SORT_FIELD = `${CATEGORY_FIELD}.keyword`;
-const SORT_BY = 'authors.name';
-
-describe('get sortb by field name', () => {
-  const sortByArray = getSortbyFieldName([], [PRICE_FIELD], [], true);
-  const sortByArrayStringProp = getSortbyFieldName([], [CATEGORY_FIELD], [CATEGORY_FIELD], true);
-  const sortByDifferentLocalField = getSortbyFieldName(
-    [{ entityIdentifier: AUTHOR_IDENTIFIER, localField: 'authors' }],
-    [SORT_BY],
-    [`${AUTHOR_IDENTIFIER}.name`],
-    true
-  );
-  const sortByNoArray = getSortbyFieldName([], PRICE_FIELD, [], false);
-  const sortByNoArrayStringProp = getSortbyFieldName([], CATEGORY_FIELD, [CATEGORY_FIELD], false);
-
-  it('should be a function', () => {
-    expect(typeof getSortbyFieldName).toEqual('function');
-  });
-
-  it('should always return a string', () => {
-    expect(typeof sortByArray).toEqual('string');
-    expect(typeof sortByArrayStringProp).toEqual('string');
-    expect(typeof sortByDifferentLocalField).toEqual('string');
-    expect(typeof sortByNoArray).toEqual('string');
-    expect(typeof sortByNoArrayStringProp).toEqual('string');
-  });
-
-  it('should return correct string', () => {
-    expect(sortByArray).toEqual(PRICE_FIELD);
-    expect(sortByArrayStringProp).toEqual(CATEGORY_SORT_FIELD);
-    expect(sortByDifferentLocalField).toEqual(`${SORT_BY}.keyword`);
-    expect(sortByNoArray).toEqual(PRICE_FIELD);
-    expect(sortByNoArrayStringProp).toEqual(CATEGORY_SORT_FIELD);
-  });
-
-  it('should automatically handle when is an array but isSortbyArray is not set', () => {
-    const sort = getSortbyFieldName([], [PRICE_FIELD], []);
-    expect(typeof sort).toEqual('string');
-    expect(sort).toEqual(PRICE_FIELD);
-  });
-
-  it('should handle empty array', () => {
-    const sort = getSortbyFieldName([], [], []);
-    expect(sort).toBeNull();
-  });
-
-  it('should handle empty string', () => {
-    const sort = getSortbyFieldName([], '', []);
-    expect(sort).toBeNull();
-  });
-});

package/tests/unit/src/helpers/get-unpublished-entity-name.test.js

@@ -1,33 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getUnpublishedEntityName from '../../../../src/helpers/get-unpublished-entity-name';
-
-describe('get sanitized entity name', () => {
-  const empty = getUnpublishedEntityName('');
-  const article = getUnpublishedEntityName('article');
-  const publishedPage = getUnpublishedEntityName('published_page');
-  const publishedArticle = getUnpublishedEntityName('published_article');
-  const articleForTest = getUnpublishedEntityName('article_for_test');
-  const publishedArticleForTest = getUnpublishedEntityName('published_article_for_test');
-
-  it('should be a function', () => {
-    expect(typeof getUnpublishedEntityName).toEqual('function');
-  });
-
-  it('should always return a string', () => {
-    expect(typeof empty).toEqual('string');
-    expect(typeof article).toEqual('string');
-    expect(typeof publishedPage).toEqual('string');
-    expect(typeof publishedArticle).toEqual('string');
-    expect(typeof articleForTest).toEqual('string');
-    expect(typeof publishedArticleForTest).toEqual('string');
-  });
-
-  it('should return correct string', () => {
-    expect(empty).toEqual('');
-    expect(article).toEqual('article');
-    expect(publishedPage).toEqual('page');
-    expect(publishedArticle).toEqual('article');
-    expect(articleForTest).toEqual('article_for_test');
-    expect(publishedArticleForTest).toEqual('article_for_test');
-  });
-});

package/tests/unit/src/helpers/get-updated-filter-by.test.js

@@ -1,44 +0,0 @@
-import { MOCKED_INFINITE_SCROLL_PROPS, MOCKED_SCHEMA_FOR_FILTERS } from '../../../helpers/mocks';
-
-import getUpdatedFilterBy from '../../../../src/helpers/get-updated-filter-by';
-
-const mockedProps = [
-  ['category.name/category', 'tags.name/tag', 'metaTitle', 'exhibitorIds/exhibitor'],
-  {
-    category: { name: 'mock category' },
-    tags: [{ name: 'tag-1' }, { name: 'second' }],
-    metaTitle: 'general meta'
-  },
-  MOCKED_SCHEMA_FOR_FILTERS,
-  MOCKED_SCHEMA_FOR_FILTERS,
-  '8f717220-83d9-11ea-967c-97ffdeb65ced',
-  MOCKED_INFINITE_SCROLL_PROPS
-];
-
-const mockedResult = [
-  'category.name/mock category',
-  'tags.name/tag-1',
-  'tags.name/second',
-  'metaTitle/general meta'
-];
-
-describe('get updated filter by helper function', () => {
-  it('should be a function', () => {
-    expect(typeof getUpdatedFilterBy).toEqual('function');
-  });
-
-  it('should return an empty array if no inheritedFilters is passed or is empty array', () => {
-    const noFiltersRelation = getUpdatedFilterBy();
-    const withEmptyFilters = getUpdatedFilterBy([]);
-    expect(Array.isArray(noFiltersRelation)).toBe(true);
-    expect(Array.isArray(withEmptyFilters)).toBe(true);
-    expect(noFiltersRelation.length).toEqual(0);
-    expect(withEmptyFilters.length).toEqual(0);
-  });
-
-  it('should return an array with the correct value/filters', () => {
-    const withCorrectValues = getUpdatedFilterBy(...mockedProps);
-    expect(Array.isArray(withCorrectValues)).toBe(true);
-    expect(withCorrectValues).toEqual(mockedResult);
-  });
-});

package/tests/unit/src/helpers/get-wrapped-value-with-link.test.js

@@ -1,39 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getWrappedValueWithLink from '../../../../src/helpers/get-wrapped-value-with-link';
-
-describe('get wrapped value with link func', () => {
-  const value = 'test-value';
-  const link = './test-link';
-  const emptyLink = '';
-  const keyField = 'name';
-  const arrayOfValues = [
-    { keyField, name: 'test-name', url: link },
-    { keyField, name: 'test-name2', url: emptyLink }
-  ];
-  const keyPrefix = 'prefix';
-
-  it('should be a function', () => {
-    expect(typeof getWrappedValueWithLink).toEqual('function');
-  });
-
-  it('should return a link element with value when value and link are passed', () => {
-    const resultWithLink = getWrappedValueWithLink(value, link);
-    expect(resultWithLink.props.href).toEqual(link);
-    expect(resultWithLink.props.children).toEqual(value);
-  });
-
-  it('should return value when a string is passed and there is no link provided', () => {
-    const resultWithoutLink = getWrappedValueWithLink(value, emptyLink);
-    expect(resultWithoutLink).toEqual(value);
-  });
-
-  it('should return array with correponding value and link', () => {
-    const resultWithArray = getWrappedValueWithLink(arrayOfValues, link, keyPrefix);
-    expect(Array.isArray(resultWithArray)).toBeTruthy();
-    expect(resultWithArray).toHaveLength(2);
-    expect(resultWithArray[0].props.href).toEqual(link);
-    expect(resultWithArray[0].key).toEqual(`${keyPrefix}-0`);
-    expect(resultWithArray[0].props.children).toMatchSnapshot();
-    expect(resultWithArray[1]).toMatchSnapshot();
-  });
-});

package/tests/unit/src/helpers/group-entities.test.js

@@ -1,34 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import groupEntities from '../../../../src/helpers/group-entities';
-
-const mockeEntities = [
-  { id: 'someEntity' },
-  { id: 'someEntity1' },
-  { id: 'someEntity2' },
-  { id: 'someEntity3' },
-  { id: 'someEntity4' },
-  { id: 'someEntity5' },
-  { id: 'someEntity6' }
-];
-
-describe('Group entities helper', () => {
-  const groups = groupEntities(mockeEntities);
-  it('should be a function', () => {
-    expect(typeof groupEntities).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    assertIsArray(groups);
-  });
-
-  it('should return an array of arrays', () => {
-    groups.forEach(assertIsArray);
-
-    const groupsWithSize = groupEntities(mockeEntities, 2);
-    groupsWithSize.forEach(assertIsArray);
-  });
-});
-
-function assertIsArray(array) {
-  expect(Array.isArray(array)).toBeTruthy();
-}

package/tests/unit/src/helpers/inject-banner.test.js

@@ -1,39 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import '@testing-library/jest-dom/extend-expect';
-import injectBanner from '../../../../src/helpers/inject-banner';
-
-const entities = [{ id: 'someEntity' }];
-const banner = {
-  interval: 2,
-  id: 'someBannerId'
-};
-
-describe('Inject banner helper', () => {
-  const entitiesWithBanner = injectBanner(entities, banner);
-
-  it('should be a function', () => {
-    expect(typeof injectBanner).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(entitiesWithBanner)).toBeTruthy();
-  });
-
-  it('should inject banner object at interval position', () => {
-    const [, injectedBanner] = entitiesWithBanner;
-    expect(injectedBanner).toEqual(banner);
-  });
-
-  it('should inject banner component when banner has transform property', () => {
-    const bannerWithTransform = {
-      interval: 2,
-      id: 'someBannerId',
-      transform: true
-    };
-    const [, injectedBanner] = injectBanner(entities, bannerWithTransform);
-    expect(React.isValidElement(injectedBanner)).toBeTruthy();
-  });
-});

package/tests/unit/src/helpers/inject-banners-to-entities.test.js

@@ -1,47 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import injectBannersToEntities from '../../../../src/helpers/inject-banners-to-entities';
-
-const entities = [
-  { id: 'someEntity' },
-  { id: 'someEntity1' },
-  { id: 'someEntity2' },
-  { id: 'someEntity3' },
-  { id: 'someEntity4' }
-];
-
-const data = {
-  banner: {
-    interval: 2,
-    id: 'someBannerId',
-    limit: 0
-  }
-};
-
-describe('Inject banner helper', () => {
-  const entitiesWithBanner = injectBannersToEntities(entities, data);
-
-  it('should be a function', () => {
-    expect(typeof injectBannersToEntities).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(entitiesWithBanner)).toBeTruthy();
-  });
-
-  it('should return empty array if no entities are passed as argument', () => {
-    expect(injectBannersToEntities([], {})).toEqual([]);
-  });
-
-  it('should inject multiple banners if banner has property repeat', () => {
-    const data2 = {
-      banner: {
-        interval: 2,
-        id: 'someBannerId',
-        limit: 0,
-        repeat: true
-      }
-    };
-    const bannersInjected = injectBannersToEntities(entities, data2);
-    expect(bannersInjected.length).toEqual(entities.length);
-  });
-});

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

@@ -1,45 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import injectMultipleBanners from '../../../../src/helpers/inject-multiple-banners';
-
-const entities = [
-  { id: 'someEntity' },
-  { id: 'someEntity1' },
-  { id: 'someEntity2' },
-  { id: 'someEntity3' },
-  { id: 'someEntity4' }
-];
-
-const banner = {
-  interval: 2,
-  id: 'someBannerId',
-  limit: 0
-};
-
-describe('Inject banner helper', () => {
-  const entitiesWithBanner = injectMultipleBanners(entities, banner);
-  it('should be a function', () => {
-    expect(typeof injectMultipleBanners).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(entitiesWithBanner)).toBeTruthy();
-  });
-
-  it('should inject banners object at interval position', () => {
-    const banners = entitiesWithBanner.filter(ad => ad.id === 'someBannerId');
-    const expectedBanners = Math.floor(entities.length / banner.interval);
-
-    expect(banners.length).toEqual(expectedBanners);
-  });
-
-  it('should inject banners for entities when banner contains transform property', () => {
-    const bannerWithTransform = {
-      interval: 2,
-      id: 'someBannerId',
-      limit: 0,
-      transform: true
-    };
-    const entitiesWithTransform = injectMultipleBanners(entities, bannerWithTransform);
-    expect(entitiesWithTransform).toEqual([]);
-  });
-});

package/tests/unit/src/helpers/is-filter-entitys-id.test.js

@@ -1,23 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import isFilterEntitysId from '../../../../src/helpers/is-filter-entitys-id';
-
-const ITEM_ENTITY = 'page';
-
-describe("is filter entity's id", () => {
-  it('should be a function', () => {
-    expect(typeof isFilterEntitysId).toEqual('function');
-  });
-
-  it("should return true if filter field should be current entity's id", () => {
-    expect(isFilterEntitysId('pageId', ITEM_ENTITY)).toBeTruthy();
-    expect(isFilterEntitysId('pagesId', ITEM_ENTITY)).toBeTruthy();
-    expect(isFilterEntitysId('pageIds', ITEM_ENTITY)).toBeTruthy();
-    expect(isFilterEntitysId('pageIds', ITEM_ENTITY)).toBeTruthy();
-  });
-
-  it('should return false if filter field is a different property', () => {
-    expect(isFilterEntitysId('metaTitle', ITEM_ENTITY)).toBeFalsy();
-    expect(isFilterEntitysId('url', ITEM_ENTITY)).toBeFalsy();
-    expect(isFilterEntitysId('slug', ITEM_ENTITY)).toBeFalsy();
-  });
-});

package/tests/unit/src/helpers/is-object.test.js

@@ -1,21 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import isObject from '../../../../src/helpers/is-object';
-
-describe('is object function', () => {
-  const withArray = isObject([]);
-  const withObject = isObject({});
-  const withNull = isObject(null);
-  const withUndefined = isObject(undefined);
-  const withFunc = isObject(() => {});
-  it('should be a function', () => {
-    expect(typeof isObject).toEqual('function');
-  });
-
-  it('should return true only if the value passed is an object', () => {
-    expect(withArray).toBe(false);
-    expect(withNull).toBe(false);
-    expect(withUndefined).toBe(false);
-    expect(withFunc).toBe(false);
-    expect(withObject).toBe(true);
-  });
-});