@blaze-cms/react-page-builder 0.131.0 → 0.132.0-admin-updates.0

package/src/components/SearchFilter/searchFilterReducer.js

@@ -0,0 +1,15 @@
+const searchFilterReducer = (state, action) => {
+  const { newValues, type, shouldSearch = true } = action;
+  switch (type) {
+    case 'update':
+      return { ...state, ...newValues, shouldSearch };
+    case 'resetSearch':
+      return { ...state, shouldSearch: false };
+    case 'reset':
+      return null;
+    default:
+      throw new Error();
+  }
+};
+
+export default searchFilterReducer;

package/src/components/SearchFilterSort/SearchFilterSort.js

@@ -1,15 +1,23 @@
 import React from 'react';
 import Select from '@blaze-react/select';
-import { withRouter } from 'next/router';
+import { useRouter } from 'next/router';
 import { parseUrl } from 'query-string';
 import PropTypes from 'prop-types';
 import { DEFAULT_SORT } from './constants';
 import { handleSortUpdate } from './helpers';
 import { withTitle } from '../../HOC';
 
-const SearchFilterSort = ({ router, filters, elementLabel, selectLabel, id }) => {
+const getSortFromQuery = listComponentName => {
+  const listNameKey = listComponentName ? `pb[${listComponentName}]` : '';
+  const sortKey = `${listNameKey}${listNameKey ? '[sort]' : 'sort'}`;
+  const sortByKey = `${listNameKey}${listNameKey ? '[sortby]' : 'sortby'}`;
+  return [sortKey, sortByKey];
+};
+const SearchFilterSort = ({ filters, elementLabel, selectLabel, id, listComponentName }) => {
+  const router = useRouter();
   const { asPath } = router;
-  const { url, query, query: { sort, sortby } = {} } = parseUrl(asPath);
+  const [sortKey, sortByKey] = getSortFromQuery(listComponentName);
+  const { url, query, query: { [sortKey]: sort, [sortByKey]: sortby } = {} } = parseUrl(asPath);
   const selectedValue = `${sortby}:${sort}` || '';
   const defaultTextValue = selectLabel || DEFAULT_SORT;
   const options = filters.map(({ label: optionLabel, propsToDisplay, sort: sortValue }) => [
@@ -17,7 +25,8 @@ const SearchFilterSort = ({ router, filters, elementLabel, selectLabel, id }) =>
     optionLabel
   ]);
 
-  const setSortValue = ({ value }) => handleSortUpdate(router, value, query, url, selectLabel);
+  const setSortValue = ({ value }) =>
+    handleSortUpdate({ router, value, query, url, selectLabel, listComponentName });
 
   return (
     <div className="sort-by">
@@ -34,18 +43,19 @@ const SearchFilterSort = ({ router, filters, elementLabel, selectLabel, id }) =>
 };
 
 SearchFilterSort.propTypes = {
-  router: PropTypes.object.isRequired,
   filters: PropTypes.array,
   elementLabel: PropTypes.string,
   selectLabel: PropTypes.string,
-  id: PropTypes.string
+  id: PropTypes.string,
+  listComponentName: PropTypes.string
 };
 
 SearchFilterSort.defaultProps = {
   filters: [],
   elementLabel: '',
   selectLabel: '',
-  id: ''
+  id: '',
+  listComponentName: ''
 };
 
-export default withRouter(withTitle(SearchFilterSort));
+export default withTitle(SearchFilterSort);

package/src/components/SearchFilterSort/helpers/handle-sort-update.js

@@ -2,21 +2,30 @@ import { stringify } from 'query-string';
 import { DEFAULT_SORT, SORT, SORTBY, PAGINATION_QUERY } from '../constants';
 import updateSort from './update-sort';
 
-const handleSortUpdate = (router, value, query, url, selectLabel) => {
+const handleSortUpdate = ({ router, value, query, url, selectLabel, listComponentName }) => {
   const queryWithoutSort = {};
   const routerOptions = { shallow: true, scroll: false };
+  const { asPath } = router;
+  const hashBit = asPath.split('#')[1];
+  const parsedHash = hashBit ? `#${hashBit}` : '';
+  const listNameKey = listComponentName ? `pb[${listComponentName}]` : '';
+  const sortString = listNameKey ? `[${SORT}]` : SORT;
+  const sortByString = listNameKey ? `[${SORTBY}]` : SORTBY;
+  const sortKey = `${listNameKey}${sortString}`;
+  const sortByKey = `${listNameKey}${sortByString}`;
   Object.keys(query).forEach(key => {
     if (key.indexOf(PAGINATION_QUERY) !== -1) return;
-    if (key !== SORTBY && key !== SORT) queryWithoutSort[key] = query[key];
+    if (key !== sortByKey && key !== sortKey) queryWithoutSort[key] = query[key];
   });
   if (value === DEFAULT_SORT || value === selectLabel) {
     const stringifiedQuery = stringify(queryWithoutSort);
 
     return stringifiedQuery
-      ? router.push(`/Resolver`, `${url}?${stringifiedQuery}`, routerOptions)
-      : router.push(`/Resolver`, url, routerOptions);
+      ? router.push(`/Resolver`, `${url}?${stringifiedQuery}${parsedHash}`, routerOptions)
+      : router.push(`/Resolver`, `${url}${parsedHash}`, routerOptions);
   }
-  const updatedSortUrl = updateSort(value, queryWithoutSort, url);
+
+  const updatedSortUrl = updateSort(value, queryWithoutSort, url, parsedHash, listComponentName);
   return router.push('/Resolver', updatedSortUrl, routerOptions);
 };
 

package/src/components/SearchFilterSort/helpers/update-sort.js

@@ -1,10 +1,14 @@
 import { stringify } from 'query-string';
+import { buildQueryKey } from '../../../helpers';
+import { SORT, SORTBY } from '../constants';
 
-const updateSort = (value, query, url) => {
+const updateSort = (value, query, url, hashBit = '', listComponentName = '') => {
+  const sortKey = buildQueryKey(SORT, listComponentName);
+  const sortByKey = buildQueryKey(SORTBY, listComponentName);
   const [newSortBy, newSort] = value.split(':');
-  const updatedQuery = { ...query, sortby: newSortBy, sort: newSort };
+  const updatedQuery = { ...query, [sortByKey]: newSortBy, [sortKey]: newSort };
   const parsedQuery = stringify(updatedQuery);
-  return `${url}?${parsedQuery}`;
+  return `${url}?${parsedQuery}${hashBit}`;
 };
 
 export default updateSort;

package/src/helpers/build-inherited-filters.js

@@ -1,6 +1,7 @@
 import flatten from 'lodash.flatten';
 import isFilterEntitysId from './is-filter-entitys-id';
 import getFilterProps from './get-filter-props';
+import { ID } from '../constants';
 
 const getRelationData = (entityData, relationName, currentRelationNames) => {
   if (!entityData) return null;
@@ -49,8 +50,9 @@ const buildInheritedFilters = (
       shouldIgnoreFilter
     } = getFilterProps(filter, currentSchema, filterEntitySchema);
 
-    const relationData = getRelationData(entityData, relationName, relationForeignKeys);
+    if (filterName === ID) return;
 
+    const relationData = getRelationData(entityData, relationName, relationForeignKeys);
     if (
       (currentEntityId === entityName && isFilterEntitysId(filterName, currentEntityId)) ||
       shouldIgnoreFilter

package/src/helpers/build-props-query.js

@@ -44,19 +44,21 @@ const buildPropsQuery = (entitySchema, extraProps = [], cardOptions = null, link
 const buildComplexProps = (
   shouldAddCategoryProps,
   props,
-  { relations = [], dynamicProperties = {} },
+  { relations = [], dynamicProperties = {}, properties = {} },
   linkProps
 ) =>
   Object.keys(props).map(base => {
     const nestedProps = props[base];
     const hasLink = !!linkProps.find(linkProp => linkProp.includes(base));
+    const matchingProperty = !!properties[base];
     const matchingRelation = relations.find(({ localField }) => localField === base);
     const matchingDynamicProp = Object.keys(dynamicProperties).find(
       dynamicKey => dynamicKey === base
     );
 
     if (matchingRelation && !nestedProps.includes('id')) nestedProps.push('id');
-    if (hasLink && (!!matchingRelation || !!matchingDynamicProp)) nestedProps.push('url');
+    if (hasLink && (!!matchingProperty || !!matchingRelation || !!matchingDynamicProp))
+      nestedProps.push('url');
     const jointNestedProps = nestedProps.join(',');
     if (base === 'category' && shouldAddCategoryProps)
       return `${base}{${jointNestedProps}, ${categoryProps}}`;

package/src/helpers/build-query-key.js

@@ -0,0 +1,7 @@
+const buildQueryKey = (key, listName) => {
+  const listNameKey = listName ? `pb[${listName}]` : '';
+  const wrappedSearchKey = listNameKey ? `[${key}]` : key;
+  return `${listNameKey}${wrappedSearchKey}`;
+};
+
+export default buildQueryKey;

package/src/helpers/build-set-filters.js

@@ -31,8 +31,9 @@ const buildSetFilters = ({
   }
 
   const shouldApplyFilterValues = filterBy.length && filterByProperty.length;
-  const listFilterValues = shouldApplyFilterValues ? getFilterValues(filterBy) : {};
+  if (!shouldApplyFilterValues) return { checkboxFilters, listFilterValues: {} };
 
+  const listFilterValues = getFilterValues(filterBy);
   return { checkboxFilters, listFilterValues };
 };
 

package/src/helpers/get-entities-with-banner.js

@@ -4,8 +4,9 @@ export default function getEntitiesWithBanner(entities, options, hasNewBannerSet
   const { hasBanner } = options;
   if (hasNewBannerSettings) {
     return entities.map(currentEntity => {
-      const { parent, transform, limit } = options;
-      return { ...currentEntity, parent, limit, transform };
+      const { parent, transform, limit, banner } = options;
+      const { adunit, baseAdunit } = banner || {};
+      return { ...currentEntity, parent, limit, transform, adunit, baseAdunit };
     });
   }
   if (!hasBanner) return entities;

package/src/helpers/get-query-filters.js

@@ -2,10 +2,9 @@ import getSearchFilterType from './get-search-filter-type';
 import buildSearchValuesCheckboxSelect from './build-search-values-checkbox-select';
 import { RANGE, CHECKBOX, SELECT } from '../constants';
 
-const getQueryFilters = (searchFilter, query) => {
-  if (!searchFilter.settings || !searchFilter.settings.filters) {
+const getQueryFilters = (searchFilter, query, listName) => {
+  if (!searchFilter.settings || !searchFilter.settings.filters)
     return { valuesAnd: [], valuesOr: [] };
-  }
 
   const rangeFilters = getSearchFilterType(searchFilter, RANGE);
   const checkboxFilters = getSearchFilterType(searchFilter, CHECKBOX);
@@ -15,7 +14,8 @@ const getQueryFilters = (searchFilter, query) => {
     query,
     rangeFilters,
     checkboxFilters,
-    selectFilters
+    selectFilters,
+    listName
   );
   return { valuesAnd, valuesOr };
 };

package/src/helpers/get-query-props.js

@@ -2,10 +2,11 @@ import isFilterEntitysId from './is-filter-entitys-id';
 import getFilterProps from './get-filter-props';
 import { ID } from '../constants';
 
-const getQueryProps = (inheritedFilters, currentSchema, filterEntitySchema) => {
+const getQueryProps = (inheritedFilters, currentSchema, filterEntitySchema = {}) => {
   if (!currentSchema || !inheritedFilters.length) return ID;
 
-  const { identifier: currentEntityId } = currentSchema;
+  const { identifier: currentEntityId, properties } = currentSchema;
+  const { identifier: filterEntityId } = filterEntitySchema;
 
   return inheritedFilters.reduce((acc, filter) => {
     const {
@@ -17,12 +18,19 @@ const getQueryProps = (inheritedFilters, currentSchema, filterEntitySchema) => {
       relationForeignKeys,
       shouldIgnoreFilter
     } = getFilterProps(filter, currentSchema, filterEntitySchema);
-
     if (shouldIgnoreFilter) return acc;
     if (relationForeignKeys && relationForeignKeys.length) {
       return `${acc} ${relationForeignKeys.join(' ')}`;
     }
-
+    if (filterName === ID) {
+      const queryValue = Object.keys(properties).find(
+        propKey =>
+          properties[propKey] &&
+          properties[propKey].relation &&
+          properties[propKey].relation.entityIdentifier === filterEntityId
+      );
+      if (queryValue) return `${acc} ${queryValue} `;
+    }
     const queryProp = relationEntityName ? `${relationName} { ${relationProp} }` : filterName;
     const queryPropFinalValue =
       isEntityItself && isFilterEntitysId(filterName, currentEntityId) ? ID : queryProp;

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

@@ -6,13 +6,16 @@ const getWrappedValueWithLink = (value, link, keyPrefix = '') => {
     const arrayResults = value.map((arrValue, index) => {
       const { keyField, url } = arrValue;
       const keyValue = arrValue[keyField];
+
       const isLastItem = index === value.length - 1;
-      const keyFieldValue = isLastItem ? keyValue : keyValue.concat(',');
+      const keyFieldValue = isLastItem ? keyValue : <>{keyValue}, </>;
 
       return url ? (
-        <BlazeLink key={[keyPrefix, index].join('-')} href={url}>{`${keyFieldValue} `}</BlazeLink>
+        <BlazeLink key={[keyPrefix, index].join('-')} href={url}>
+          {<>{keyFieldValue} </>}
+        </BlazeLink>
       ) : (
-        `${keyFieldValue} `
+        <>{keyFieldValue} </>
       );
     });
 

package/src/helpers/index.js

@@ -51,3 +51,5 @@ export { default as getParsedPropValues } from './get-parsed-prop-values';
 export { default as getSanitizedPropValues } from './get-sanitized-prop-values';
 export { default as appendImages } from './append-images';
 export { default as parseTextBlock } from './parse-TextBlock';
+export { default as processDataSummaryValue } from './process-data-summary-value';
+export { default as buildQueryKey } from './build-query-key';

package/src/helpers/parse-props-to-display.js

@@ -4,35 +4,39 @@ import isObject from './is-object';
 import getParsedPropValues from './get-parsed-prop-values';
 import getSanitizedPropValues from './get-sanitized-prop-values';
 import { BOLD_TAG, BLANK_SPACE_UNICODE_STRING } from '../constants';
+import processDataSummaryValue from './process-data-summary-value';
 
 // TODO this helper should be removed if database is wiped clean and all elements change to new props struc
 const parsePropsToDisplay = (props = {}, propsToDisplay = []) => {
   if (!isObject(propsToDisplay[0])) return at(props, propsToDisplay).filter(Boolean);
 
-  return propsToDisplay.map(
-    ({ bold, propertiesToDisplay, prefix, suffix, shouldStrip, enableLink }, currentIndex) => {
-      const Wrapper = bold ? BOLD_TAG : Fragment;
+  return propsToDisplay.map((options, currentIndex) => {
+    const { bold, propertiesToDisplay, prefix, suffix, shouldStrip, enableLink } = options;
+    const Wrapper = bold ? BOLD_TAG : Fragment;
 
-      const parsedPropValues = getParsedPropValues({
-        propertiesToDisplay,
-        props,
-        enableLink,
-        shouldStrip
-      });
+    const parsedPropValues = getParsedPropValues({
+      propertiesToDisplay,
+      props,
+      enableLink,
+      shouldStrip
+    });
 
-      const sanitizedPropValues = getSanitizedPropValues(parsedPropValues);
-      if (!sanitizedPropValues || !sanitizedPropValues.length) return null;
-      const stringEndBlank =
-        currentIndex + 1 === propsToDisplay.length ? '' : BLANK_SPACE_UNICODE_STRING;
+    const sanitizedPropValues = getSanitizedPropValues(parsedPropValues);
+    if (!sanitizedPropValues || !sanitizedPropValues.length) return null;
+    const stringEndBlank =
+      currentIndex + 1 === propsToDisplay.length ? '' : BLANK_SPACE_UNICODE_STRING;
 
-      return (
-        <Wrapper>
-          {prefix} {sanitizedPropValues} {suffix}
-          {stringEndBlank}
-        </Wrapper>
-      );
-    }
-  );
+    const processedValue = Array.isArray(sanitizedPropValues)
+      ? sanitizedPropValues.map(value => processDataSummaryValue(value, options))
+      : processDataSummaryValue(sanitizedPropValues, options);
+
+    return (
+      <Wrapper>
+        {prefix} {processedValue} {suffix}
+        {stringEndBlank}
+      </Wrapper>
+    );
+  });
 };
 
 export default parsePropsToDisplay;

package/src/helpers/process-data-summary-value.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import components from '../components';
+
+const { code: Code } = components;
+
+const renderCode = value => <Code code={value} disableWrapper />;
+
+const processDataSummaryValue = (objPropValue, { isHtml }) => {
+  let pValue = objPropValue;
+  if (isHtml) {
+    pValue = Array.isArray(objPropValue)
+      ? objPropValue.map(({ keyField, [keyField]: value, ...otherProps }) => ({
+          [keyField]: renderCode(value),
+          keyField,
+          ...otherProps
+        }))
+      : renderCode(objPropValue);
+  }
+  return pValue;
+};
+
+export default processDataSummaryValue;

package/tests/helpers/mocks.js

@@ -1139,11 +1139,9 @@ const MOCKED_PROPS_FILTERS_LIST = {
 };
 
 const MOCKED_PROPS_SEARCH_FILTER = {
-  router: {
-    asPath: 'somePath',
-    query: {},
-    push: () => {}
-  },
+  listComponentName: '',
+  filterData: {},
+  asPath: 'somePath',
   parent: {
     itemEntity: 'published_page'
   },

package/tests/unit/src/components/Card/helpers/get-updated-items-to-display.test.js

@@ -0,0 +1,72 @@
+import '@testing-library/jest-dom/extend-expect';
+import getUpdatedItemsToDisplay from '../../../../../../src/components/Card/helpers/get-updated-items-to-display';
+
+const mockedProps = {
+  itemsToDisplay: [
+    {
+      displayItems: ['54321']
+    }
+  ],
+  parentEntityData: {
+    authorIds: ['12345']
+  },
+  parentSchema: {
+    properties: {
+      authorIds: {
+        relation: {
+          entityIdentifier: 'author'
+        }
+      }
+    }
+  },
+  inheritedFilters: ['id/author']
+};
+
+describe('getUpdatedItemsToDisplay helper function', () => {
+  it('should return empty array if no props passed', () => {
+    const emptyArray = getUpdatedItemsToDisplay({});
+    expect(emptyArray).toEqual([]);
+  });
+
+  it('should return old itemsToDisplay itemsToDisplay if no idProp match, no parentSchema or no parentEntityData', () => {
+    const onlyItemsToDisplayPassed = getUpdatedItemsToDisplay({
+      itemsToDisplay: mockedProps.itemsToDisplay
+    });
+    const noIdPropMatch = getUpdatedItemsToDisplay({
+      ...mockedProps,
+      inheritedFilters: ['notid/author']
+    });
+    const noParentSchema = getUpdatedItemsToDisplay({
+      ...mockedProps,
+      parentSchema: null
+    });
+    const noParentEntityData = getUpdatedItemsToDisplay({
+      ...mockedProps,
+      parentEntityData: null
+    });
+    expect(onlyItemsToDisplayPassed).toEqual(mockedProps.itemsToDisplay);
+    expect(noIdPropMatch).toEqual(mockedProps.itemsToDisplay);
+    expect(noParentSchema).toEqual(mockedProps.itemsToDisplay);
+    expect(noParentEntityData).toEqual(mockedProps.itemsToDisplay);
+  });
+
+  it('should return old itemsToDisplay if parentSchema has no propMatch with idProp entity', () => {
+    const sameItemsToDisplay = getUpdatedItemsToDisplay({
+      ...mockedProps,
+      inheritedFilters: ['id/noentitymatch']
+    });
+    expect(sameItemsToDisplay).toEqual(mockedProps.itemsToDisplay);
+  });
+
+  it('should return updated itemsToDisplay otherwise', () => {
+    const sameItemsToDisplay = getUpdatedItemsToDisplay({
+      ...mockedProps
+    });
+    expect(sameItemsToDisplay).toEqual([
+      ...mockedProps.itemsToDisplay,
+      {
+        displayItems: ['12345']
+      }
+    ]);
+  });
+});

package/tests/unit/src/components/Code/Code.test.js

@@ -23,6 +23,11 @@ describe('Code component', () => {
     expect(asFragment()).toMatchSnapshot();
   });
 
+  it('should not render wrapper', () => {
+    const { asFragment } = render(Code, { ...props, disableWrapper: true });
+    expect(asFragment()).toMatchSnapshot();
+  });
+
   it('should return null if there is not embed code', () => {
     const { container } = render(Code, {});
     expect(container.innerHTML).toBe('');

package/tests/unit/src/components/Code/__snapshots__/Code.test.js.snap

@@ -27,3 +27,11 @@ exports[`Code component should not render script tags 1`] = `
   </div>
 </DocumentFragment>
 `;
+
+exports[`Code component should not render wrapper 1`] = `
+<DocumentFragment>
+  <p>
+    Lorem ipsum
+  </p>
+</DocumentFragment>
+`;

package/tests/unit/src/components/DataSummary/helpers/build-loop-props-content.test.js

@@ -1,6 +1,11 @@
 import '@testing-library/jest-dom/extend-expect';
 import buildLoopPropsContent from '../../../../../../src/components/DataSummary/helpers/build-loop-props-content';
 import { mockedLoopProps, mockedPropsToDisplay, mockedData, mockedResults } from './mocks';
+import processDataSummaryValue from '../../../../../../src/helpers/process-data-summary-value';
+
+jest.mock('../../../../../../src/helpers/process-data-summary-value', () =>
+  jest.fn(value => value)
+);
 
 describe('buildLoopPropsContent helper function', () => {
   const noParamsPassed = buildLoopPropsContent();
@@ -41,6 +46,10 @@ describe('buildLoopPropsContent helper function', () => {
     expect(noDataPassed).toEqual([]);
   });
 
+  it('should call processDataSummaryValue', () => {
+    expect(processDataSummaryValue).toHaveBeenCalledWith('pre data name', mockedPropsToDisplay[0]);
+  });
+
   it('should return regular dataSummary content if no loopable values are found', () => {
     expect(withNoLoopValues).toEqual(mockedResults[0]);
     expect(withNoLoopableValues).toEqual(mockedResults[1]);
@@ -81,4 +90,45 @@ describe('buildLoopPropsContent helper function', () => {
     });
     expect.hasAssertions();
   });
+
+  it('should nested items with urls', () => {
+    const data = {
+      nestedLoopProp: [
+        {
+          nestedValue: 'abc',
+          url: 'http://blazecms.app/abc'
+        },
+        {
+          nestedValue: '123',
+          url: 'http://blazecms.app/123'
+        },
+        {
+          nestedValue: 'no url',
+          url: null
+        }
+      ]
+    };
+    const withUrl = buildLoopPropsContent(
+      mockedLoopProps,
+      [
+        {
+          bold: false,
+          enableLink: true,
+          label: '',
+          modifier: '',
+          prefix: '',
+          propertiesToDisplay: ['nestedLoopProp.nestedValue'],
+          shouldStrip: true
+        }
+      ],
+      0,
+      data
+    );
+
+    withUrl.forEach(([, value, url], index) => {
+      expect(value).toEqual(data.nestedLoopProp[index].nestedValue);
+      expect(url).toEqual(data.nestedLoopProp[index].url || '');
+    });
+    expect.hasAssertions();
+  });
 });

package/tests/unit/src/components/DataSummary/helpers/get-link-to-published-content.test.js

@@ -38,4 +38,25 @@ describe('get link to published content', () => {
     const result = getLinkToPublishedContent(publishedKey, props);
     expect(result).toEqual('');
   });
+
+  it('should return url from the currentValue', () => {
+    const currentValue = { url: 'currentValueUrl' };
+    const props = { content: [content] };
+    const result = getLinkToPublishedContent(publishedKey, props, currentValue);
+    expect(result).toEqual(currentValue.url);
+  });
+
+  it('should return url from the currentValue even if falsey', () => {
+    const currentValue = { url: null };
+    const props = { content: [content] };
+    const result = getLinkToPublishedContent(publishedKey, props, currentValue);
+    expect(result).toEqual(currentValue.url);
+  });
+
+  it('should not return url from the currentValue if not set', () => {
+    const currentValue = {};
+    const props = { content: [content] };
+    const result = getLinkToPublishedContent(publishedKey, props, currentValue);
+    expect(result).toEqual(content.url);
+  });
 });

package/tests/unit/src/components/SearchFilter/__snapshots__/SearchFilterContainer.test.js.snap

@@ -1,11 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`SearchFilter container should match snapshot 1`] = `
-<DocumentFragment>
-  <div>
-    Mocked component
-  </div>
-</DocumentFragment>
-`;
+exports[`SearchFilter container should match snapshot 1`] = `<DocumentFragment />`;
 
 exports[`SearchFilter container should return null if no filters are passed 1`] = `<DocumentFragment />`;

package/tests/unit/src/components/SearchFilter/helpers/build-new-query.test.js

@@ -1,20 +1,20 @@
-import buildNewQuery from '../../../../../../src/components/SearchFilter/helpers/build-new-query';
-
+import buildNewUrl from '../../../../../../src/components/SearchFilter/helpers/build-new-url';
+// url, currentUrl, queryParams, hashBit
 const mockedProps = [
   ['', 'current-as-path', 'some=query&params=value'],
   ['urlFromProps', '', 'other=query&with=value'],
-  ['urlFromProps', 'not=used', 'another=query&withthis=value', 'sort=asc&sortby=name']
+  ['urlFromProps', 'not=used', 'another=query&withthis=value'],
+  ['urlFromProps', 'not=used', 'another=query&withthis=value', 'this-is-content']
 ];
 
-describe('buildNewQuery helper function', () => {
-  const simpleExample = buildNewQuery(...mockedProps[0]);
-  const withPropsUrl = buildNewQuery(...mockedProps[1]);
-  const withSort = buildNewQuery(...mockedProps[2]);
+describe('buildNewUrl helper function', () => {
+  const simpleExample = buildNewUrl(...mockedProps[0]);
+  const withPropsUrl = buildNewUrl(...mockedProps[1]);
+  const withHash = buildNewUrl(...mockedProps[3]);
 
   it('should always return a string', () => {
     expect(typeof simpleExample).toBe('string');
     expect(typeof withPropsUrl).toBe('string');
-    expect(typeof withSort).toBe('string');
   });
 
   it('should return new url using asPath and queryParams passed', () => {
@@ -25,7 +25,7 @@ describe('buildNewQuery helper function', () => {
     expect(withPropsUrl).toEqual('urlFromProps?other=query&with=value');
   });
 
-  it('should return new url with sort if passed', () => {
-    expect(withSort).toEqual('urlFromProps?another=query&withthis=value&sort=asc&sortby=name');
+  it('should return new url with hash if passed', () => {
+    expect(withHash).toEqual('urlFromProps?another=query&withthis=value#this-is-content');
   });
 });