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

package/tests/unit/src/helpers/get-items-to-display-ids.test.js

@@ -1,59 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getItemsToDisplayIds from '../../../../src/helpers/get-items-to-display-ids';
-
-const itemsToDisplayMock = [
-  {
-    displayItems: ['f6e2a480-36cf-11ea-9776-070aacc2c6c7']
-  },
-  {
-    displayItems: ['26bb0670-36d0-11ea-9776-070aacc2c6c7']
-  }
-];
-
-const repeatedIds = [...itemsToDisplayMock, ...itemsToDisplayMock];
-const blankMockItems = [
-  {},
-  {
-    displayItems: null
-  },
-  {
-    displayItems: undefined
-  },
-  {
-    displayItems: []
-  }
-];
-const ids = ['f6e2a480-36cf-11ea-9776-070aacc2c6c7', '26bb0670-36d0-11ea-9776-070aacc2c6c7'];
-
-describe('get ids from itemsToDisplay prop', () => {
-  const withIds = getItemsToDisplayIds(itemsToDisplayMock);
-  const withNoIds = getItemsToDisplayIds({});
-  const withUndefinedItems = getItemsToDisplayIds(undefined);
-  const withBlankMockItems = getItemsToDisplayIds(blankMockItems);
-  const withRepeatedIds = getItemsToDisplayIds(repeatedIds);
-
-  it('should be a function', () => {
-    expect(typeof getItemsToDisplayIds).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(withIds)).toEqual(true);
-    expect(Array.isArray(withNoIds)).toEqual(true);
-    expect(Array.isArray(withUndefinedItems)).toEqual(true);
-    expect(Array.isArray(withBlankMockItems)).toEqual(true);
-  });
-
-  it('should return empty array if no items or items with no displayItems are provided as arguments', () => {
-    expect(withNoIds).toEqual([]);
-    expect(withUndefinedItems).toEqual([]);
-    expect(withBlankMockItems).toEqual([]);
-  });
-
-  it('should return array with unique ids', () => {
-    expect(withIds).toEqual(ids);
-  });
-
-  it('should return array with unique ids', () => {
-    expect(withRepeatedIds).toEqual(ids);
-  });
-});

package/tests/unit/src/helpers/get-modifiers.test.js

@@ -1,46 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getModifiers from '../../../../src/helpers/get-modifiers';
-
-const mocks = [
-  {
-    base: 'test-className',
-    modifier: 'some-modifier'
-  },
-  {
-    base: 'test-className',
-    modifier: ['first-modi', 'second-modi']
-  }
-];
-
-describe('Get modifiers helper', () => {
-  const { base, modifier } = mocks[0];
-  const className = getModifiers(base, modifier);
-
-  it('should be a function', () => {
-    expect(typeof getModifiers).toEqual('function');
-  });
-
-  it('should always return a string', () => {
-    expect(isString(className)).toBeTruthy();
-
-    const withoutModifiers = getModifiers(base);
-    expect(isString(withoutModifiers)).toBeTruthy();
-  });
-
-  it('should always return base with modifier', () => {
-    expect(className).toContain(base);
-    expect(className).toContain(modifier);
-  });
-
-  it('if modifier is array should expect same behaviour and return base class and modifiers', () => {
-    const { base: arrayBase, modifier: modifiersArray } = mocks[1];
-    const multipleModifiersClassName = getModifiers(arrayBase, modifiersArray);
-    expect(multipleModifiersClassName).toEqual(
-      'test-className test-className--first-modi test-className--second-modi'
-    );
-  });
-});
-
-function isString(string) {
-  return typeof string === 'string';
-}

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

@@ -1,23 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getNotEqualQuery from '../../../../src/helpers/get-not-equal-query';
-
-const mockedID = 'someId';
-
-describe('get not equal query', () => {
-  const withoutID = getNotEqualQuery();
-  const withID = getNotEqualQuery(mockedID);
-
-  it('should be a function', () => {
-    expect(typeof getNotEqualQuery).toEqual('function');
-  });
-
-  it('should return always an object', () => {
-    expect(typeof withoutID).toBe('object');
-    expect(typeof withID).toBe('object');
-  });
-
-  it('should return not equal with Id', () => {
-    expect(withID).toHaveProperty('id._ne');
-    expect(withID.id._ne).toBe(mockedID);
-  });
-});

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

@@ -1,31 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getPaginationIndex from '../../../../src/helpers/get-pagination-index';
-
-const mockedArgs = [
-  [{ [`pb[list-1][page]`]: 17, someOtherQuery: 'yes' }, 'list-1'],
-  [[{ [`pb[list-1][page]`]: 3 }, 'list-2']],
-  [[{}, 'list-3']],
-  [{ [`pb[list-4][page]`]: 4 }, 'list-4']
-];
-
-describe('get pagination index from url', () => {
-  const paginationWithQuery = getPaginationIndex(...mockedArgs[0]);
-  const queryPaginationNoMatch = getPaginationIndex(...mockedArgs[1]);
-  const noPaginationQuery = getPaginationIndex(...mockedArgs[2]);
-  const queryPaginationMatch = getPaginationIndex(...mockedArgs[3]);
-
-  it('should return 1 if no path is provided', () => {
-    expect(getPaginationIndex()).toEqual(1);
-  });
-
-  it('should return 1 if no name is provided', () => {
-    expect(getPaginationIndex('some-path')).toEqual(1);
-  });
-
-  it('should return the pagination index if found', () => {
-    expect(queryPaginationNoMatch).toEqual(1);
-    expect(paginationWithQuery).toEqual(17);
-    expect(noPaginationQuery).toEqual(1);
-    expect(queryPaginationMatch).toEqual(4);
-  });
-});

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

@@ -1,66 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-import React from 'react';
-import { Link } from '@blaze-cms/nextjs-components';
-import getParsedPropValues from '../../../../src/helpers/get-parsed-prop-values';
-
-describe('getParsedPropValues helper', () => {
-  const color1 = 'red';
-  const color2 = 'blue';
-  const brand1 = 'red yatch brand';
-  const brand2 = 'blue yatch brand';
-  const url = '/red-yatch-brand';
-  const name = 'test';
-  const src = '/image/test';
-
-  const propertiesToDisplay = ['colours', 'publishedBrands.name', 'name', 'image.src'];
-
-  const props = {
-    colours: [color1, color2],
-    publishedBrands: [
-      {
-        name: brand1,
-        url
-      },
-      {
-        name: brand2
-      }
-    ],
-    someRandomProp: [{}],
-    image: {
-      alt: 'image',
-      src
-    },
-    name
-  };
-
-  const setup = ({ enableLink = false, shouldStrip = false }) =>
-    getParsedPropValues({ propertiesToDisplay, props, enableLink, shouldStrip });
-
-  it('should return array of matched prop values', () => {
-    const expected = [[`${color1}, `, color2], [`${brand1}, `, brand2], name, src];
-
-    expect(setup({})).toEqual(expected);
-  });
-
-  it('should return return array of matched prop values with link if enableLink is true & prop value has url', () => {
-    const expected = [
-      [`${color1}, `, color2],
-      [
-        <Link key={['publishedBrands', brand1, 0].join('-')} href={url}>{`${brand1}, `}</Link>,
-        brand2
-      ],
-      name,
-      src
-    ];
-
-    expect(JSON.stringify(setup({ enableLink: true }))).toEqual(JSON.stringify(expected));
-  });
-
-  it('should return array of matched prop with sanitized values if shouldStrip is true', () => {
-    const expected = [[`${color1}, `, color2], [`${brand1}, `, brand2], name, src];
-
-    expect(setup({ shouldStrip: true })).toEqual(expected);
-  });
-});

package/tests/unit/src/helpers/get-parsed-summary-value.test.js

@@ -1,26 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getParsedSummaryValue from '../../../../src/helpers/get-parsed-summary-value';
-
-describe('get parsed summary value func', () => {
-  it('should be a function', () => {
-    expect(typeof getParsedSummaryValue).toEqual('function');
-  });
-
-  it('should return "Yes" string if argument passed to function is a "true" string', () => {
-    const _true = 'true';
-    const result = getParsedSummaryValue(_true);
-    expect(result).toEqual('Yes');
-  });
-
-  it('should return "No" string if argument passed to function is a "false" string', () => {
-    const _false = 'false';
-    const result = getParsedSummaryValue(_false);
-    expect(result).toEqual('No');
-  });
-
-  it('should return value if argument passed to function is different than "true" or "false"', () => {
-    const different = 'different';
-    const result = getParsedSummaryValue(different);
-    expect(result).toEqual(different);
-  });
-});

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

@@ -1,38 +0,0 @@
-import '@testing-library/jest-dom/extend-expect';
-import getPropValues from '../../../../src/helpers/get-prop-values';
-
-describe('get prop values', () => {
-  const propertiesToDisplay = ['metaTitle', 'metaDescription', 'author.name', 'tags.name'];
-  const props = {
-    metaTitle: 'metatitletest',
-    metaDescription: 'metadescriptiontest',
-    author: {
-      name: 'authortestname'
-    },
-    tags: [{ name: 'tag1' }, { name: 'tag2' }]
-  };
-
-  const result = getPropValues(propertiesToDisplay, props);
-
-  it('should be a function', () => {
-    expect(typeof getPropValues).toEqual('function');
-  });
-
-  it('should always return an array', () => {
-    expect(Array.isArray(result)).toBeTruthy();
-  });
-
-  it('should return the expected result', () => {
-    expect(result).toEqual([
-      'metatitletest',
-      'metadescriptiontest',
-      'authortestname',
-      ['tag1', 'tag2']
-    ]);
-  });
-
-  it('should filter results based on whether properties to display have values', () => {
-    const filteredResults = getPropValues(propertiesToDisplay, {});
-    expect(filteredResults).toEqual([]);
-  });
-});

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