piral-core 0.15.0-alpha.4345 → 0.15.0-alpha.4399

package/src/components/PiralRoutes.test.tsx

@@ -1,12 +1,12 @@
 import * as React from 'react';
 import * as hooks from '../hooks';
 import { MemoryRouter } from 'react-router';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { PiralRoutes } from './PiralRoutes';
 import { DefaultRouteSwitch } from '../defaults/DefaultRouteSwitch_v5';
 
 const mountWithRouter = (node, url = '/') =>
-  mount(
+  render(
     <MemoryRouter initialEntries={[url]} initialIndex={0}>
       {node}
     </MemoryRouter>,
@@ -37,75 +37,75 @@ jest.mock('../hooks');
   },
 ];
 
-const StubHome: React.FC = (props) => <div />;
+const StubHome: React.FC = (props) => <div role="home" />;
 StubHome.displayName = 'StubHome';
 
-const StubCustomPage: React.FC = (props) => <div />;
+const StubCustomPage: React.FC = (props) => <div role="custom-page" />;
 StubCustomPage.displayName = 'StubCustomPage';
 
-const StubNotFound: React.FC = (props) => <div />;
+const StubNotFound: React.FC = (props) => <div role="not-found" />;
 StubNotFound.displayName = 'StubNotFound';
 
-const StubComponent: React.FC<{ data: any }> = (props) => <div />;
+const StubComponent: React.FC<{ data: any }> = (props) => <div role="component" />;
 StubComponent.displayName = 'StubComponent';
 
-const StubFooPage: React.FC<{ data: any }> = (props) => <div />;
+const StubFooPage: React.FC<{ data: any }> = (props) => <div role="foo-page" />;
 StubFooPage.displayName = 'StubFooPage';
 
-const StubFooBarPage: React.FC<{ data: any }> = (props) => <div />;
+const StubFooBarPage: React.FC<{ data: any }> = (props) => <div role="foo-bar-page" />;
 StubFooBarPage.displayName = 'StubFooBarPage';
 
-const StubBarPage: React.FC<{ data: any }> = (props) => <div />;
+const StubBarPage: React.FC<{ data: any }> = (props) => <div role="bar-page" />;
 StubBarPage.displayName = 'StubBarPage';
 
 describe('Routes Module', () => {
   it('always goes to the given home on "/"', () => {
     const node = mountWithRouter(<PiralRoutes NotFound={StubNotFound} RouteSwitch={DefaultRouteSwitch} />, '/');
-    expect(node.find(StubHome).length).toBe(1);
-    expect(node.find(StubNotFound).length).toBe(0);
-    expect(node.find(StubCustomPage).length).toBe(0);
-    expect(node.find(StubFooBarPage).length).toBe(0);
+    expect(node.queryAllByRole('home').length).toBe(1);
+    expect(node.queryAllByRole('not-found').length).toBe(0);
+    expect(node.queryAllByRole('custom-page').length).toBe(0);
+    expect(node.queryAllByRole('foo-bar-page').length).toBe(0);
   });
 
   it('goes to the not found on an invalid path', () => {
     const node = mountWithRouter(<PiralRoutes NotFound={StubNotFound} RouteSwitch={DefaultRouteSwitch} />, '/qxz');
-    expect(node.find(StubHome).length).toBe(0);
-    expect(node.find(StubNotFound).length).toBe(1);
-    expect(node.find(StubCustomPage).length).toBe(0);
-    expect(node.find(StubFooBarPage).length).toBe(0);
+    expect(node.queryAllByRole('home').length).toBe(0);
+    expect(node.queryAllByRole('not-found').length).toBe(1);
+    expect(node.queryAllByRole('custom-page').length).toBe(0);
+    expect(node.queryAllByRole('foo-bar-page').length).toBe(0);
   });
 
   it('goes to the custom page on "/custom"', () => {
     const node = mountWithRouter(<PiralRoutes NotFound={StubNotFound} RouteSwitch={DefaultRouteSwitch} />, '/custom');
-    expect(node.find(StubHome).length).toBe(0);
-    expect(node.find(StubNotFound).length).toBe(0);
-    expect(node.find(StubCustomPage).length).toBe(1);
-    expect(node.find(StubFooBarPage).length).toBe(0);
+    expect(node.queryAllByRole('home').length).toBe(0);
+    expect(node.queryAllByRole('not-found').length).toBe(0);
+    expect(node.queryAllByRole('custom-page').length).toBe(1);
+    expect(node.queryAllByRole('foo-bar-page').length).toBe(0);
   });
 
   it('goes exactly to the page on "/foo/bar"', () => {
     const node = mountWithRouter(<PiralRoutes NotFound={StubNotFound} RouteSwitch={DefaultRouteSwitch} />, '/foo/bar');
-    expect(node.find(StubHome).length).toBe(0);
-    expect(node.find(StubNotFound).length).toBe(0);
-    expect(node.find(StubCustomPage).length).toBe(0);
-    expect(node.find(StubFooBarPage).length).toBe(1);
+    expect(node.queryAllByRole('home').length).toBe(0);
+    expect(node.queryAllByRole('not-found').length).toBe(0);
+    expect(node.queryAllByRole('custom-page').length).toBe(0);
+    expect(node.queryAllByRole('foo-bar-page').length).toBe(1);
   });
 
   it('goes exactly to the page on "/foo"', () => {
     const node = mountWithRouter(<PiralRoutes NotFound={StubNotFound} RouteSwitch={DefaultRouteSwitch} />, '/foo');
-    expect(node.find(StubHome).length).toBe(0);
-    expect(node.find(StubNotFound).length).toBe(0);
-    expect(node.find(StubCustomPage).length).toBe(0);
-    expect(node.find(StubFooBarPage).length).toBe(0);
-    expect(node.find(StubFooPage).length).toBe(1);
+    expect(node.queryAllByRole('home').length).toBe(0);
+    expect(node.queryAllByRole('not-found').length).toBe(0);
+    expect(node.queryAllByRole('custom-page').length).toBe(0);
+    expect(node.queryAllByRole('foo-bar-page').length).toBe(0);
+    expect(node.queryAllByRole('foo-page').length).toBe(1);
   });
 
   it('goes exactly to the page on "/bar"', () => {
     const node = mountWithRouter(<PiralRoutes NotFound={StubNotFound} RouteSwitch={DefaultRouteSwitch} />, '/bar');
-    expect(node.find(StubHome).length).toBe(0);
-    expect(node.find(StubNotFound).length).toBe(0);
-    expect(node.find(StubCustomPage).length).toBe(0);
-    expect(node.find(StubFooBarPage).length).toBe(0);
-    expect(node.find(StubBarPage).length).toBe(1);
+    expect(node.queryAllByRole('home').length).toBe(0);
+    expect(node.queryAllByRole('not-found').length).toBe(0);
+    expect(node.queryAllByRole('custom-page').length).toBe(0);
+    expect(node.queryAllByRole('foo-bar-page').length).toBe(0);
+    expect(node.queryAllByRole('bar-page').length).toBe(1);
   });
 });

package/src/components/PiralView-server.test.tsx

@@ -5,7 +5,7 @@
 import * as React from 'react';
 import * as hooks from '../hooks';
 import * as routes from './PiralRoutes';
-import { render } from 'enzyme';
+import { renderToString } from 'react-dom/server';
 import { PiralView } from './PiralView';
 
 const StubDashboard: React.FC = () => <div />;
@@ -54,8 +54,8 @@ describe('Portal Module', () => {
   it('In this test window should be undefined', () => {
     state.app.loading = false;
     state.app.error = undefined;
-    const node = render(<PiralView children={undefined} />);
+    const html = renderToString(<PiralView children={undefined} />);
     expect(typeof window).toBe('undefined');
-    expect(node.length).toBe(1);
+    expect(html).not.toBe('');
   });
 });

package/src/components/PiralView.test.tsx

@@ -1,22 +1,22 @@
 import * as React from 'react';
 import * as hooks from '../hooks';
 import * as routes from './PiralRoutes';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { PiralView } from './PiralView';
 
-const StubDashboard: React.FC = () => <div />;
+const StubDashboard: React.FC<any> = () => <div role="dashboard" />;
 StubDashboard.displayName = 'StubDashboard';
 
-const StubErrorInfo: React.FC = () => <div />;
+const StubErrorInfo: React.FC<any> = ({ type }) => <div role="error">{type}</div>;
 StubErrorInfo.displayName = 'StubErrorInfo';
 
-const StubLoader: React.FC = () => <div />;
+const StubLoader: React.FC<any> = () => <div role="loader" />;
 StubLoader.displayName = 'StubLoader';
 
-const StubRouter: React.FC = ({ children }) => <div>{children}</div>;
+const StubRouter: React.FC<any> = ({ children }) => <div role="router">{children}</div>;
 StubRouter.displayName = 'StubRouter';
 
-const StubLayout: React.FC = ({ children }) => <div>{children}</div>;
+const StubLayout: React.FC<any> = ({ children }) => <div role="layout">{children}</div>;
 StubLayout.displayName = 'StubLayout';
 
 jest.mock('../hooks');
@@ -24,7 +24,7 @@ jest.mock('./PiralRoutes');
 
 const state = {
   app: {
-    error: undefined,
+    error: undefined as any,
     loading: true,
   },
   components: {
@@ -50,39 +50,39 @@ describe('Portal Module', () => {
   it('renders the dashboard / content in layout if loaded without error', () => {
     state.app.loading = false;
     state.app.error = undefined;
-    const node = mount(<PiralView />);
-    expect(node.find(StubLoader).length).toBe(0);
-    expect(node.find(StubErrorInfo).length).toBe(0);
-    expect(node.find(StubDashboard).length).toBe(1);
+    const node = render(<PiralView />);
+    expect(node.queryAllByRole("loader").length).toBe(0);
+    expect(node.queryAllByRole("error").length).toBe(0);
+    expect(node.queryAllByRole("dashboard").length).toBe(1);
   });
 
   it('just renders the loader if not loaded yet', () => {
     state.app.loading = true;
     state.app.error = undefined;
-    const node = mount(<PiralView />);
-    expect(node.find(StubLoader).length).toBe(1);
-    expect(node.find(StubErrorInfo).length).toBe(0);
-    expect(node.find(StubDashboard).length).toBe(0);
+    const node = render(<PiralView />);
+    expect(node.queryAllByRole("loader").length).toBe(1);
+    expect(node.queryAllByRole("error").length).toBe(0);
+    expect(node.queryAllByRole("dashboard").length).toBe(0);
   });
 
   it('renders the error outside layout if errored when loading', () => {
     state.app.loading = false;
     state.app.error = new Error('Test');
-    const node = mount(<PiralView />);
-    expect(node.find(StubLoader).length).toBe(0);
-    expect(node.find(StubErrorInfo).length).toBe(1);
-    expect(node.find(StubErrorInfo).prop('type')).toBe('loading');
-    expect(node.find(StubDashboard).length).toBe(0);
+    const node = render(<PiralView />);
+    expect(node.queryAllByRole("loader").length).toBe(0);
+    expect(node.queryAllByRole("error").length).toBe(1);
+    expect(node.getByRole("error").textContent).toBe('loading');
+    expect(node.queryAllByRole("dashboard").length).toBe(0);
   });
 
   it('renders the not found error in layout', () => {
     state.app.loading = false;
     state.app.error = undefined;
     (routes as any).PiralRoutes = ({ NotFound }) => <NotFound />;
-    const node = mount(<PiralView />);
-    expect(node.find(StubLoader).length).toBe(0);
-    expect(node.find(StubErrorInfo).length).toBe(1);
-    expect(node.find(StubErrorInfo).prop('type')).toBe('not_found');
-    expect(node.find(StubDashboard).length).toBe(0);
+    const node = render(<PiralView />);
+    expect(node.queryAllByRole("loader").length).toBe(0);
+    expect(node.queryAllByRole("error").length).toBe(1);
+    expect(node.getByRole("error").textContent).toBe('not_found');
+    expect(node.queryAllByRole("dashboard").length).toBe(0);
   });
 });

package/src/components/ResponsiveLayout.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import * as hooks from '../hooks';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { ResponsiveLayout } from './ResponsiveLayout';
 import { defaultBreakpoints } from '../utils';
 
@@ -11,34 +11,34 @@ describe('Responsive Module', () => {
     (hooks as any).useMedia = () => 'desktop';
     const Layout: React.FC = jest.fn().mockImplementation(({ children }) => <div>{children}</div>);
     Layout.displayName = 'Layout';
-    const StubComponent: React.FC = () => <div />;
+    const StubComponent: React.FC = () => <div role="stub" />;
     StubComponent.displayName = 'StubComponent';
-    const node = mount(
+    const node = render(
       <ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints}>
-        <StubComponent />)
+        <StubComponent />
       </ResponsiveLayout>,
     );
-    expect(node.find(StubComponent).length).toBe(1);
+    expect(node.queryAllByRole('stub').length).toBe(1);
   });
 
   it('does not call changeTo when nothing changed', () => {
     (hooks as any).useMedia = () => 'desktop';
     const Layout = jest.fn().mockImplementation(({ children }) => <div>{children}</div>);
-    mount(<ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints} />);
+    render(<ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints} />);
     expect(Layout).toHaveBeenCalledWith({ currentLayout: 'desktop' }, {});
   });
 
   it('does calls changeTo when someething changed (desktop -> tablet)', () => {
     (hooks as any).useMedia = () => 'tablet';
     const Layout = jest.fn().mockImplementation(({ children }) => <div>{children}</div>);
-    mount(<ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints} />);
+    render(<ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints} />);
     expect(Layout).toHaveBeenCalledWith({ currentLayout: 'tablet' }, {});
   });
 
   it('does calls changeTo when someething changed (desktop -> mobile)', () => {
     (hooks as any).useMedia = () => 'mobile';
     const Layout = jest.fn().mockImplementation(({ children }) => <div>{children}</div>);
-    mount(<ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints} />);
+    render(<ResponsiveLayout Layout={Layout} breakpoints={defaultBreakpoints} />);
     expect(Layout).toHaveBeenCalledWith({ currentLayout: 'mobile' }, {});
   });
 });

package/src/components/SwitchErrorInfo.test.tsx

@@ -1,38 +1,36 @@
-import *  as React from 'react';
-import { mount } from 'enzyme';
+import * as React from 'react';
+import { render } from '@testing-library/react';
 import { SwitchErrorInfo } from './SwitchErrorInfo';
 
 jest.mock('../hooks/globalState', () => ({
-    useGlobalState(select: any) {
-        return select(state);
-    },
+  useGlobalState(select: any) {
+    return select(state);
+  },
 }));
 
-const StubComponent1: React.FC = (props) => <div children={props.children} />;
-const Unknown: React.FC = (props) => <div children={props.children} />;
+const StubComponent1: React.FC<any> = (props) => <div role="stub" children={props.children} />;
+const Unknown: React.FC<any> = (props) => <div role="unknown" children={props.children} />;
 
 const state = {
-    registry: {
-        extensions: {},
-    },
-    errorComponents: {
-        stubComponent1: StubComponent1,
-        unknown: Unknown,
-    },
+  registry: {
+    extensions: {},
+  },
+  errorComponents: {
+    stubComponent1: StubComponent1,
+    unknown: Unknown,
+  },
 };
 
 (React as any).useMemo = (cb) => cb();
 
 describe('SwitchErrorInfo Module', () => {
-    it('is able to render StubComponent1 component', () => {
-        const node = mount(<SwitchErrorInfo type="stubComponent1" />);
-        expect(node.at(0).exists()).toBe(true);
-        expect(node.find(StubComponent1).length).toBe(1);
-    });
+  it('is able to render StubComponent1 component', () => {
+    const node = render(<SwitchErrorInfo type="stubComponent1" />);
+    expect(node.queryAllByRole('stub').length).toBe(1);
+  });
 
-    it('is able to default render Unknow component if the compenent name not available in state data', () => {
-        const node = mount(<SwitchErrorInfo type="notRealComponent" />);
-        expect(node.at(0).exists()).toBe(true);
-        expect(node.find(Unknown).length).toBe(1);
-    });
-})
+  it('is able to default render Unknow component if the compenent name not available in state data', () => {
+    const node = render(<SwitchErrorInfo type="notRealComponent" />);
+    expect(node.queryAllByRole('unknown').length).toBe(1);
+  });
+});

package/src/defaults/DefaultErrorInfo.test.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { DefaultErrorInfo } from './DefaultErrorInfo';
 
 jest.mock('../hooks/globalState', () => ({
@@ -9,47 +9,44 @@ jest.mock('../hooks/globalState', () => ({
 }));
 
 const state = {
+  components: {},
   registry: {
     extensions: {},
   },
   errorComponents: {},
 };
 
-const StubErrorInfo: React.FC = (props) => <div />;
+const StubErrorInfo: React.FC = (props) => <div role="stub" />;
 StubErrorInfo.displayName = 'StubErrorInfo';
 
 describe('Default Error Info Component', () => {
   it('renders the switch-case in the loading error case', () => {
-    const node = mount(<DefaultErrorInfo type="loading" error="foo" />);
-    expect(node.find(StubErrorInfo).length).toBe(0);
-    expect(node.findWhere((n) => n.key() === 'default_error').length).toBe(1);
+    const node = render(<DefaultErrorInfo type="loading" error="foo" />);
+    expect(node.queryAllByRole("stub").length).toBe(0);
+    expect(node.queryAllByText("Error: loading").length).toBe(1);
   });
 
   it('renders the switch-case in the not_found error case', () => {
-    const node = mount(
+    const node = render(
       <DefaultErrorInfo
         type="not_found"
-        history={undefined}
-        match={undefined}
         location={{ pathname: 'foo', hash: '', key: '', search: '', state: '' }}
       />,
     );
-    expect(node.find(StubErrorInfo).length).toBe(0);
-    expect(node.findWhere((n) => n.key() === 'default_error').length).toBe(1);
+    expect(node.queryAllByRole("stub").length).toBe(0);
+    expect(node.queryAllByText("Error: not_found").length).toBe(1);
   });
 
   it('renders the switch-case in the page error case', () => {
-    const node = mount(
+    const node = render(
       <DefaultErrorInfo
         error={undefined}
         type="page"
-        history={undefined}
-        match={undefined}
         location={{ pathname: 'bar', hash: '', key: '', search: '', state: '' }}
       />,
     );
-    expect(node.find(StubErrorInfo).length).toBe(0);
-    expect(node.findWhere((n) => n.key() === 'default_error').length).toBe(1);
+    expect(node.queryAllByRole("stub").length).toBe(0);
+    expect(node.queryAllByText("Error: page").length).toBe(1);
   });
 
   it('renders the react fragment in the default case', () => {
@@ -58,8 +55,8 @@ describe('Default Error Info Component', () => {
         component: StubErrorInfo,
       },
     ];
-    const node = mount(<DefaultErrorInfo type="extension" error="foo" />);
-    expect(node.find(StubErrorInfo).length).toBe(1);
-    expect(node.findWhere((n) => n.key() === 'default_error').length).toBe(0);
+    const node = render(<DefaultErrorInfo type="extension" error="foo" />);
+    expect(node.queryAllByRole("stub").length).toBe(1);
+    expect(node.queryAllByText("Error: extension").length).toBe(0);
   });
 });

package/src/defaults/DefaultErrorInfo.tsx

@@ -8,6 +8,6 @@ import { ErrorInfoProps } from '../types';
  * the "error" name.
  */
 export const DefaultErrorInfo: React.FC<ErrorInfoProps> = (props) => (
-  <ExtensionSlot name="error" params={props} empty={() => <SwitchErrorInfo key="default_error" {...props} />} />
+  <ExtensionSlot name="error" params={props} empty={() => <SwitchErrorInfo {...props} />} />
 );
 DefaultErrorInfo.displayName = 'DefaultErrorInfo';

package/src/defaults/DefaultLayout.test.tsx

@@ -1,23 +1,23 @@
 import * as React from 'react';
+import { render } from '@testing-library/react';
 import { DefaultLayout } from './DefaultLayout';
-import { mount } from 'enzyme';
 
 describe('Default Layout Component', () => {
   it('renders correctly for desktop', () => {
     const children = <div></div>;
-    const node = mount(<DefaultLayout currentLayout="desktop" children={children} />);
-    expect(node.find('div').length).toBe(1);
+    const node = render(<DefaultLayout currentLayout="desktop" children={children} />);
+    expect(node.container.querySelectorAll('div').length).toBe(1);
   });
 
   it('renders correctly for mobile', () => {
     const children = <div></div>;
-    const node = mount(<DefaultLayout currentLayout="mobile" children={children} />);
-    expect(node.find('div').length).toBe(1);
+    const node = render(<DefaultLayout currentLayout="mobile" children={children} />);
+    expect(node.container.querySelectorAll('div').length).toBe(1);
   });
 
   it('renders correctly for tablet', () => {
     const children = <div></div>;
-    const node = mount(<DefaultLayout currentLayout="tablet" children={children} />);
-    expect(node.find('div').length).toBe(1);
+    const node = render(<DefaultLayout currentLayout="tablet" children={children} />);
+    expect(node.container.querySelectorAll('div').length).toBe(1);
   });
 });

package/src/defaults/DefaultLoadingIndicator.test.tsx

@@ -1,10 +1,10 @@
 import * as React from 'react';
+import { render } from '@testing-library/react';
 import { DefaultLoadingIndicator } from './DefaultLoadingIndicator';
-import { mount } from 'enzyme';
 
 describe('Default Loading Indicator Component', () => {
   it('renders correctly', () => {
-    const node = mount(<DefaultLoadingIndicator />);
-    expect(node.find('div').length).toBe(1);
+    const node = render(<DefaultLoadingIndicator />);
+    expect(node.container.querySelectorAll('div').length).toBe(1);
   });
 });

package/src/hooks/setter.test.ts

@@ -1,6 +1,5 @@
 import * as React from 'react';
-import { act } from 'react-dom/test-utils';
-import { createRoot } from 'react-dom/client';
+import { render, act } from '@testing-library/react';
 import { useSetter } from './setter';
 
 describe('UseSetter Hook Module', () => {
@@ -12,9 +11,8 @@ describe('UseSetter Hook Module', () => {
       return null;
     };
 
-    const root = createRoot(document.body.appendChild(document.createElement('div')));
-    root.render(React.createElement(MyComponent));
-    await act(() => new Promise(resolve => setTimeout(resolve, 5)));
+    render(React.createElement(MyComponent));
+    await act(() => new Promise((resolve) => setTimeout(resolve, 5)));
     expect(cb).toHaveBeenCalled();
   });
 });

package/src/setters/SetComponent.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetComponent } from './SetComponent';
 import { StateContext } from '../state';
 
@@ -34,7 +34,7 @@ function createMockContainer() {
 describe('Piral-Core SetComponent component', () => {
   it('SetComponent sets the layout component in the store', () => {
     const { context } = createMockContainer();
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetComponent name="LoadingIndicator" component={FakeLoading} />
       </StateContext.Provider>,

package/src/setters/SetError.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetError } from './SetError';
 import { StateContext } from '../state';
 
@@ -34,7 +34,7 @@ function createMockContainer() {
 describe('Piral-Core SetError component', () => {
   it('SetError sets the error component in the store', () => {
     const { context } = createMockContainer();
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetError type="loading" component={FakeError} />
       </StateContext.Provider>,

package/src/setters/SetErrors.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetErrors } from './SetErrors';
 import { StateContext } from '../state/stateContext';
 
@@ -34,7 +34,7 @@ function createMockContainer() {
 describe('Piral SetErrors component', () => {
   it('SetErrors sets the error components', () => {
     const { context } = createMockContainer();
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetErrors
           errors={

package/src/setters/SetLayout.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetLayout } from './SetLayout';
 import { StateContext } from '../state/stateContext';
 
@@ -34,7 +34,7 @@ function createMockContainer() {
 describe('Piral SetLayout component', () => {
   it('SetLayout sets the layout components', () => {
     const { context } = createMockContainer();
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetLayout
           layout={

package/src/setters/SetProvider.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetProvider } from './SetProvider';
 import { StateContext } from '../state';
 
@@ -32,7 +32,7 @@ describe('Piral-Core SetProvider component', () => {
   it('SetProvider uses the includeProvider action', () => {
     const { context } = createMockContainer();
     const provider = <FakeProvider />;
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetProvider provider={provider} />
       </StateContext.Provider>,

package/src/setters/SetRedirect.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetRedirect } from './SetRedirect';
 import { StateContext } from '../state';
 
@@ -31,7 +31,7 @@ function createMockContainer() {
 describe('Piral-Core SetRedirect component', () => {
   it('SetRedirect sets the redirect route in the store', () => {
     const { context } = createMockContainer();
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetRedirect from="/foo" to="/bar" />
       </StateContext.Provider>,

package/src/setters/SetRoute.test.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import create from 'zustand';
-import { mount } from 'enzyme';
+import { render } from '@testing-library/react';
 import { SetRoute } from './SetRoute';
 import { StateContext } from '../state';
 
@@ -34,7 +34,7 @@ function createMockContainer() {
 describe('Piral-Core SetRoute component', () => {
   it('SetRoute sets the link route in the store', () => {
     const { context } = createMockContainer();
-    const node = mount(
+    render(
       <StateContext.Provider value={context}>
         <SetRoute path="/foo" component={FakeRoute} />
       </StateContext.Provider>,