@blaze-cms/react-page-builder 0.131.1 → 0.132.0-admin-updates.1

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/PlaceholderIcon/__snapshots__/index.test.js.snap

@@ -0,0 +1,72 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`Placeholder component should render PlaceholderIcon 1`] = `
+<DocumentFragment>
+  <div
+    class="editor-view__placeholder"
+    data-testid="placeholder-icon"
+  >
+    <svg
+      height="25px"
+      version="1.1"
+      viewBox="0 0 16 16"
+      width="25px"
+      xmlns="http://www.w3.org/2000/svg"
+    >
+      <title>
+        card
+      </title>
+      <g
+        fill="none"
+        fill-rule="evenodd"
+        id="Icons"
+        stroke="none"
+        stroke-width="1"
+      >
+        <g
+          id="card"
+          transform="translate(-261.000000, -216.000000)"
+        >
+          <g
+            transform="translate(261.000000, 216.000000)"
+          >
+            <path
+              d="M15,1 L15,9.53124644 L14.998,9.531 L14.9986024,7.67959976 L11.4210663,4.62547112 L7.4590683,8.08893259 C7.08560181,8.77082265 6.07591438,8.77082265 5.51715851,8.27688661 L3.50145721,6.5 L1,8.77 L1,7.323 L2.58011188,5.9054667 C3.10161735,5.44445974 3.91799869,5.41372594 4.47882094,5.81326531 L4.59488493,5.9054667 L6.4402744,7.56106172 L10.4252459,3.98593625 C10.9840017,3.49200022 11.8812631,3.49200022 12.4400189,3.98593625 L14.9986024,6.28137475 L14.998,1 Z M6.14778213,2.60821539 C6.69719001,2.60821539 7.14257312,3.0379169 7.14257312,3.56798059 C7.14257312,4.09804429 6.69719002,4.52774581 6.14778213,4.52774581 C5.88422964,4.52580316 5.6316942,4.42547921 5.44313851,4.24781429 C5.25594548,4.06784498 5.15142164,3.82293899 5.15297371,3.56798059 C5.15297371,3.0379169 5.59837425,2.60821539 6.14778213,2.60821539 Z"
+              fill="#63779C"
+              fill-rule="nonzero"
+              id="Combined-Shape"
+            />
+            <path
+              d="M3,13 C3,12.7238576 3.22385763,12.5 3.5,12.5 L12.5,12.5 C12.7761424,12.5 13,12.7238576 13,13 C13,13.2761424 12.7761424,13.5 12.5,13.5 L3.5,13.5 C3.22385763,13.5 3,13.2761424 3,13 Z"
+              fill="#899BBC"
+              fill-rule="nonzero"
+              id="Shape"
+            />
+            <rect
+              height="15"
+              id="Rectangle"
+              rx="2"
+              stroke="#899BBC"
+              width="15"
+              x="0.5"
+              y="0.5"
+            />
+            <line
+              id="Line-2"
+              stroke="#63779C"
+              stroke-linecap="square"
+              x1="0.5"
+              x2="15.5"
+              y1="10.5"
+              y2="10.5"
+            />
+          </g>
+        </g>
+      </g>
+    </svg>
+    <span>
+      card
+    </span>
+  </div>
+</DocumentFragment>
+`;

package/tests/unit/src/components/PlaceholderIcon/index.test.js

@@ -0,0 +1,20 @@
+/**
+ * @jest-environment jsdom
+ */
+import { render } from '@blaze-cms/tools/test-helpers/test-functions';
+
+import PlaceholderIcon from '../../../../../../blaze-plugin-page-builder-ui/src/components/EditorView/PlaceholderIcon';
+import { CardIcon } from '../../../../../../blaze-plugin-page-builder-ui/src/components/EditorView/Icons';
+
+const mockedProps = {
+  type: 'card',
+  icon: CardIcon
+};
+
+describe('Placeholder component', () => {
+  it('should render PlaceholderIcon', () => {
+    const { asFragment, getByTestId } = render(PlaceholderIcon, mockedProps);
+    expect(getByTestId('placeholder-icon')).toBeDefined();
+    expect(asFragment()).toMatchSnapshot();
+  });
+});

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

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

@@ -1,4 +1,4 @@
-import buildQuery from '../../../../../../src/components/SearchFilter/helpers/build-query';
+import buildUrlQuery from '../../../../../../src/components/SearchFilter/helpers/build-url-query';
 import { SEARCH_TERM } from '../../../../../../src/components/SearchFilter/constants';
 
 const mockedProps = [
@@ -10,10 +10,15 @@ const mockedProps = [
   ]
 ];
 
-describe('buildQuery helper function', () => {
-  const simpleExample = buildQuery(...mockedProps[0]);
-  const withTextSearch = buildQuery(...mockedProps[1]);
-  const withSearchAndRange = buildQuery(...mockedProps[2]);
+describe('buildUrlQuery helper function', () => {
+  const simpleExample = buildUrlQuery(...mockedProps[0]);
+  const withTextSearch = buildUrlQuery(...mockedProps[1]);
+  const withSearchAndRange = buildUrlQuery(...mockedProps[2]);
+  const withListName = buildUrlQuery(...mockedProps[2], 'listName');
+  const withListNameAndOtherQueryBits = buildUrlQuery(...mockedProps[2], 'listName', {
+    sort: 'asc',
+    anotherQuery: '123'
+  });
 
   it('should always return a string', () => {
     expect(typeof simpleExample).toBe('string');
@@ -24,10 +29,22 @@ describe('buildQuery helper function', () => {
   });
 
   it('should return new query string with search term if available', () => {
-    expect(withTextSearch).toEqual('search_term=new%20search%20value');
+    expect(withTextSearch).toEqual('search_term=new search value');
   });
 
   it('should return new query string with search text and all other available query values', () => {
-    expect(withSearchAndRange).toEqual('search_term=new%20search%20value&rangeFilter=2-10');
+    expect(withSearchAndRange).toEqual('search_term=new search value&rangeFilter=2-10');
+  });
+
+  it('should return new query string listName if passed', () => {
+    expect(withListName).toEqual(
+      'pb[listName][search_term]=new search value&pb[listName][rangeFilter]=2-10'
+    );
+  });
+
+  it('should return new query string with unaltered bits from other query', () => {
+    expect(withListNameAndOtherQueryBits).toEqual(
+      'pb[listName][search_term]=new search value&pb[listName][rangeFilter]=2-10&sort=asc&anotherQuery=123'
+    );
   });
 });

package/tests/unit/src/components/SearchFilter/helpers/get-initial-filter-values.test.js

@@ -1,4 +1,4 @@
-import getInitialFilterValues from '../../../../../../src/components/SearchFilter/helpers/get-initial-filter-values';
+import getFilterValues from '../../../../../../src/components/SearchFilter/helpers/get-filter-values';
 import { SEARCH_TERM } from '../../../../../../src/components/SearchFilter/constants';
 
 const filters = [
@@ -16,25 +16,24 @@ const mockedProps = [
   [{ rangeFilter: { min: 5, max: 10 }, checkboxFilter: {}, emptySelect: {} }, filters, query]
 ];
 
-describe('getInitialFilterValues helper function', () => {
-  const withNoValue = getInitialFilterValues(...mockedProps[0]);
-  const withValues = getInitialFilterValues(...mockedProps[1]);
+describe('getFilterValues helper function', () => {
+  const withNoValue = getFilterValues(...mockedProps[0]);
+  const withValues = getFilterValues(...mockedProps[1]);
 
   it('should return init filter values based on query and filterData', () => {
-    expect(withNoValue).toEqual({ dataNotSet: false, search_term: '' });
+    expect(withNoValue).toEqual({ search_term: '', dataNotSet: false });
     expect(withValues).toEqual({
-      dataNotSet: false,
       search_term: query[SEARCH_TERM],
       rangeFilter: { max: 10, maxValue: 8, min: 5, minValue: 7, step: 1 },
       checkboxFilter: ['check1', 'check2'],
-      emptySelect: null
+      emptySelect: null,
+      dataNotSet: false
     });
   });
 
   it('should return init filter values without filterData', () => {
-    const withNoData = getInitialFilterValues(null, filters, query);
+    const withNoData = getFilterValues(null, filters, query);
     expect(withNoData).toEqual({
-      dataNotSet: true,
       search_term: query[SEARCH_TERM],
       rangeFilter: {
         max: 8,
@@ -44,7 +43,8 @@ describe('getInitialFilterValues helper function', () => {
         step: 1
       },
       checkboxFilter: query.checkboxFilter,
-      emptySelect: null
+      emptySelect: null,
+      dataNotSet: true
     });
   });
 });

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

@@ -5,8 +5,11 @@ import { render } from '@blaze-cms/tools/test-helpers/test-functions';
 import '@testing-library/jest-dom/extend-expect';
 import SearchFilterSort from '../../../../../src/components/SearchFilterSort/SearchFilterSort';
 
+jest.mock('next/router', () => ({
+  useRouter: jest.fn(() => ({ asPath: 'test-url' }))
+}));
+
 const props = {
-  router: { asPath: 'some-path' },
   filters: [{ label: 'label1', propsToDisplay: ['name'], sort: 'ascending' }],
   label: 'someLabel',
   id: '123456'

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

@@ -1,43 +1,50 @@
 import handleSortUpdate from '../../../../../../src/components/SearchFilterSort/helpers/handle-sort-update';
 
 const routerPushResultMock = () => ({ then: jest.fn() });
+// router, value, query, url, selectLabel, listComponentName
 const mockedProps = [
-  [{ push: jest.fn(routerPushResultMock) }, 'defaultOption', {}, 'url', 'defaultOption'],
-  [
-    { push: jest.fn(routerPushResultMock) },
-    'defaultOption',
-    { sort: 'asc', sortby: 'name', type: 'big' },
-    'baseurl',
-    'defaultOption'
-  ],
-  [
-    { push: jest.fn(routerPushResultMock) },
-    'name:desc',
-    { someOther: 'ott' },
-    'url',
-    'defaultOption'
-  ]
+  {
+    router: { asPath: 'asPath', push: jest.fn(routerPushResultMock) },
+    value: 'defaultOption',
+    query: {},
+    url: 'url',
+    selectLabel: 'defaultOption'
+  },
+  {
+    router: { asPath: 'asPath', push: jest.fn(routerPushResultMock) },
+    value: 'defaultOption',
+    query: { sort: 'asc', sortby: 'name', type: 'big' },
+    url: 'baseurl',
+    selectLabel: 'defaultOption'
+  },
+  {
+    router: { asPath: 'asPath', push: jest.fn(routerPushResultMock) },
+    value: 'name:desc',
+    query: { someOther: 'ott' },
+    url: 'url',
+    selectLabel: 'defaultOption'
+  }
 ];
 
 describe('handleSortUpdate helper function', () => {
-  mockedProps.forEach(props => handleSortUpdate(...props));
+  mockedProps.forEach(props => handleSortUpdate({ ...props }));
 
   it('should navigate to url with no sort if default value is selected', () => {
-    expect(mockedProps[0][0].push).toHaveBeenLastCalledWith('/Resolver', 'url', {
+    expect(mockedProps[0].router.push).toHaveBeenLastCalledWith('/Resolver', 'url', {
       shallow: true,
       scroll: false
     });
   });
 
   it('should navigate to url with no sort with previous querys if default value is selected', () => {
-    expect(mockedProps[1][0].push).toHaveBeenLastCalledWith('/Resolver', 'baseurl?type=big', {
+    expect(mockedProps[1].router.push).toHaveBeenLastCalledWith('/Resolver', 'baseurl?type=big', {
       shallow: true,
       scroll: false
     });
   });
 
   it('should navigate to url with new sort if selected', () => {
-    expect(mockedProps[2][0].push).toHaveBeenLastCalledWith(
+    expect(mockedProps[2].router.push).toHaveBeenLastCalledWith(
       '/Resolver',
       'url?someOther=ott&sort=desc&sortby=name',
       { shallow: true, scroll: false }

package/tests/unit/src/components/SearchFilterSort/helpers/update-sort.test.js

@@ -1,10 +1,15 @@
 import updateSort from '../../../../../../src/components/SearchFilterSort/helpers/update-sort';
 
-const mockedProps = [['name:asc', {}, 'aurl'], ['name:asc', { other: '12', query2: 'an' }, 'aurl']];
+const mockedProps = [
+  ['name:asc', {}, 'aurl'],
+  ['name:asc', { other: '12', query2: 'an' }, 'aurl'],
+  ['name:desc', { query1: 'aquery' }, 'theUrl', '#hashBit']
+];
 
 describe('updateSort helper function', () => {
   const basicSort = updateSort(...mockedProps[0]);
   const sortWithOtherQuerys = updateSort(...mockedProps[1]);
+  const sortWithhash = updateSort(...mockedProps[2]);
 
   it('should return a parsed url based on the parameters passed', () => {
     expect(basicSort).toEqual('aurl?sort=asc&sortby=name');
@@ -13,4 +18,8 @@ describe('updateSort helper function', () => {
   it('should return a parsed url with extra query params if passed', () => {
     expect(sortWithOtherQuerys).toEqual('aurl?other=12&query2=an&sort=asc&sortby=name');
   });
+
+  it('should return a parsed url with extra query params and hash if passed', () => {
+    expect(sortWithhash).toEqual('theUrl?query1=aquery&sort=desc&sortby=name#hashBit');
+  });
 });