diff --git a/__test_utils__/DynamicInputForm.tsx b/__test_utils__/DynamicInputForm.tsx
index efe165c2..f607ab57 100644
--- a/__test_utils__/DynamicInputForm.tsx
+++ b/__test_utils__/DynamicInputForm.tsx
@@ -18,7 +18,7 @@ class DynamicInputForm extends React.Component<DynamicInputFormProps, { input: a
   private addInput = () => {
     const { inputName } = this.props;
     this.setState({
-      input: <TestInput name={inputName} value="" />,
+      input: <TestInput name={inputName} value="" testId="test-input" />,
     });
   };
 
@@ -28,11 +28,11 @@ class DynamicInputForm extends React.Component<DynamicInputFormProps, { input: a
 
     return (
       <>
-        <Formsy onSubmit={onSubmit}>
+        <Formsy onSubmit={onSubmit} data-testid="form">
           {input}
           {children}
         </Formsy>
-        <button type="button" onClick={this.addInput}>
+        <button type="button" onClick={this.addInput} data-testid="add-input-btn">
           Add input
         </button>
       </>
diff --git a/__test_utils__/TestInput.tsx b/__test_utils__/TestInput.tsx
index b1dbe4d5..93b24937 100644
--- a/__test_utils__/TestInput.tsx
+++ b/__test_utils__/TestInput.tsx
@@ -4,7 +4,8 @@ import React from 'react';
 import { withFormsy } from '../src';
 import { PassDownProps } from '../src/withFormsy';
 
-export type FormsyInputProps = Omit<React.HTMLProps<HTMLInputElement>, 'required' | 'value'> & PassDownProps<string>;
+export type FormsyInputProps = Omit<React.HTMLProps<HTMLInputElement>, 'required' | 'value'> &
+  PassDownProps<string> & { testId?: string };
 
 class TestInput extends React.Component<FormsyInputProps> {
   updateValue = (event) => {
@@ -12,7 +13,21 @@ class TestInput extends React.Component<FormsyInputProps> {
   };
 
   render() {
-    return <input type={this.props.type || 'text'} value={this.props.value || ''} onChange={this.updateValue} />;
+    return (
+      <input
+        type={this.props.type || 'text'}
+        value={this.props.value || ''}
+        onChange={this.updateValue}
+        data-is-valid={this.props.isValid}
+        data-is-pristine={this.props.isPristine}
+        data-error-message={this.props.errorMessage}
+        data-error-messages={this.props.errorMessages.join(';')}
+        data-is-form-disabled={this.props.isFormDisabled}
+        data-is-form-submitted={this.props.isFormSubmitted}
+        data-value={JSON.stringify(this.props.value)}
+        data-testid={this.props.testId}
+      />
+    );
   }
 }
 
diff --git a/__test_utils__/TestInputHoc.tsx b/__test_utils__/TestInputHoc.tsx
index bf0e9d4f..a67d37d0 100644
--- a/__test_utils__/TestInputHoc.tsx
+++ b/__test_utils__/TestInputHoc.tsx
@@ -1,10 +1,14 @@
 import React from 'react';
 import { withFormsy } from '../src';
+import { PassDownProps } from '../src/withFormsy';
 
-class TestComponent extends React.Component {
+type TestComponentProps = { testId?: string; name?: string } & PassDownProps<string>;
+
+class TestComponent extends React.Component<TestComponentProps> {
   render() {
-    return <input />;
+    const { testId, name } = this.props;
+    return <input data-testid={testId} name={name} />;
   }
 }
 
-export default withFormsy(TestComponent as any);
+export default withFormsy<TestComponentProps, any>(TestComponent);
diff --git a/__test_utils__/expectIsValid.tsx b/__test_utils__/expectIsValid.tsx
deleted file mode 100644
index b6b51b74..00000000
--- a/__test_utils__/expectIsValid.tsx
+++ /dev/null
@@ -1,31 +0,0 @@
-import React from 'react';
-import { mount } from 'enzyme';
-
-import Formsy from '../src';
-import { InputFactory } from './TestInput';
-import { getWrapperInstance } from './getInput';
-
-const TestInput = InputFactory({
-  render() {
-    const { value } = this.props;
-    return <input value={value || ''} readOnly />;
-  },
-});
-
-function ValidationForm(props: { validations: string; value?: any }) {
-  const { validations, value } = props;
-
-  return (
-    <Formsy>
-      <TestInput name="foo" validations={validations} value={value} />
-    </Formsy>
-  );
-}
-
-export function expectIsValid(testForm: React.ComponentElement<any, any>) {
-  const form = mount(testForm);
-  const inputComponent = form.find('Formsy(TestInput)');
-  return expect(getWrapperInstance(inputComponent).isValid());
-}
-
-export default ValidationForm;
diff --git a/__test_utils__/getInput.ts b/__test_utils__/getInput.ts
deleted file mode 100644
index 8d54378c..00000000
--- a/__test_utils__/getInput.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { WrapperInstanceMethods } from '../src/withFormsy';
-import Formsy from '../src';
-
-export function getWrapperInstance<V>(inputComponent) {
-  return inputComponent.instance() as WrapperInstanceMethods<V>;
-}
-
-export function getInputInstance(inputComponent) {
-  return inputComponent.instance() as HTMLInputElement;
-}
-
-export function getFormInstance(formComponent) {
-  return formComponent.instance() as Formsy;
-}
diff --git a/__test_utils__/getValidState.tsx b/__test_utils__/getValidState.tsx
new file mode 100644
index 00000000..f4712da0
--- /dev/null
+++ b/__test_utils__/getValidState.tsx
@@ -0,0 +1,31 @@
+import { render } from '@testing-library/react';
+import React from 'react';
+
+import Formsy from '../src';
+import { InputFactory } from './TestInput';
+
+const TestInput = InputFactory({
+  render() {
+    const { value, isValid, testId } = this.props;
+    return <input value={value || ''} readOnly data-is-valid={isValid} data-testid={testId} />;
+  },
+});
+
+function ValidationForm(props: { validations: string; value?: any }) {
+  const { validations, value } = props;
+
+  return (
+    <Formsy>
+      <TestInput name="foo" validations={validations} value={value} testId="test-input" />
+    </Formsy>
+  );
+}
+
+export async function getValidState(testForm: React.ComponentElement<any, any>) {
+  const form = render(testForm);
+  const inputComponent = await form.findByTestId('test-input');
+
+  return inputComponent.dataset.isValid === 'true';
+}
+
+export default ValidationForm;
diff --git a/__test_utils__/immediate.ts b/__test_utils__/immediate.ts
deleted file mode 100644
index ed311ae3..00000000
--- a/__test_utils__/immediate.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export default function (fn) {
-  setTimeout(fn, 0);
-}
diff --git a/__tests__/Element.spec.tsx b/__tests__/Element.spec.tsx
index 8b43a511..d8defb50 100644
--- a/__tests__/Element.spec.tsx
+++ b/__tests__/Element.spec.tsx
@@ -1,50 +1,59 @@
-import { mount } from 'enzyme';
-import React from 'react';
-import { getFormInstance, getInputInstance, getWrapperInstance } from '../__test_utils__/getInput';
-import immediate from '../__test_utils__/immediate';
+import { fireEvent, render } from '@testing-library/react';
+import React, { useState } from 'react';
 import TestInput, { FormsyInputProps, InputFactory } from '../__test_utils__/TestInput';
 
 import Formsy, { withFormsy } from '../src';
 
 describe('Element', () => {
   it('should pass down correct value prop after using setValue()', () => {
-    const form = mount(
+    const screen = render(
       <Formsy>
-        <TestInput name="foo" value="foo" />
+        <TestInput name="foo" value="foo" testId="test-input" />
       </Formsy>,
     );
 
-    const input = form.find('input');
-    expect(getInputInstance(input).value).toEqual('foo');
-    input.simulate('change', { target: { value: 'foobar' } });
-    expect(getInputInstance(input).value).toEqual('foobar');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+    expect(input.value).toEqual('foo');
+
+    fireEvent.change(input, { target: { value: 'foobar' } });
+    expect(input.value).toEqual('foobar');
   });
 
   it('withFormsy: should only set the value and not validate when calling setValue(val, false)', () => {
     const Input = withFormsy(
       class NoValidateInput extends React.Component<FormsyInputProps> {
         updateValue = (event) => {
-          this.props.setValue(event.target.value, false);
+          this.props.setValue(event.target.value, false); // disables validation
         };
 
         render() {
-          return <input type="text" value={this.props.value || ''} onChange={this.updateValue} />;
+          return (
+            <input
+              type="text"
+              value={this.props.value || ''}
+              onChange={this.updateValue}
+              data-isvalid={this.props.isValid}
+              data-testid="test-input"
+            />
+          );
         }
       },
     );
-    const form = mount(
+
+    const screen = render(
       <Formsy>
-        <Input name="foo" value="foo" />
+        <Input name="foo" value="foo" required={true} />
       </Formsy>,
     );
-    const inputComponent = form.find('Formsy(NoValidateInput)');
-    const setStateSpy = jest.spyOn(getWrapperInstance(inputComponent) as any, 'setState');
-    const inputElement = form.find('input');
-
-    expect(setStateSpy).not.toHaveBeenCalled();
-    inputElement.simulate('change', { target: { value: 'foobar' } });
-    expect(setStateSpy).toHaveBeenCalledTimes(1);
-    expect(setStateSpy).toHaveBeenCalledWith({ value: 'foobar' });
+
+    const inputElement = screen.getByTestId('test-input') as HTMLInputElement;
+
+    expect(inputElement.dataset.isvalid).toEqual('true');
+
+    fireEvent.change(inputElement, { target: { value: '' } });
+
+    expect(inputElement.value).toEqual(''); // new value set
+    expect(inputElement.dataset.isvalid).toEqual('true'); // validation not changed;
   });
 
   it('should set back to pristine value when running reset', () => {
@@ -54,26 +63,27 @@ describe('Element', () => {
         reset = this.props.resetValue;
       },
     });
-    const form = mount(
+    const screen = render(
       <Formsy>
-        <Input name="foo" value="foo" />
+        <Input name="foo" value="foo" testId="test-input" />
       </Formsy>,
     );
 
-    const input = form.find('input');
-    input.simulate('change', { target: { value: 'foobar' } });
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+    fireEvent.change(input, { target: { value: 'foobar' } });
     reset();
-    expect(getInputInstance(input).value).toEqual('foo');
+    expect(input.value).toEqual('foo');
   });
 
   it('should return error message passed when calling getErrorMessage()', () => {
-    let errorMessage = null;
+    let errorMessage;
     const Input = InputFactory({
       componentDidUpdate() {
         errorMessage = this.props.errorMessage;
       },
     });
-    mount(
+
+    render(
       <Formsy>
         <Input name="foo" value="foo" validations="isEmail" validationError="Has to be email" />
       </Formsy>,
@@ -82,33 +92,14 @@ describe('Element', () => {
     expect(errorMessage).toEqual('Has to be email');
   });
 
-  it('should return true or false when calling isValid() depending on valid state', () => {
-    let isValid = null;
-    const Input = InputFactory({
-      componentDidUpdate() {
-        isValid = this.props.isValid;
-      },
-    });
-    const form = mount(
-      <Formsy action="/users">
-        <Input name="foo" value="foo" validations="isEmail" />
-      </Formsy>,
-    );
-
-    expect(isValid).toEqual(false);
-    const input = form.find('input');
-    input.simulate('change', { target: { value: 'foo@foo.com' } });
-    expect(isValid).toEqual(true);
-  });
-
   it('should return true or false when calling isRequired() depending on passed required attribute', () => {
-    const isRequireds = [];
+    const isRequires = [];
     const Input = InputFactory({
       componentDidMount() {
-        isRequireds.push(this.props.isRequired);
+        isRequires.push(this.props.isRequired);
       },
     });
-    mount(
+    render(
       <Formsy action="/users">
         <Input name="foo" value="" />
         <Input name="foo" value="" required />
@@ -116,19 +107,19 @@ describe('Element', () => {
       </Formsy>,
     );
 
-    expect(isRequireds[0]).toEqual(false);
-    expect(isRequireds[1]).toEqual(true);
-    expect(isRequireds[2]).toEqual(true);
+    expect(isRequires[0]).toEqual(false);
+    expect(isRequires[1]).toEqual(true);
+    expect(isRequires[2]).toEqual(true);
   });
 
   it('should return true or false when calling showRequired() depending on input being empty and required is passed, or not', () => {
-    const showRequireds = [];
+    const showRequires = [];
     const Input = InputFactory({
       componentDidMount() {
-        showRequireds.push(this.props.showRequired);
+        showRequires.push(this.props.showRequired);
       },
     });
-    mount(
+    render(
       <Formsy action="/users">
         <Input name="A" value="foo" />
         <Input name="B" value="" required />
@@ -136,26 +127,30 @@ describe('Element', () => {
       </Formsy>,
     );
 
-    expect(showRequireds[0]).toEqual(false);
-    expect(showRequireds[1]).toEqual(true);
-    expect(showRequireds[2]).toEqual(false);
+    expect(showRequires[0]).toEqual(false);
+    expect(showRequires[1]).toEqual(true);
+    expect(showRequires[2]).toEqual(false);
   });
 
   it('should return true or false when calling isPristine() depending on input has been "touched" or not', () => {
     const Input = InputFactory({});
-    const form = mount(
+    const screen = render(
       <Formsy action="/users">
-        <Input name="A" value="foo" />
+        <Input name="A" value="foo" testId="test-input" />
       </Formsy>,
     );
 
-    expect(getFormInstance(form).inputs[0].isPristine()).toEqual(true);
-    const input = form.find('input');
-    input.simulate('change', { target: { value: 'foo' } });
-    expect(getFormInstance(form).inputs[0].isPristine()).toEqual(false);
+    const input = screen.getByTestId('test-input');
+    expect(input.dataset.isPristine).toEqual('true');
+
+    fireEvent.change(input, { target: { value: 'foobar' } });
+
+    expect(input.dataset.isPristine).toEqual('false');
   });
 
   it('should allow an undefined value to be updated to a value', () => {
+    const newValue = 'foo';
+
     class TestForm extends React.Component<{}, { value?: string }> {
       constructor(props) {
         super(props);
@@ -166,42 +161,49 @@ describe('Element', () => {
 
       changeValue = () => {
         this.setState({
-          value: 'foo',
+          value: newValue,
         });
       };
 
       render() {
         return (
           <Formsy action="/users">
-            <TestInput name="A" value={this.state.value} />
+            <TestInput name="A" value={this.state.value} testId="test-input" />
+            <button onClick={this.changeValue} data-testid="btn">
+              change value
+            </button>
           </Formsy>
         );
       }
     }
 
-    const form = mount<TestForm>(<TestForm />);
+    const screen = render(<TestForm />);
+    const btn = screen.getByTestId('btn');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
 
-    form.instance().changeValue();
-    const input = form.find('input');
-    immediate(() => {
-      expect(getInputInstance(input).value).toEqual('foo');
-    });
+    expect(input.value).toEqual('');
+
+    fireEvent.click(btn);
+
+    expect(input.value).toEqual(newValue);
   });
 
   it('should be able to test a values validity', () => {
     function TestForm() {
       return (
         <Formsy>
-          <TestInput name="A" validations="isEmail" />
+          <TestInput name="A" validations="isEmail" testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const input = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(input).isValidValue('foo@bar.com')).toEqual(true);
-    expect(getWrapperInstance(input).isValidValue('foo@bar')).toEqual(false);
+    fireEvent.change(input, { target: { value: 'foo@bar.com' } });
+    expect(input.dataset.isValid).toEqual('true');
+    fireEvent.change(input, { target: { value: 'foo@bar' } });
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should be able to use an object as validations property', () => {
@@ -213,16 +215,19 @@ describe('Element', () => {
             validations={{
               isEmail: true,
             }}
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const input = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(input).isValidValue('foo@bar.com')).toEqual(true);
-    expect(getWrapperInstance(input).isValidValue('foo@bar')).toEqual(false);
+    fireEvent.change(input, { target: { value: 'foo@bar.com' } });
+    expect(input.dataset.isValid).toEqual('true');
+    fireEvent.change(input, { target: { value: 'foo@bar' } });
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should be able to pass complex values to a validation rule', () => {
@@ -234,19 +239,19 @@ describe('Element', () => {
             validations={{
               matchRegexp: /foo/,
             }}
-            value="foo"
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).isValid()).toEqual(true);
-    const input = form.find('input');
-    input.simulate('change', { target: { value: 'bar' } });
-    expect(getWrapperInstance(inputComponent).isValid()).toEqual(false);
+    fireEvent.change(input, { target: { value: 'foo' } });
+    expect(input.dataset.isValid).toEqual('true');
+    fireEvent.change(input, { target: { value: 'bar' } });
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should be able to run a function to validate', () => {
@@ -267,6 +272,7 @@ describe('Element', () => {
               custom: customValidationA,
             }}
             value="foo"
+            testId="text-input-1"
           />
           <TestInput
             name="B"
@@ -274,20 +280,24 @@ describe('Element', () => {
               custom: customValidationB,
             }}
             value="foo"
+            testId="text-input-2"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+
+    const input1 = screen.getByTestId('text-input-1');
+    const input2 = screen.getByTestId('text-input-2');
+
+    expect(input1.dataset.isValid).toEqual('true');
+    expect(input2.dataset.isValid).toEqual('true');
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent.at(0)).isValid()).toEqual(true);
-    expect(getWrapperInstance(inputComponent.at(1)).isValid()).toEqual(true);
-    const input = form.find('input');
-    input.at(0).simulate('change', { target: { value: 'bar' } });
-    expect(getWrapperInstance(inputComponent.at(0)).isValid()).toEqual(false);
-    expect(getWrapperInstance(inputComponent.at(1)).isValid()).toEqual(false);
+    fireEvent.change(input1, { target: { value: 'bar' } });
+
+    expect(input1.dataset.isValid).toEqual('false');
+    expect(input2.dataset.isValid).toEqual('false');
   });
 
   it('should not override error messages with error messages passed by form if passed error messages is an empty object', () => {
@@ -302,15 +312,16 @@ describe('Element', () => {
             validationError="bar2"
             validationErrors={{ isEmail: 'bar3' }}
             value="foo"
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).getErrorMessage()).toEqual('bar3');
+    expect(input.dataset.errorMessage).toEqual('bar3');
   });
 
   it('should handle multiple validation error messages passed from validators', () => {
@@ -324,7 +335,7 @@ describe('Element', () => {
 
     function TestForm() {
       return (
-        <Formsy>
+        <Formsy data-testid="form">
           <TestInput
             name="A"
             validations={{
@@ -332,19 +343,20 @@ describe('Element', () => {
               customValidationB,
             }}
             value="foo"
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const inputComponent = form.find('Formsy(TestInput)');
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const formEl = form.find('form');
-    formEl.simulate('submit');
+    const form = screen.getByTestId('form');
+    fireEvent.submit(form);
 
-    expect(getWrapperInstance(inputComponent).getErrorMessage()).toEqual('error message one');
-    expect(getWrapperInstance(inputComponent).getErrorMessages()).toEqual(['error message one', 'error message two']);
+    expect(input.dataset.errorMessage).toEqual('error message one');
+    expect(input.dataset.errorMessages.split(';')).toEqual(['error message one', 'error message two']);
   });
 
   it('should override all error messages with error messages passed by form', () => {
@@ -359,15 +371,16 @@ describe('Element', () => {
             validationError="bar2"
             validationErrors={{ isEmail: 'bar3' }}
             value="foo"
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).getErrorMessage()).toEqual('bar');
+    const input = screen.getByTestId('test-input');
+    expect(input.dataset.errorMessage).toEqual('bar');
   });
 
   it('should override validation rules with required rules', () => {
@@ -385,15 +398,16 @@ describe('Element', () => {
             required={{
               isLength: 1,
             }}
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).getErrorMessage()).toEqual('bar3');
+    expect(input.dataset.errorMessage).toEqual('bar3');
   });
 
   it('should fall back to default error message when non exist in validationErrors map', () => {
@@ -408,46 +422,47 @@ describe('Element', () => {
             validationError="bar1"
             validationErrors={{ foo: 'bar2' }}
             value="foo"
+            testId="test-input"
           />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).getErrorMessage()).toEqual('bar1');
+    expect(input.dataset.errorMessage).toEqual('bar1');
   });
 
   it('should not be valid if it is required and required rule is true', () => {
     function TestForm() {
       return (
         <Formsy>
-          <TestInput name="A" required />
+          <TestInput name="A" required testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).isValid()).toEqual(false);
+    const input = screen.getByTestId('test-input');
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should return the validationError if the field is invalid and required rule is true', () => {
     function TestForm() {
       return (
         <Formsy>
-          <TestInput name="A" validationError="Field is required" required />
+          <TestInput name="A" validationError="Field is required" required testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
 
-    const inputComponent = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputComponent).isValid()).toEqual(false);
-    expect(getWrapperInstance(inputComponent).getErrorMessage()).toEqual('Field is required');
+    const input = screen.getByTestId('test-input');
+    expect(input.dataset.isValid).toEqual('false');
+    expect(input.dataset.errorMessage).toEqual('Field is required');
   });
 
   it('should handle objects and arrays as values', () => {
@@ -460,26 +475,33 @@ describe('Element', () => {
         };
       }
 
+      changeData = () => {
+        this.setState({
+          foo: { foo: 'foo' },
+          bar: ['bar'],
+        });
+      };
+
       render() {
         return (
           <Formsy>
-            <TestInput name="foo" value={this.state.foo} />
-            <TestInput name="bar" value={this.state.bar} />
+            <TestInput name="foo" value={this.state.foo} testId="test-input1" />
+            <TestInput name="bar" value={this.state.bar} testId="test-input2" />
+            <button type="button" data-testid="btn" onClick={this.changeData} />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input1 = screen.getByTestId('test-input1') as HTMLInputElement;
+    const input2 = screen.getByTestId('test-input2') as HTMLInputElement;
+    const btn = screen.getByTestId('btn');
 
-    form.setState({
-      foo: { foo: 'foo' },
-      bar: ['bar'],
-    });
+    fireEvent.click(btn);
 
-    const inputs = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(inputs.at(0)).getValue()).toEqual({ foo: 'foo' });
-    expect(getWrapperInstance(inputs.at(1)).getValue()).toEqual(['bar']);
+    expect(JSON.parse(input1.dataset.value)).toEqual({ foo: 'foo' });
+    expect(JSON.parse(input2.dataset.value)).toEqual(['bar']);
   });
 
   it('should handle isFormDisabled with dynamic inputs', () => {
@@ -500,29 +522,33 @@ describe('Element', () => {
       render() {
         return (
           <Formsy disabled={this.state.bool}>
-            {this.state.bool ? <TestInput name="foo" /> : <TestInput name="bar" />}
+            <TestInput name="foo" testId="test-input" />
+            <button type="button" data-testid="btn" onClick={this.flip} />
           </Formsy>
         );
       }
     }
 
-    const form = mount<TestForm>(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
+    const btn = screen.getByTestId('btn');
 
-    const input = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(input).isFormDisabled()).toEqual(true);
-    form.instance().flip();
-    expect(getWrapperInstance(input).isFormDisabled()).toEqual(false);
+    expect(input.dataset.isFormDisabled).toEqual('true');
+    fireEvent.click(btn);
+    expect(input.dataset.isFormDisabled).toEqual('false');
   });
 
   it('should allow for dot notation in name which maps to a deep object', () => {
+    const spy = jest.fn();
+
     class TestForm extends React.Component {
       onSubmit(model) {
-        expect(model).toEqual({ foo: { bar: 'foo', test: 'test' } });
+        spy(model);
       }
 
       render() {
         return (
-          <Formsy onSubmit={this.onSubmit}>
+          <Formsy onSubmit={this.onSubmit} data-testid="form">
             <TestInput name="foo.bar" value="foo" />
             <TestInput name="foo.test" value="test" />
           </Formsy>
@@ -530,24 +556,24 @@ describe('Element', () => {
       }
     }
 
-    const form = mount(<TestForm />);
-
-    // TODO: Beef up this smoke test
-    expect(true).toBe(true);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    fireEvent.submit(form);
 
-    const formEl = form.find('form');
-    formEl.simulate('submit');
+    expect(spy).toHaveBeenCalledWith({ foo: { bar: 'foo', test: 'test' } });
   });
 
   it('should allow for application/x-www-form-urlencoded syntax and convert to object', () => {
+    const spy = jest.fn();
+
     class TestForm extends React.Component {
       onSubmit(model) {
-        expect(model).toEqual({ foo: ['foo', 'bar'] });
+        spy(model);
       }
 
       render() {
         return (
-          <Formsy onSubmit={this.onSubmit}>
+          <Formsy onSubmit={this.onSubmit} data-testid="form">
             <TestInput name="foo[0]" value="foo" />
             <TestInput name="foo[1]" value="bar" />
           </Formsy>
@@ -555,13 +581,11 @@ describe('Element', () => {
       }
     }
 
-    const form = mount(<TestForm />);
-
-    // TODO: Beef up this smoke test
-    expect(true).toBe(true);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    fireEvent.submit(form);
 
-    const formEl = form.find('form');
-    formEl.simulate('submit');
+    expect(spy).toHaveBeenCalledWith({ foo: ['foo', 'bar'] });
   });
 
   it('input should rendered once with PureRenderMixin', () => {
@@ -578,7 +602,7 @@ describe('Element', () => {
       },
     });
 
-    mount(
+    render(
       <Formsy>
         <Input name="foo" value="foo" />
       </Formsy>,
@@ -597,35 +621,51 @@ describe('Element', () => {
 
       render() {
         renderSpy();
-        return <input type={this.props.type} value={this.props.value} onChange={this.updateValue} />;
+        return (
+          <input type={this.props.type} value={this.props.value} onChange={this.updateValue} data-testid="test-input" />
+        );
       },
     });
 
-    const form = mount(
+    const screen = render(
       <Formsy>
         <Input name="foo" value="foo" />
       </Formsy>,
     );
-
-    const input = form.find('input');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
 
     expect(renderSpy).toHaveBeenCalledTimes(1);
 
-    input.simulate('change', { target: { value: 'fooz' } });
-    expect(getInputInstance(input).value).toEqual('fooz');
+    const value = 'fooz';
+    fireEvent.change(input, { target: { value } });
+
+    expect(input.value).toEqual(value);
     expect(renderSpy).toHaveBeenCalledTimes(2);
   });
 
   it('unregisters on unmount', () => {
-    const TestComponent = ({ hasInput }) => <Formsy>{hasInput ? <TestInput name="foo" value="foo" /> : null}</Formsy>;
+    const submitSpy = jest.fn();
+
+    const TestComponent = () => {
+      const [hasInput, setInput] = useState(true);
+      return (
+        <Formsy onSubmit={(model) => submitSpy(model)} data-testid="form">
+          {hasInput ? <TestInput name="foo" value="foo" /> : null}
+          <button type="button" data-testid="btn" onClick={() => setInput(false)} />
+        </Formsy>
+      );
+    };
 
-    const wrapper = mount(<TestComponent hasInput />);
-    const formsy = getFormInstance(wrapper.find(Formsy));
+    const screen = render(<TestComponent />);
+    const form = screen.getByTestId('form');
+    const btn = screen.getByTestId('btn');
 
-    expect(formsy.inputs).toHaveLength(1);
+    fireEvent.submit(form);
+    expect(submitSpy).toHaveBeenCalledWith({ foo: 'foo' });
 
-    wrapper.setProps({ hasInput: false });
+    fireEvent.click(btn);
 
-    expect(formsy.inputs).toHaveLength(0);
+    fireEvent.submit(form);
+    expect(submitSpy).toHaveBeenCalledWith({});
   });
 });
diff --git a/__tests__/Formsy.spec.tsx b/__tests__/Formsy.spec.tsx
index cc0596f6..1ecb6ac3 100755
--- a/__tests__/Formsy.spec.tsx
+++ b/__tests__/Formsy.spec.tsx
@@ -1,10 +1,9 @@
 /* eslint-disable max-classes-per-file, react/destructuring-assignment */
-import { mount } from 'enzyme';
+import { createEvent, fireEvent, render } from '@testing-library/react';
 import * as React from 'react';
-import { useState } from 'react';
+import { useRef, useState } from 'react';
 
 import DynamicInputForm from '../__test_utils__/DynamicInputForm';
-import { getFormInstance, getWrapperInstance } from '../__test_utils__/getInput';
 import TestInput from '../__test_utils__/TestInput';
 import TestInputHoc from '../__test_utils__/TestInputHoc';
 import Formsy, { addValidationRule } from '../src';
@@ -12,48 +11,53 @@ import { ValidationError } from '../src/interfaces';
 
 describe('Setting up a form', () => {
   it('should expose the users DOM node through an innerRef prop', () => {
-    class TestForm extends React.Component {
-      public inputRef: any;
+    const refSpy = jest.fn();
 
+    class TestForm extends React.Component {
       render() {
         return (
           <Formsy>
             <TestInputHoc
               name="name"
-              innerRef={(c) => {
-                this.inputRef = c;
+              innerRef={(ref: any) => {
+                if (!ref) {
+                  return;
+                }
+
+                refSpy(ref.constructor.name);
               }}
+              testId="test-input"
             />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    const input = ((form.instance() as TestForm) as TestForm).inputRef;
-    expect(input.props.name).toEqual('name');
+    render(<TestForm />);
+
+    expect(refSpy).toHaveBeenCalledWith('TestComponent');
   });
 
   it('should render a form into the document', () => {
-    const form = mount(<Formsy />);
-    expect(form.find('form').name()).toEqual('form');
+    const screen = render(<Formsy data-testid="form" />);
+    const form = screen.getByTestId('form') as HTMLFormElement;
+
+    expect(form.tagName.toLowerCase()).toEqual('form');
   });
 
   it('should set a class name if passed', () => {
-    const form = mount(<Formsy className="foo" />);
-    expect(form.find('form').hasClass('foo')).toBe(true);
+    const screen = render(<Formsy data-testid="form" className="foo" />);
+    const form = screen.getByTestId('form') as HTMLFormElement;
+
+    expect(form.classList.contains('foo')).toBe(true);
   });
 
   it('should allow for null/undefined children', () => {
-    let model = null;
+    const submitSpy = jest.fn();
 
     function TestForm() {
       return (
-        <Formsy
-          onSubmit={(formModel) => {
-            model = formModel;
-          }}
-        >
+        <Formsy onSubmit={(formModel) => submitSpy(formModel)} data-testid="form">
           <h1>Test</h1>
           {null}
           {undefined}
@@ -62,52 +66,47 @@ describe('Setting up a form', () => {
       );
     }
 
-    const form = mount(<TestForm />);
-    form.simulate('submit');
-    expect(model).toEqual({ name: 'foo' });
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    fireEvent.submit(form);
+
+    expect(submitSpy).toHaveBeenCalledWith({ name: 'foo' });
   });
 
   it('should allow for inputs being added dynamically', () => {
-    let model = null;
-
-    const form = mount(
-      <DynamicInputForm
-        onSubmit={(formModel) => {
-          model = formModel;
-        }}
-        inputName="test"
-      />,
-    );
-    form.find('button').simulate('click');
-    form.update();
+    const submitSpy = jest.fn();
+
+    const screen = render(<DynamicInputForm onSubmit={(formModel) => submitSpy(formModel)} inputName="test" />);
+    const form = screen.getByTestId('form');
+    const addInputBtn = screen.getByTestId('add-input-btn');
 
-    form.simulate('submit');
-    expect(model).toHaveProperty('test');
+    fireEvent.click(addInputBtn);
+    fireEvent.submit(form);
+
+    expect(submitSpy).toHaveBeenCalledWith({ test: '' });
   });
 
   it('should allow dynamically added inputs to update the form-model', () => {
-    let model = null;
-
-    const form = mount(
-      <DynamicInputForm
-        onSubmit={(formModel) => {
-          model = formModel;
-        }}
-        inputName="test"
-      />,
-    );
-    form.find('button').simulate('click');
-    form.update();
+    const submitSpy = jest.fn();
+
+    const screen = render(<DynamicInputForm onSubmit={(formModel) => submitSpy(formModel)} inputName="test" />);
+    const form = screen.getByTestId('form');
+    const addInputBtn = screen.getByTestId('add-input-btn');
 
-    form.find('input').simulate('change', {
+    fireEvent.click(addInputBtn);
+
+    fireEvent.change(screen.getByTestId('test-input'), {
       target: { value: 'foo' },
     });
-    form.simulate('submit');
-    expect(model).toHaveProperty('test', 'foo');
+
+    fireEvent.submit(form);
+
+    expect(submitSpy).toHaveBeenCalledWith({ test: 'foo' });
   });
 
   it('should allow a dynamically updated input to update the form-model', () => {
-    let model = null;
+    const submitSpy = jest.fn();
 
     class TestForm extends React.Component<{ inputValue: any }, { inputValue: any }> {
       constructor(props) {
@@ -120,13 +119,9 @@ describe('Setting up a form', () => {
       render() {
         const { inputValue } = this.state;
         return (
-          <Formsy
-            onSubmit={(formModel) => {
-              model = formModel;
-            }}
-          >
-            <TestInput name="test" value={inputValue} />
-            <button type="button" onClick={this.updateInputValue}>
+          <Formsy onSubmit={(formModel) => submitSpy(formModel)} data-testid="form">
+            <TestInput name="test" value={inputValue} testId="test-input" />
+            <button type="button" onClick={this.updateInputValue} data-testid="update-btn">
               Update
             </button>
           </Formsy>
@@ -134,18 +129,18 @@ describe('Setting up a form', () => {
       }
     }
 
-    const form = mount(<TestForm inputValue="foo" />);
+    const screen = render(<TestForm inputValue="foo" />);
+    const form = screen.getByTestId('form');
+    const updateBtn = screen.getByTestId('update-btn');
 
-    form.simulate('submit');
+    fireEvent.submit(form);
 
-    expect(model).toHaveProperty('test', 'foo');
+    expect(submitSpy).toHaveBeenCalledWith({ test: 'foo' });
 
-    form.find('button').simulate('click');
-    form.update();
-    form.simulate('submit');
-    form.update();
+    fireEvent.click(updateBtn);
+    fireEvent.submit(form);
 
-    expect(model).toHaveProperty('test', 'bar');
+    expect(submitSpy).toHaveBeenCalledWith({ test: 'bar' });
   });
 });
 
@@ -159,15 +154,17 @@ describe('mapModel', () => {
 
     function TestForm() {
       return (
-        <Formsy mapping={mapping} onSubmit={onSubmit}>
+        <Formsy mapping={mapping} onSubmit={onSubmit} data-testid="form">
           <TestInput name="parent.child" value="test" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    fireEvent.submit(form);
 
-    form.simulate('submit');
     expect(mapping).toHaveBeenCalledWith({ 'parent.child': 'test' });
     expect(onSubmit).toHaveBeenCalledWith(
       { 'parent.child': 'test', testChange: true },
@@ -186,14 +183,14 @@ describe('validations', () => {
     addValidationRule('runRule', runRule);
     addValidationRule('notRunRule', notRunRule);
 
-    const form = mount(
+    const screen = render(
       <Formsy>
-        <TestInput name="one" validations="runRule" value="foo" />
+        <TestInput name="one" validations="runRule" value="foo" testId="test-input" />
       </Formsy>,
     );
 
-    const input = form.find('input');
-    input.simulate('change', {
+    const input = screen.getByTestId('test-input');
+    fireEvent.change(input, {
       target: { value: 'bar' },
     });
 
@@ -222,23 +219,29 @@ describe('validations', () => {
       render() {
         return (
           <Formsy>
-            <TestInput name="one" validations={this.state.rule} value="foo" />
+            <TestInput name="one" validations={this.state.rule} value="foo" testId="test-input" />
+            <button type="button" onClick={this.changeRule} data-testid="change-rule-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    (form.instance() as TestForm).changeRule();
-    const input = form.find('input');
-    input.simulate('change', {
+    const screen = render(<TestForm />);
+    const changeRuleBtn = screen.getByTestId('change-rule-btn');
+    const input = screen.getByTestId('test-input');
+
+    fireEvent.click(changeRuleBtn);
+
+    fireEvent.change(input, {
       target: { value: 'bar' },
     });
+
     expect(ruleB).toHaveBeenCalledWith({ one: 'bar' }, 'bar', true);
   });
 
   it('should invalidate a form if dynamically inserted input is invalid', () => {
     const isInValidSpy = jest.fn();
+    const isValidSpy = jest.fn();
 
     class TestForm extends React.Component<{}, { showSecondInput: boolean }> {
       formRef = React.createRef<Formsy>();
@@ -256,24 +259,28 @@ describe('validations', () => {
 
       render() {
         return (
-          <Formsy ref={this.formRef} onInvalid={isInValidSpy}>
+          <Formsy ref={this.formRef} onInvalid={isInValidSpy} onValid={isValidSpy}>
             <TestInput name="one" validations="isEmail" value="foo@bar.com" />
             {this.state.showSecondInput ? <TestInput name="two" validations="isEmail" value="foo@bar" /> : null}
+            <button type="button" onClick={this.addInput} data-testid="add-input-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const addInputBtn = screen.getByTestId('add-input-btn');
 
-    expect((form.instance() as TestForm).formRef.current.state.isValid).toEqual(true);
-    (form.instance() as TestForm).addInput();
+    expect(isValidSpy).toHaveBeenCalled();
+
+    fireEvent.click(addInputBtn);
 
     expect(isInValidSpy).toHaveBeenCalled();
   });
 
   it('should validate a form when removing an invalid input', () => {
     const isValidSpy = jest.fn();
+    const isInValidSpy = jest.fn();
 
     class TestForm extends React.Component<{}, { showSecondInput: boolean }> {
       formRef = React.createRef<Formsy>();
@@ -283,26 +290,29 @@ describe('validations', () => {
         this.state = { showSecondInput: true };
       }
 
-      removeInput() {
+      removeInput = () => {
         this.setState({
           showSecondInput: false,
         });
-      }
+      };
 
       render() {
         return (
-          <Formsy ref={this.formRef} onValid={isValidSpy}>
+          <Formsy ref={this.formRef} onValid={isValidSpy} onInvalid={isInValidSpy}>
             <TestInput name="one" validations="isEmail" value="foo@bar.com" />
             {this.state.showSecondInput ? <TestInput name="two" validations="isEmail" value="foo@bar" /> : null}
+            <button type="button" onClick={this.removeInput} data-testid="remove-input-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const removeInputBtn = screen.getByTestId('remove-input-btn');
 
-    expect((form.instance() as TestForm).formRef.current.state.isValid).toEqual(false);
-    (form.instance() as TestForm).removeInput();
+    expect(isInValidSpy).toHaveBeenCalled();
+
+    fireEvent.click(removeInputBtn);
 
     expect(isValidSpy).toHaveBeenCalled();
   });
@@ -313,16 +323,16 @@ describe('validations', () => {
     addValidationRule('ruleA', ruleA);
     addValidationRule('ruleB', ruleB);
 
-    const form = mount(
+    const screen = render(
       <Formsy>
-        <TestInput name="one" validations="ruleA,ruleB" value="foo" />
+        <TestInput name="one" validations="ruleA,ruleB" value="foo" testId="test-input" />
       </Formsy>,
     );
 
-    const input = form.find('input');
-    input.simulate('change', {
-      target: { value: 'bar' },
-    });
+    const input = screen.getByTestId('test-input');
+
+    fireEvent.change(input, { target: { value: 'bar' } });
+
     expect(ruleA).toHaveBeenCalledWith({ one: 'bar' }, 'bar', true);
     expect(ruleB).toHaveBeenCalledWith({ one: 'bar' }, 'bar', true);
   });
@@ -333,21 +343,23 @@ describe('onChange', () => {
     const hasChanged = jest.fn();
 
     function TestForm() {
-      return <Formsy onChange={hasChanged} />;
+      return <Formsy onChange={hasChanged} data-testid="form" />;
     }
 
-    mount(<TestForm />);
+    render(<TestForm />);
     expect(hasChanged).not.toHaveBeenCalled();
   });
 
   it('should trigger onChange once when form element is changed', () => {
     const hasChanged = jest.fn();
-    const form = mount(
+    const screen = render(
       <Formsy onChange={hasChanged}>
-        <TestInput name="foo" value="" />
+        <TestInput name="foo" value="" testId="test-input" />
       </Formsy>,
     );
-    form.find('input').simulate('change', { target: { value: 'bar' } });
+
+    fireEvent.change(screen.getByTestId('test-input'), { target: { value: 'bar' } });
+
     expect(hasChanged).toHaveBeenCalledTimes(1);
   });
 
@@ -362,19 +374,27 @@ describe('onChange', () => {
         };
       }
 
-      addInput() {
+      showInput = () => {
         this.setState({
           showInput: true,
         });
-      }
+      };
 
       render() {
-        return <Formsy onChange={hasChanged}>{this.state.showInput ? <TestInput name="test" /> : null}</Formsy>;
+        return (
+          <Formsy onChange={hasChanged}>
+            {this.state.showInput ? <TestInput name="test" /> : null}
+            <button type="button" onClick={this.showInput} data-testid="show-input-btn" />
+          </Formsy>
+        );
       }
     }
 
-    const form = mount(<TestForm />);
-    (form.instance() as TestForm).addInput();
+    const screen = render(<TestForm />);
+    const showInputBtn = screen.getByTestId('show-input-btn');
+
+    fireEvent.click(showInputBtn);
+
     expect(hasChanged).toHaveBeenCalledTimes(1);
   });
 
@@ -389,24 +409,26 @@ describe('onChange', () => {
         };
       }
 
-      addInput() {
+      showInput = () => {
         this.setState({
           showInput: true,
         });
-      }
+      };
 
       render() {
         return (
           <Formsy onChange={hasChanged}>
             {this.state.showInput ? <TestInput name="parent.child" value="test" /> : null}
+            <button type="button" onClick={this.showInput} data-testid="show-input-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    (form.instance() as TestForm).addInput();
-    form.update();
+    const screen = render(<TestForm />);
+    const showInputBtn = screen.getByTestId('show-input-btn');
+
+    fireEvent.click(showInputBtn);
 
     expect(hasChanged).toHaveBeenCalledWith({ parent: { child: 'test' } }, false);
   });
@@ -422,34 +444,41 @@ describe('Update a form', () => {
         };
       }
 
-      enableForm() {
+      enableForm = () => {
         this.setState({ disabled: false });
-      }
+      };
 
       render() {
         return (
           <Formsy disabled={this.state.disabled}>
-            <TestInput name="foo" />
+            <TestInput name="foo" testId="test-input" />
+            <button type="button" onClick={this.enableForm} data-testid="enable-form-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    const input = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(input).isFormDisabled()).toEqual(true);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
+    const enableFormBtn = screen.getByTestId('enable-form-btn');
+
+    expect(input.dataset.isFormDisabled).toEqual('true');
 
-    (form.instance() as TestForm).enableForm();
+    fireEvent.click(enableFormBtn);
 
-    expect(getWrapperInstance(input).isFormDisabled()).toEqual(false);
+    expect(input.dataset.isFormDisabled).toEqual('false');
   });
 
   it('should be possible to pass error state of elements by changing an errors attribute', () => {
-    class TestForm extends React.Component<{}, { validationErrors: { [key: string]: React.ReactNode } }> {
+    class TestForm extends React.Component<
+      {},
+      { validationErrors: { [key: string]: React.ReactNode }; value: string }
+    > {
       constructor(props) {
         super(props);
         this.state = {
           validationErrors: { foo: 'bar' },
+          value: '',
         };
       }
 
@@ -457,54 +486,68 @@ describe('Update a form', () => {
         this.setState(values.foo ? { validationErrors: {} } : { validationErrors: { foo: 'bar' } });
       };
 
+      changeValue = () => {
+        this.setState({ value: 'new value' });
+      };
+
       render() {
         return (
           <Formsy onChange={this.onChange} validationErrors={this.state.validationErrors}>
-            <TestInput name="foo" value="" />
+            <TestInput name="foo" value={this.state.value} testId="test-input" />
+            <button type="button" onClick={this.changeValue} data-testid="change-value-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
+    const changeValueBtn = screen.getByTestId('change-value-btn');
+    expect(input.dataset.errorMessage).toEqual('bar');
 
-    const input = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(input).getErrorMessage()).toEqual('bar');
-    getWrapperInstance(input).setValue('gotValue');
+    fireEvent.click(changeValueBtn);
 
-    expect(getWrapperInstance(input).getErrorMessage()).toEqual(null);
+    expect(input.dataset.errorMessage).toEqual(undefined);
   });
 
   it('should prevent a default submit', () => {
     function TestForm() {
       return (
-        <Formsy>
+        <Formsy data-testid="form">
           <TestInput name="foo" validations="isEmail" value="foo@bar.com" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const FoundForm = form.find(TestForm);
-    const submitEvent = { preventDefault: jest.fn() };
-    FoundForm.simulate('submit', submitEvent);
-    expect(submitEvent.preventDefault).toHaveBeenCalled();
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    const event = createEvent.submit(form);
+    event.preventDefault = jest.fn();
+
+    fireEvent(form, event);
+
+    expect(event.preventDefault).toHaveBeenCalled();
   });
 
   it('should not prevent a default submit when preventDefaultSubmit is passed', () => {
     function TestForm() {
       return (
-        <Formsy preventDefaultSubmit={false}>
+        <Formsy data-testid="form" preventDefaultSubmit={false}>
           <TestInput name="foo" validations="isEmail" value="foo@bar.com" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const FoundForm = form.find(TestForm);
-    const submitEvent = { preventDefault: jest.fn() };
-    FoundForm.simulate('submit', submitEvent);
-    expect(submitEvent.preventDefault).not.toHaveBeenCalled();
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    const event = createEvent.submit(form);
+    event.preventDefault = jest.fn();
+
+    fireEvent(form, event);
+
+    expect(event.preventDefault).not.toHaveBeenCalled();
   });
 
   it('should trigger an onValidSubmit when submitting a valid form', () => {
@@ -512,15 +555,17 @@ describe('Update a form', () => {
 
     function TestForm() {
       return (
-        <Formsy onValidSubmit={isCalled}>
+        <Formsy onValidSubmit={isCalled} data-testid="form">
           <TestInput name="foo" validations="isEmail" value="foo@bar.com" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const FoundForm = form.find(TestForm);
-    FoundForm.simulate('submit');
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    fireEvent.submit(form);
+
     expect(isCalled).toHaveBeenCalled();
   });
 
@@ -529,16 +574,17 @@ describe('Update a form', () => {
 
     function TestForm() {
       return (
-        <Formsy onInvalidSubmit={isCalled}>
+        <Formsy onInvalidSubmit={isCalled} data-testid="form">
           <TestInput name="foo" validations="isEmail" value="foo@bar" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    fireEvent.submit(form);
 
-    const FoundForm = form.find(TestForm);
-    FoundForm.simulate('submit');
     expect(isCalled).toHaveBeenCalled();
   });
 });
@@ -549,15 +595,18 @@ describe('value === false', () => {
 
     function TestForm() {
       return (
-        <Formsy onSubmit={onSubmit}>
+        <Formsy onSubmit={onSubmit} data-testid="form">
           <TestInput name="foo" value={false} type="checkbox" />
           <button type="submit">Save</button>
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    form.simulate('submit');
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+
+    fireEvent.submit(form);
+
     expect(onSubmit).toHaveBeenCalledWith(
       { foo: false },
       expect.any(Function),
@@ -577,25 +626,31 @@ describe('value === false', () => {
         };
       }
 
-      changeValue() {
+      changeValue = () => {
         this.setState({
           value: false,
         });
-      }
+      };
 
       render() {
         return (
-          <Formsy onSubmit={onSubmit}>
+          <Formsy onSubmit={onSubmit} data-testid="form">
             <TestInput name="foo" value={this.state.value} type="checkbox" />
-            <button type="submit">Save</button>
+            <button type="button" data-testid="change-value-btn" onClick={this.changeValue}>
+              Save
+            </button>
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    (form.instance() as TestForm).changeValue();
-    form.simulate('submit');
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    const changeValueBtn = screen.getByTestId('change-value-btn');
+
+    fireEvent.click(changeValueBtn);
+    fireEvent.submit(form);
+
     expect(onSubmit).toHaveBeenCalledWith(
       { foo: false },
       expect.any(Function),
@@ -608,17 +663,23 @@ describe('value === false', () => {
     function TestForm() {
       return (
         <Formsy>
-          <TestInput name="foo" value type="checkbox" />
-          <button type="submit">Save</button>
+          <TestInput name="foo" value type="checkbox" testId="test-input" />
+          <button type="submit" data-testid="submit-btn">
+            Save
+          </button>
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const input = form.find('Formsy(TestInput)');
-    expect(getWrapperInstance(input).isFormSubmitted()).toEqual(false);
-    form.simulate('submit');
-    expect(getWrapperInstance(input).isFormSubmitted()).toEqual(true);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input');
+    const submitBtn = screen.getByTestId('submit-btn');
+
+    expect(input.dataset.isFormSubmitted).toEqual('false');
+
+    fireEvent.click(submitBtn);
+
+    expect(input.dataset.isFormSubmitted).toEqual('true');
   });
 
   it('should be able to reset the form to its pristine state', () => {
@@ -630,34 +691,47 @@ describe('value === false', () => {
         };
       }
 
-      changeValue() {
+      changeValue = () => {
         this.setState({
           value: false,
         });
-      }
+      };
 
       render() {
         return (
           <Formsy>
-            <TestInput name="foo" value={this.state.value} type="checkbox" />
-            <button type="submit">Save</button>
+            <TestInput name="foo" value={this.state.value} type="checkbox" testId="test-input" />
+            <button type="button" onClick={this.changeValue} data-testid="change-value-btn">
+              Change value
+            </button>
+            <button type="reset" data-testid="reset-btn">
+              Rest value
+            </button>
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    const input = form.find('Formsy(TestInput)');
-    const formsyForm = form.find(Formsy);
-    expect(getWrapperInstance(input).getValue()).toEqual(true);
-    (form.instance() as TestForm).changeValue();
-    expect(getWrapperInstance(input).getValue()).toEqual(false);
-    getFormInstance(formsyForm).reset();
-    expect(getWrapperInstance(input).getValue()).toEqual(true);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+    const changeValueBtn = screen.getByTestId('change-value-btn');
+    const resetBtn = screen.getByTestId('reset-btn');
+
+    expect(input.dataset.value).toEqual('true');
+
+    fireEvent.click(changeValueBtn);
+
+    expect(input.dataset.value).toEqual('false');
+
+    fireEvent.click(resetBtn);
+
+    expect(input.dataset.value).toEqual('true');
   });
 
   it('should be able to set a value to components with updateInputsWithValue', () => {
     class TestForm extends React.Component<{}, { valueFoo: boolean; valueBar: boolean }> {
+      formRef = React.createRef<Formsy>();
+
       constructor(props) {
         super(props);
         this.state = {
@@ -666,29 +740,39 @@ describe('value === false', () => {
         };
       }
 
+      updateInputsWithValue = () => {
+        this.formRef.current.updateInputsWithValue({ foo: false });
+      };
+
       render() {
         return (
-          <Formsy>
-            <TestInput name="foo" value={this.state.valueFoo} type="checkbox" />
-            <TestInput name="bar" value={this.state.valueBar} type="checkbox" />
-            <button type="submit">Save</button>
+          <Formsy ref={this.formRef}>
+            <TestInput name="foo" value={this.state.valueFoo} type="checkbox" testId="test-input1" />
+            <TestInput name="bar" value={this.state.valueBar} type="checkbox" testId="test-input2" />
+            <button type="button" onClick={this.updateInputsWithValue} data-testid="update-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    const inputs = form.find('Formsy(TestInput)');
-    const formsyForm = form.find(Formsy);
-    expect(getWrapperInstance(inputs.at(0)).getValue()).toEqual(true);
-    expect(getWrapperInstance(inputs.at(1)).getValue()).toEqual(true);
-    getFormInstance(formsyForm).updateInputsWithValue({ foo: false });
-    expect(getWrapperInstance(inputs.at(0)).getValue()).toEqual(false);
-    expect(getWrapperInstance(inputs.at(1)).getValue()).toEqual(true);
+    const screen = render(<TestForm />);
+    const input1 = screen.getByTestId('test-input1');
+    const input2 = screen.getByTestId('test-input2');
+    const updateBtn = screen.getByTestId('update-btn');
+
+    expect(input1.dataset.value).toEqual('true');
+    expect(input2.dataset.value).toEqual('true');
+
+    fireEvent.click(updateBtn);
+
+    expect(input1.dataset.value).toEqual('false');
+    expect(input2.dataset.value).toEqual('true');
   });
 
   it('should be able to set a deep value with updateInputsWithValue', () => {
-    class TestForm extends React.Component<{}, { valueBar: number; valueFoo: { valueBar: number }}> {
+    class TestForm extends React.Component<{}, { valueBar: number; valueFoo: { valueBar: number } }> {
+      formRef = React.createRef<Formsy>();
+
       constructor(props) {
         super(props);
         this.state = {
@@ -697,29 +781,39 @@ describe('value === false', () => {
         };
       }
 
+      updateInputsWithValue = () => {
+        this.formRef.current.updateInputsWithValue({ foo: { bar: 3 }, bar: 4 });
+      };
+
       render() {
         return (
-          <Formsy>
-            <TestInput name="foo.bar" value={this.state.valueFoo.valueBar} />
-            <TestInput name="bar" value={this.state.valueBar} />
-            <button type="submit">Save</button>
+          <Formsy ref={this.formRef}>
+            <TestInput name="foo.bar" value={this.state.valueFoo.valueBar} testId="test-input1" />
+            <TestInput name="bar" value={this.state.valueBar} testId="test-input2" />
+            <button type="button" onClick={this.updateInputsWithValue} data-testid="update-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    const inputs = form.find('Formsy(TestInput)');
-    const formsyForm = form.find(Formsy);
-    expect(getWrapperInstance(inputs.at(0)).getValue()).toEqual(1);
-    expect(getWrapperInstance(inputs.at(1)).getValue()).toEqual(2);
-    getFormInstance(formsyForm).updateInputsWithValue({ foo: { bar: 3 }, bar: 4 });
-    expect(getWrapperInstance(inputs.at(0)).getValue()).toEqual(3);
-    expect(getWrapperInstance(inputs.at(1)).getValue()).toEqual(4);
+    const screen = render(<TestForm />);
+    const input1 = screen.getByTestId('test-input1') as HTMLInputElement;
+    const input2 = screen.getByTestId('test-input2') as HTMLInputElement;
+    const updateBtn = screen.getByTestId('update-btn');
+
+    expect(input1.value).toEqual('1');
+    expect(input2.value).toEqual('2');
+
+    fireEvent.click(updateBtn);
+
+    expect(input1.dataset.value).toEqual('3');
+    expect(input2.dataset.value).toEqual('4');
   });
 
   it('should be able to reset the form using custom data', () => {
     class TestForm extends React.Component<{}, { value: number; valueDeep: number }> {
+      formRef = React.createRef<Formsy>();
+
       constructor(props) {
         super(props);
         this.state = {
@@ -728,135 +822,159 @@ describe('value === false', () => {
         };
       }
 
-      changeValue() {
+      changeValue = () => {
         this.setState({
           value: 2,
           valueDeep: 12,
         });
-      }
+      };
+
+      resetValues = () => {
+        this.formRef.current.reset({
+          foo: 3,
+          bar: { foo: 13 },
+        });
+      };
 
       render() {
         const { value, valueDeep } = this.state;
 
         return (
-          <Formsy>
-            <TestInput name="foo" value={value} />
-            <TestInput name="bar.foo" value={valueDeep} />
-            <button type="submit">Save</button>
+          <Formsy ref={this.formRef}>
+            <TestInput name="foo" value={value} testId="test-input1" />
+            <TestInput name="bar.foo" value={valueDeep} testId="test-input2" />
+            <button type="button" onClick={this.changeValue} data-testid="change-value-btn" />
+            <button type="button" onClick={this.resetValues} data-testid="reset-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    const input = form.find('Formsy(TestInput)').at(0);
-    const inputDeep = form.find('Formsy(TestInput)').at(1);
-    const formsyForm = form.find(Formsy);
+    const screen = render(<TestForm />);
+    const input1 = screen.getByTestId('test-input1') as HTMLInputElement;
+    const input2 = screen.getByTestId('test-input2') as HTMLInputElement;
+    const updateValueBtn = screen.getByTestId('change-value-btn');
+    const resetBtn = screen.getByTestId('reset-btn');
 
-    expect(getWrapperInstance(input).getValue()).toEqual(1);
-    expect(getWrapperInstance(inputDeep).getValue()).toEqual(11);
+    expect(input1.value).toEqual('1');
+    expect(input2.value).toEqual('11');
 
-    ((form.instance() as TestForm) as TestForm).changeValue();
-    expect(getWrapperInstance(input).getValue()).toEqual(2);
-    expect(getWrapperInstance(inputDeep).getValue()).toEqual(12);
+    fireEvent.click(updateValueBtn);
 
-    getFormInstance(formsyForm).reset({
-      foo: 3,
-      bar: { foo: 13 },
-    });
-    expect(getWrapperInstance(input).getValue()).toEqual(3);
-    expect(getWrapperInstance(inputDeep).getValue()).toEqual(13);
+    expect(input1.value).toEqual('2');
+    expect(input2.value).toEqual('12');
+
+    fireEvent.click(resetBtn);
+
+    expect(input1.value).toEqual('3');
+    expect(input2.value).toEqual('13');
   });
 });
 
 describe('.reset()', () => {
   it('should be able to reset the form to empty values', () => {
     function TestForm() {
+      const formRef = useRef<Formsy>();
       return (
-        <Formsy>
-          <TestInput name="foo" value="42" type="checkbox" />
-          <button type="submit">Save</button>
+        <Formsy ref={formRef}>
+          <TestInput name="foo" value="42" type="checkbox" testId="test-input" />
+          <button
+            type="button"
+            onClick={() =>
+              formRef.current.reset({
+                foo: '',
+              })
+            }
+            data-testid="reset-btn"
+          >
+            Reset
+          </button>
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const input = form.find('Formsy(TestInput)');
-    const formsyForm = form.find(Formsy);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+    const resetBtn = screen.getByTestId('reset-btn');
 
-    getFormInstance(formsyForm).reset({
-      foo: '',
-    });
-    expect(getWrapperInstance(input).getValue()).toEqual('');
+    fireEvent.click(resetBtn);
+
+    expect(input.value).toEqual('');
   });
 
   it('should be able to reset the form using a button', () => {
     function TestForm() {
       return (
         <Formsy>
-          <TestInput name="foo" value="foo" />
-          <button type="submit">Save</button>
+          <TestInput name="foo" value="foo" testId="test-input" />
+          <button type="reset" data-testid="reset-btn">
+            Reset
+          </button>
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const input = form.find('Formsy(TestInput)');
-    const formsyForm = form.find(Formsy);
+    const screen = render(<TestForm />);
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+    const resetBtn = screen.getByTestId('reset-btn');
+
+    expect(input.value).toEqual('foo');
+
+    fireEvent.change(input, { target: { value: 'foobar' } });
+
+    expect(input.value).toEqual('foobar');
+
+    fireEvent.click(resetBtn);
 
-    expect(getWrapperInstance(input).getValue()).toEqual('foo');
-    input.simulate('change', { target: { value: 'foobar' } });
-    expect(getWrapperInstance(input).getValue()).toEqual('foobar');
-    formsyForm.simulate('reset');
-    expect(getWrapperInstance(input).getValue()).toEqual('foo');
+    expect(input.value).toEqual('foo');
   });
 });
 
 describe('.isChanged()', () => {
   it('initially returns false', () => {
     const hasOnChanged = jest.fn();
-    const form = mount(
-      <Formsy onChange={hasOnChanged}>
+    const formRef = React.createRef<Formsy>();
+    render(
+      <Formsy onChange={hasOnChanged} ref={formRef}>
         <TestInput name="one" value="foo" />
       </Formsy>,
     );
-    expect(getFormInstance(form).isChanged()).toEqual(false);
+
+    expect(formRef.current.isChanged()).toEqual(false);
     expect(hasOnChanged).not.toHaveBeenCalled();
   });
 
   it('returns true when changed', () => {
     const hasOnChanged = jest.fn();
-    const form = mount(
+    const screen = render(
       <Formsy onChange={hasOnChanged}>
-        <TestInput name="one" value="foo" />
+        <TestInput name="one" value="foo" testId="test-input" />
       </Formsy>,
     );
-    const input = form.find('input');
-    input.simulate('change', {
+    const input = screen.getByTestId('test-input');
+    fireEvent.change(input, {
       target: { value: 'bar' },
     });
-    expect(getFormInstance(form).isChanged()).toEqual(true);
+
     expect(hasOnChanged).toHaveBeenCalledWith({ one: 'bar' }, true);
   });
 
   it('returns false if changes are undone', () => {
     const hasOnChanged = jest.fn();
-    const form = mount(
+    const screen = render(
       <Formsy onChange={hasOnChanged}>
-        <TestInput name="one" value="foo" />
+        <TestInput name="one" value="foo" testId="test-input" />
       </Formsy>,
     );
-    const input = form.find('input');
-    input.simulate('change', {
+    const input = screen.getByTestId('test-input');
+    fireEvent.change(input, {
       target: { value: 'bar' },
     });
     expect(hasOnChanged).toHaveBeenCalledWith({ one: 'bar' }, true);
 
-    input.simulate('change', {
+    fireEvent.change(input, {
       target: { value: 'foo' },
     });
-
-    expect(getFormInstance(form).isChanged()).toEqual(false);
     expect(hasOnChanged).toHaveBeenCalledWith({ one: 'foo' }, false);
   });
 });
@@ -880,17 +998,23 @@ describe('form valid state', () => {
 
       render() {
         return (
-          <Formsy onInvalid={this.onInvalid} onValid={this.onValid} onValidSubmit={this.onValidSubmit}>
+          <Formsy
+            onInvalid={this.onInvalid}
+            onValid={this.onValid}
+            onValidSubmit={this.onValidSubmit}
+            data-testid="form"
+          >
             <TestInput name="foo" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
 
     expect(isValid).toEqual(true);
-    form.simulate('submit');
+    fireEvent.submit(form);
 
     expect(isValid).toEqual(false);
   });
@@ -901,22 +1025,36 @@ describe('form valid state', () => {
       // do nothing
     });
 
+    const errorSpy = jest.fn();
+
     class TestForm extends React.Component {
       onValidSubmit = (_model, _reset, updateInputsWithError) => {
-        updateInputsWithError({ bar: 'bar' }, true);
+        try {
+          updateInputsWithError({ bar: 'bar' }, true);
+        } catch (e) {
+          errorSpy(e.message);
+        }
       };
 
+      public componentDidCatch(error: Error) {
+        errorSpy(error);
+      }
+
       render() {
         return (
-          <Formsy onValidSubmit={this.onValidSubmit}>
-            <TestInput name="foo" />
+          <Formsy onValidSubmit={this.onValidSubmit} data-testid="form">
+            <TestInput name="foo" testId="test-input" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
-    expect(() => form.simulate('submit')).toThrow();
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    fireEvent.submit(form);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('You are trying to update an input that does not exist'),
+    );
     mockConsoleError.mockRestore();
   });
 
@@ -947,15 +1085,17 @@ describe('form valid state', () => {
         return (
           <Formsy onInvalid={this.onInvalid} onValid={this.onValid} validationErrors={this.state.validationErrors}>
             <TestInput name="foo" />
+            <button type="button" onClick={() => this.setValidationErrors()} data-testid="validation-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const validationBtn = screen.getByTestId('validation-btn');
 
     expect(isValid).toEqual(true);
-    (form.instance() as TestForm).setValidationErrors();
+    fireEvent.click(validationBtn);
     expect(isValid).toEqual(false);
   });
 
@@ -991,15 +1131,18 @@ describe('form valid state', () => {
             validationErrors={this.state.validationErrors}
           >
             <TestInput name="foo" />
+            <button type="button" onClick={() => this.setValidationErrors()} data-testid="validation-btn" />
           </Formsy>
         );
       }
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
+    const validationBtn = screen.getByTestId('validation-btn');
 
     expect(isValid).toEqual(true);
-    (form.instance() as TestForm).setValidationErrors();
+
+    fireEvent.click(validationBtn);
 
     expect(isValid).toEqual(true);
   });
@@ -1011,7 +1154,7 @@ describe('form valid state', () => {
 
       return (
         <>
-          <button type="button" onClick={() => setCounter(counter + 1)} id="add">
+          <button type="button" onClick={() => setCounter(counter + 1)} data-testid="add-btn">
             +
           </button>
           {Array.from(Array(counter)).map((_, index) => (
@@ -1029,13 +1172,14 @@ describe('form valid state', () => {
       );
     };
     jest.useFakeTimers();
-    const form = mount(<TestForm />);
-    const plusButton = form.find('#add');
+    const screen = render(<TestForm />);
+    const plusButton = screen.getByTestId('add-btn');
+
     jest.runAllTimers();
 
     expect(isValid).toBe(true);
 
-    plusButton.simulate('click');
+    fireEvent.click(plusButton);
 
     expect(isValid).toBe(false);
   });
@@ -1051,7 +1195,7 @@ describe('form valid state', () => {
       </Formsy>
     );
 
-    mount(<TestForm />);
+    render(<TestForm />);
 
     expect(validSpy).toHaveBeenCalledTimes(1 + 1); // one for form mount & 1 for all attachToForm calls
   });
@@ -1062,20 +1206,21 @@ describe('onSubmit/onValidSubmit/onInvalidSubmit', () => {
     it(`should pass submit event to "${key}"`, () => {
       const submitSpy = jest.fn();
 
-      const form = mount(
+      const screen = render(
         <Formsy {...{ [key]: submitSpy }}>
-          <button id="submit">submit</button>
+          <button type="submit" data-testid="submit-btn" />
           {key === 'onInvalidSubmit' && <TestInput name="test" required={true} />}
         </Formsy>,
       );
-      const button = form.find('#submit');
-      button.simulate('submit');
+      const button = screen.getByTestId('submit-btn');
+
+      fireEvent.click(button);
 
       expect(submitSpy).toHaveBeenCalledWith(
         expect.any(Object),
         expect.any(Function),
         expect.any(Function),
-        expect.objectContaining({ type: 'submit' }),
+        expect.any(Object),
       );
     });
   });
@@ -1083,12 +1228,17 @@ describe('onSubmit/onValidSubmit/onInvalidSubmit', () => {
 
 describe('<Formsy /> can render any tag or element with the props as', () => {
   it('as div', () => {
-    const form = mount(<Formsy formElement="div" />);
-    expect(form.find('div').length).toBe(1);
+    const screen = render(<Formsy formElement="div" data-testid="form" />);
+    const form = screen.getByTestId('form');
+
+    expect(form.tagName.toLowerCase()).toBe('div');
   });
+
   it('as CustumElement', () => {
-    const CustomElement = ({ children }) => <div>{children}</div>;
-    const form = mount(<Formsy formElement={CustomElement} />);
-    expect(form.find(CustomElement).length).toBe(1);
+    const CustomElement = ({ children }) => <div data-testid="custom-element">{children}</div>;
+    const screen = render(<Formsy formElement={CustomElement} />);
+    const customElement = screen.getByTestId('custom-element');
+
+    expect(customElement.tagName.toLowerCase()).toBe('div');
   });
 });
diff --git a/__tests__/Rules-equals.spec.tsx b/__tests__/Rules-equals.spec.tsx
index 37fde553..a89ef4b0 100644
--- a/__tests__/Rules-equals.spec.tsx
+++ b/__tests__/Rules-equals.spec.tsx
@@ -1,29 +1,29 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('equals', () => {
-  it('should pass when the value is equal', () => {
-    expectIsValid(<ValidationForm validations="equals:foo" value="foo" />).toEqual(true);
+  it('should pass when the value is equal', async () => {
+    expect(await getValidState(<ValidationForm validations="equals:foo" value="foo" />)).toEqual(true);
   });
 
-  it('should fail when the value is not equal', () => {
-    expectIsValid(<ValidationForm validations="equals:foo" value="fo" />).toEqual(false);
+  it('should fail when the value is not equal', async () => {
+    expect(await getValidState(<ValidationForm validations="equals:foo" value="fo" />)).toEqual(false);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="equals:foo" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="equals:foo" value="" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="equals:foo" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="equals:foo" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="equals:foo" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="equals:foo" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="equals:foo" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="equals:foo" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-equalsField.spec.tsx b/__tests__/Rules-equalsField.spec.tsx
index d5ac1b52..1b7b3b1d 100644
--- a/__tests__/Rules-equalsField.spec.tsx
+++ b/__tests__/Rules-equalsField.spec.tsx
@@ -1,50 +1,54 @@
-import { mount } from 'enzyme';
 import React from 'react';
+import { getValidState } from '../__test_utils__/getValidState';
 import TestInput from '../__test_utils__/TestInput';
 
 import Formsy from '../src';
-import { WrapperInstanceMethods } from '../src/withFormsy';
 
 function ValidationForm(props: { validations: string; value?: any; other?: any }) {
   const { validations, value, other } = props;
 
   return (
     <Formsy>
-      <TestInput name="foo" validations={validations} value={value} />
+      <TestInput name="foo" validations={validations} value={value} testId="test-input" />
       <TestInput name="other" value={other} />
     </Formsy>
   );
 }
 
-export function expectIsValid(testForm: React.ComponentElement<any, any>) {
-  const form = mount(testForm);
-  const inputComponent = form.find('Formsy(TestInput)').first();
-  return expect(((inputComponent.instance() as unknown) as WrapperInstanceMethods<any>).isValid());
-}
-
 describe('equalsField', () => {
-  it('should pass when the value is equal', () => {
-    expectIsValid(<ValidationForm validations="equalsField:other" value="bar" other="bar" />).toEqual(true);
+  it('should pass when the value is equal', async () => {
+    expect(await getValidState(<ValidationForm validations="equalsField:other" value="bar" other="bar" />)).toEqual(
+      true,
+    );
+  });
+
+  it('should fail when the value is not equal', async () => {
+    expect(await getValidState(<ValidationForm validations="equalsField:other" value="bar" other="" />)).toEqual(false);
   });
 
-  it('should fail when the value is not equal', () => {
-    expectIsValid(<ValidationForm validations="equalsField:other" value="bar" other="" />).toEqual(false);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="equalsField:other" value="" other="" />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="equalsField:other" value="" other="" />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(
+      await getValidState(<ValidationForm validations="equalsField:other" value={undefined} other={undefined} />),
+    ).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="equalsField:other" value={undefined} other={undefined} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="equalsField:other" value={null} other={null} />)).toEqual(
+      true,
+    );
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="equalsField:other" value={null} other={null} />).toEqual(true);
+  it('should work with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="equalsField:other" value={42} other={42} />)).toEqual(true);
   });
 
-  it('should work with a number', () => {
-    expectIsValid(<ValidationForm validations="equalsField:other" value={42} other={42} />).toEqual(true);
-    expectIsValid(<ValidationForm validations="equalsField:other" value={42} other={10} />).toEqual(false);
+  it('should work with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="equalsField:other" value={42} other={10} />)).toEqual(
+      false,
+    );
   });
 });
diff --git a/__tests__/Rules-isAlpha.spec.tsx b/__tests__/Rules-isAlpha.spec.tsx
index 663da8f1..2c6ff5d5 100644
--- a/__tests__/Rules-isAlpha.spec.tsx
+++ b/__tests__/Rules-isAlpha.spec.tsx
@@ -1,33 +1,33 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isAlpha', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" />)).toEqual(true);
   });
 
-  it('should pass with a string is only latin letters', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" value="myValue" />).toEqual(true);
+  it('should pass with a string is only latin letters', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" value="myValue" />)).toEqual(true);
   });
 
-  it('should fail with a string with numbers', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" value="myValue42" />).toEqual(false);
+  it('should fail with a string with numbers', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" value="myValue42" />)).toEqual(false);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" value={null} />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" value="" />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isAlpha" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlpha" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isAlphanumeric.spec.tsx b/__tests__/Rules-isAlphanumeric.spec.tsx
index d81053ea..dfd3c1d2 100644
--- a/__tests__/Rules-isAlphanumeric.spec.tsx
+++ b/__tests__/Rules-isAlphanumeric.spec.tsx
@@ -1,37 +1,37 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isAlphanumeric', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" />)).toEqual(true);
   });
 
-  it('should pass with a string is only latin letters', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value="myValue" />).toEqual(true);
+  it('should pass with a string is only latin letters', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value="myValue" />)).toEqual(true);
   });
 
-  it('should fail with a string with numbers', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value="myValue42" />).toEqual(true);
+  it('should fail with a string with numbers', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value="myValue42" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value={null} />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value="" />)).toEqual(true);
   });
 
-  it('should pass with a number', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value={42} />).toEqual(true);
+  it('should pass with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value={42} />)).toEqual(true);
   });
 
-  it('should fail with a non alpha and number symbols', () => {
-    expectIsValid(<ValidationForm validations="isAlphanumeric" value="!@#$%^&*()" />).toEqual(false);
+  it('should fail with a non alpha and number symbols', async () => {
+    expect(await getValidState(<ValidationForm validations="isAlphanumeric" value="!@#$%^&*()" />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isEmail.spec.tsx b/__tests__/Rules-isEmail.spec.tsx
index a7d902e9..415067fe 100644
--- a/__tests__/Rules-isEmail.spec.tsx
+++ b/__tests__/Rules-isEmail.spec.tsx
@@ -1,37 +1,37 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isEmail', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isEmail" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" />)).toEqual(true);
   });
 
-  it('should fail with "foo"', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value="foo" />).toEqual(false);
+  it('should fail with "foo"', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value="foo" />)).toEqual(false);
   });
 
-  it('should pass with "foo@foo.com"', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value="foo@foo.com" />).toEqual(true);
+  it('should pass with "foo@foo.com"', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value="foo@foo.com" />)).toEqual(true);
   });
 
-  it('should pass with new long domains', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value="tickets@now.diamonds" />).toEqual(true);
+  it('should pass with new long domains', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value="tickets@now.diamonds" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value={null} />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value="" />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isEmail" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmail" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isEmptyString.spec.tsx b/__tests__/Rules-isEmptyString.spec.tsx
index d82330e0..144c9224 100644
--- a/__tests__/Rules-isEmptyString.spec.tsx
+++ b/__tests__/Rules-isEmptyString.spec.tsx
@@ -1,33 +1,33 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isEmptyString', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" />).toEqual(false);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" />)).toEqual(false);
   });
 
-  it('should fail with non-empty string', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" value="abc" />).toEqual(false);
+  it('should fail with non-empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" value="abc" />)).toEqual(false);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" value="" />)).toEqual(true);
   });
 
-  it('should fail with undefined', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" value={undefined} />).toEqual(false);
+  it('should fail with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" value={undefined} />)).toEqual(false);
   });
 
-  it('should fail with null', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" value={null} />).toEqual(false);
+  it('should fail with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" value={null} />)).toEqual(false);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" value={42} />)).toEqual(false);
   });
 
-  it('should fail with a zero', () => {
-    expectIsValid(<ValidationForm validations="isEmptyString" value={0} />).toEqual(false);
+  it('should fail with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isEmptyString" value={0} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isExisty.spec.tsx b/__tests__/Rules-isExisty.spec.tsx
index 2debcb0f..2651cf50 100644
--- a/__tests__/Rules-isExisty.spec.tsx
+++ b/__tests__/Rules-isExisty.spec.tsx
@@ -1,33 +1,33 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isExisty', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isExisty" />).toEqual(false);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" />)).toEqual(false);
   });
 
-  it('should pass with a string', () => {
-    expectIsValid(<ValidationForm validations="isExisty" value="abc" />).toEqual(true);
+  it('should pass with a string', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" value="abc" />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isExisty" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" value="" />)).toEqual(true);
   });
 
-  it('should fail with undefined', () => {
-    expectIsValid(<ValidationForm validations="isExisty" value={undefined} />).toEqual(false);
+  it('should fail with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" value={undefined} />)).toEqual(false);
   });
 
-  it('should fail with null', () => {
-    expectIsValid(<ValidationForm validations="isExisty" value={null} />).toEqual(false);
+  it('should fail with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" value={null} />)).toEqual(false);
   });
 
-  it('should pass with a number', () => {
-    expectIsValid(<ValidationForm validations="isExisty" value={42} />).toEqual(true);
+  it('should pass with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" value={42} />)).toEqual(true);
   });
 
-  it('should pass with a zero', () => {
-    expectIsValid(<ValidationForm validations="isExisty" value={0} />).toEqual(true);
+  it('should pass with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isExisty" value={0} />)).toEqual(true);
   });
 });
diff --git a/__tests__/Rules-isFalse.spec.tsx b/__tests__/Rules-isFalse.spec.tsx
index 9c7f2d94..bf105043 100644
--- a/__tests__/Rules-isFalse.spec.tsx
+++ b/__tests__/Rules-isFalse.spec.tsx
@@ -1,41 +1,41 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isFalse', () => {
-  it('should fail with a default value', () => {
-    expectIsValid(<ValidationForm validations="isFalse" />).toEqual(false);
+  it('should fail with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" />)).toEqual(false);
   });
 
-  it('should fail with boolean false', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value={false} />).toEqual(true);
+  it('should fail with boolean false', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value={false} />)).toEqual(true);
   });
 
-  it('should pass with boolean true', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value={true} />).toEqual(false);
+  it('should pass with boolean true', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value={true} />)).toEqual(false);
   });
 
-  it('should fail with a string', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value="abc" />).toEqual(false);
+  it('should fail with a string', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value="abc" />)).toEqual(false);
   });
 
-  it('should fail with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value="" />).toEqual(false);
+  it('should fail with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value="" />)).toEqual(false);
   });
 
-  it('should fail with undefined', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value={undefined} />).toEqual(false);
+  it('should fail with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value={undefined} />)).toEqual(false);
   });
 
-  it('should fail with null', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value={null} />).toEqual(false);
+  it('should fail with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value={null} />)).toEqual(false);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value={42} />)).toEqual(false);
   });
 
-  it('should fail with a zero', () => {
-    expectIsValid(<ValidationForm validations="isFalse" value={0} />).toEqual(false);
+  it('should fail with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isFalse" value={0} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isFloat.spec.tsx b/__tests__/Rules-isFloat.spec.tsx
index df99cd8c..a6e57ccd 100644
--- a/__tests__/Rules-isFloat.spec.tsx
+++ b/__tests__/Rules-isFloat.spec.tsx
@@ -1,49 +1,49 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isFloat', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isFloat" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value="" />)).toEqual(true);
   });
 
-  it('should fail with a string', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value="abc" />).toEqual(false);
+  it('should fail with a string', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value="abc" />)).toEqual(false);
   });
 
-  it('should pass with a number as string', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value="+42" />).toEqual(true);
+  it('should pass with a number as string', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value="+42" />)).toEqual(true);
   });
 
-  it('should fail string with digits', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value="42 is an answer" />).toEqual(false);
+  it('should fail string with digits', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value="42 is an answer" />)).toEqual(false);
   });
 
-  it('should pass with an int', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value={42} />).toEqual(true);
+  it('should pass with an int', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value={42} />)).toEqual(true);
   });
 
-  it('should pass with a float', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value={Math.PI} />).toEqual(true);
+  it('should pass with a float', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value={Math.PI} />)).toEqual(true);
   });
 
-  it('should pass with a float in science notation', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value="-1e3" />).toEqual(true);
+  it('should pass with a float in science notation', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value="-1e3" />)).toEqual(true);
   });
 
-  it('should pass with undefined', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value={undefined} />).toEqual(true);
+  it('should pass with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with null', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value={null} />).toEqual(true);
+  it('should pass with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value={null} />)).toEqual(true);
   });
 
-  it('should pass with a zero', () => {
-    expectIsValid(<ValidationForm validations="isFloat" value={0} />).toEqual(true);
+  it('should pass with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isFloat" value={0} />)).toEqual(true);
   });
 });
diff --git a/__tests__/Rules-isInt.spec.tsx b/__tests__/Rules-isInt.spec.tsx
index 51948418..0583240e 100644
--- a/__tests__/Rules-isInt.spec.tsx
+++ b/__tests__/Rules-isInt.spec.tsx
@@ -1,49 +1,49 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isInt', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isInt" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isInt" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value="" />)).toEqual(true);
   });
 
-  it('should fail with a string', () => {
-    expectIsValid(<ValidationForm validations="isInt" value="abc" />).toEqual(false);
+  it('should fail with a string', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value="abc" />)).toEqual(false);
   });
 
-  it('should pass with a number as string', () => {
-    expectIsValid(<ValidationForm validations="isInt" value="+42" />).toEqual(true);
+  it('should pass with a number as string', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value="+42" />)).toEqual(true);
   });
 
-  it('should fail string with digits', () => {
-    expectIsValid(<ValidationForm validations="isInt" value="42 is an answer" />).toEqual(false);
+  it('should fail string with digits', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value="42 is an answer" />)).toEqual(false);
   });
 
-  it('should pass with an int', () => {
-    expectIsValid(<ValidationForm validations="isInt" value={42} />).toEqual(true);
+  it('should pass with an int', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value={42} />)).toEqual(true);
   });
 
-  it('should fail with a float', () => {
-    expectIsValid(<ValidationForm validations="isInt" value={Math.PI} />).toEqual(false);
+  it('should fail with a float', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value={Math.PI} />)).toEqual(false);
   });
 
-  it('should fail with a float in science notation', () => {
-    expectIsValid(<ValidationForm validations="isInt" value="-1e3" />).toEqual(false);
+  it('should fail with a float in science notation', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value="-1e3" />)).toEqual(false);
   });
 
-  it('should pass with undefined', () => {
-    expectIsValid(<ValidationForm validations="isInt" value={undefined} />).toEqual(true);
+  it('should pass with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with null', () => {
-    expectIsValid(<ValidationForm validations="isInt" value={null} />).toEqual(true);
+  it('should pass with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value={null} />)).toEqual(true);
   });
 
-  it('should pass with a zero', () => {
-    expectIsValid(<ValidationForm validations="isInt" value={0} />).toEqual(true);
+  it('should pass with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isInt" value={0} />)).toEqual(true);
   });
 });
diff --git a/__tests__/Rules-isLength.spec.tsx b/__tests__/Rules-isLength.spec.tsx
index 9ea89e1e..d7670480 100644
--- a/__tests__/Rules-isLength.spec.tsx
+++ b/__tests__/Rules-isLength.spec.tsx
@@ -1,71 +1,71 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isLength:3', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" />)).toEqual(true);
   });
 
-  it('should fail with a string too small', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value="hi" />).toEqual(false);
+  it('should fail with a string too small', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value="hi" />)).toEqual(false);
   });
 
-  it('should fail with a string too long', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value="hi ho happ" />).toEqual(false);
+  it('should fail with a string too long', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value="hi ho happ" />)).toEqual(false);
   });
 
-  it('should pass with matching length', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value="foo" />).toEqual(true);
+  it('should pass with matching length', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value="foo" />)).toEqual(true);
   });
 
-  it('should pass with undefined', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value={undefined} />).toEqual(true);
+  it('should pass with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with null', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value={null} />).toEqual(true);
+  it('should pass with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value={null} />)).toEqual(true);
   });
 
-  it('should pass with empty string', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value="" />).toEqual(true);
+  it('should pass with empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value="" />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isLength:3" value={123} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:3" value={123} />)).toEqual(false);
   });
 });
 
 describe('isLength:0', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" />)).toEqual(true);
   });
 
-  it('should fail with a string too small', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value="hi" />).toEqual(false);
+  it('should fail with a string too small', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value="hi" />)).toEqual(false);
   });
 
-  it('should fail with a string too long', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value="hi ho happ" />).toEqual(false);
+  it('should fail with a string too long', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value="hi ho happ" />)).toEqual(false);
   });
 
-  it('should pass with matching length', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value="" />).toEqual(true);
+  it('should pass with matching length', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value="" />)).toEqual(true);
   });
 
-  it('should pass with undefined', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value={undefined} />).toEqual(true);
+  it('should pass with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with null', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value={null} />).toEqual(true);
+  it('should pass with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value={null} />)).toEqual(true);
   });
 
-  it('should pass with empty string', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value="" />).toEqual(true);
+  it('should pass with empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value="" />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isLength:0" value={123} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isLength:0" value={123} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isNumeric.spec.tsx b/__tests__/Rules-isNumeric.spec.tsx
index ddf0d004..ec2a420a 100644
--- a/__tests__/Rules-isNumeric.spec.tsx
+++ b/__tests__/Rules-isNumeric.spec.tsx
@@ -1,49 +1,49 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isNumeric', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" />)).toEqual(true);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value="" />)).toEqual(true);
   });
 
-  it('should fail with an unempty string', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value="foo" />).toEqual(false);
+  it('should fail with an unempty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value="foo" />)).toEqual(false);
   });
 
-  it('should pass with a number as string', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value="+42" />).toEqual(true);
+  it('should pass with a number as string', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value="+42" />)).toEqual(true);
   });
 
-  it('should fail with a number as string with not digits', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value="42 is an answer" />).toEqual(false);
+  it('should fail with a number as string with not digits', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value="42 is an answer" />)).toEqual(false);
   });
 
-  it('should pass with an int', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value={42} />).toEqual(true);
+  it('should pass with an int', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value={42} />)).toEqual(true);
   });
 
-  it('should pass with a float', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value={Math.PI} />).toEqual(true);
+  it('should pass with a float', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value={Math.PI} />)).toEqual(true);
   });
 
-  it('should fail with a float in science notation', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value="-1e3" />).toEqual(false);
+  it('should fail with a float in science notation', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value="-1e3" />)).toEqual(false);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value={null} />)).toEqual(true);
   });
 
-  it('should pass with a zero', () => {
-    expectIsValid(<ValidationForm validations="isNumeric" value={0} />).toEqual(true);
+  it('should pass with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isNumeric" value={0} />)).toEqual(true);
   });
 });
diff --git a/__tests__/Rules-isSpecialWords.spec.tsx b/__tests__/Rules-isSpecialWords.spec.tsx
index bc57fda6..e48b5467 100644
--- a/__tests__/Rules-isSpecialWords.spec.tsx
+++ b/__tests__/Rules-isSpecialWords.spec.tsx
@@ -1,39 +1,39 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isSpecialWords', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" />)).toEqual(true);
   });
 
-  it('should pass with a 1 word', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value="sup" />).toEqual(true);
+  it('should pass with a 1 word', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" value="sup" />)).toEqual(true);
   });
 
-  it('should pass with 2 words', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value="sup dude" />).toEqual(true);
+  it('should pass with 2 words', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" value="sup dude" />)).toEqual(true);
   });
 
-  it('should pass with special charachters', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value="including special letters az ú ø æ å" />).toEqual(
-      true,
-    );
+  it('should pass with special charachters', async () => {
+    expect(
+      await getValidState(<ValidationForm validations="isSpecialWords" value="including special letters az ú ø æ å" />),
+    ).toEqual(true);
   });
 
-  it('should fail with a string with numbers', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value="sup 42" />).toEqual(false);
+  it('should fail with a string with numbers', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" value="sup 42" />)).toEqual(false);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isSpecialWords" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isSpecialWords" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isTrue.spec.tsx b/__tests__/Rules-isTrue.spec.tsx
index 1a04e14a..fd7c0015 100644
--- a/__tests__/Rules-isTrue.spec.tsx
+++ b/__tests__/Rules-isTrue.spec.tsx
@@ -1,41 +1,41 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isTrue', () => {
-  it('should fail with a default value', () => {
-    expectIsValid(<ValidationForm validations="isTrue" />).toEqual(false);
+  it('should fail with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" />)).toEqual(false);
   });
 
-  it('should fail with boolean false', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value={false} />).toEqual(false);
+  it('should fail with boolean false', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value={false} />)).toEqual(false);
   });
 
-  it('should pass with boolean true', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value={true} />).toEqual(true);
+  it('should pass with boolean true', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value={true} />)).toEqual(true);
   });
 
-  it('should fail with a string', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value="abc" />).toEqual(false);
+  it('should fail with a string', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value="abc" />)).toEqual(false);
   });
 
-  it('should fail with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value="" />).toEqual(false);
+  it('should fail with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value="" />)).toEqual(false);
   });
 
-  it('should fail with undefined', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value={undefined} />).toEqual(false);
+  it('should fail with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value={undefined} />)).toEqual(false);
   });
 
-  it('should fail with null', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value={null} />).toEqual(false);
+  it('should fail with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value={null} />)).toEqual(false);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value={42} />)).toEqual(false);
   });
 
-  it('should fail with a zero', () => {
-    expectIsValid(<ValidationForm validations="isTrue" value={0} />).toEqual(false);
+  it('should fail with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isTrue" value={0} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isUndefined.spec.tsx b/__tests__/Rules-isUndefined.spec.tsx
index c989ce4d..09686f7e 100644
--- a/__tests__/Rules-isUndefined.spec.tsx
+++ b/__tests__/Rules-isUndefined.spec.tsx
@@ -1,33 +1,33 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isUndefined', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" />)).toEqual(true);
   });
 
-  it('should fail with a string', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" value="abc" />).toEqual(false);
+  it('should fail with a string', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" value="abc" />)).toEqual(false);
   });
 
-  it('should fail with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" value="" />).toEqual(false);
+  it('should fail with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" value="" />)).toEqual(false);
   });
 
-  it('should pass with undefined', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" value={undefined} />).toEqual(true);
+  it('should pass with undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" value={undefined} />)).toEqual(true);
   });
 
-  it('should fail with null', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" value={null} />).toEqual(false);
+  it('should fail with null', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" value={null} />)).toEqual(false);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" value={42} />)).toEqual(false);
   });
 
-  it('should fail with a zero', () => {
-    expectIsValid(<ValidationForm validations="isUndefined" value={0} />).toEqual(false);
+  it('should fail with a zero', async () => {
+    expect(await getValidState(<ValidationForm validations="isUndefined" value={0} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-isUrl.spec.tsx b/__tests__/Rules-isUrl.spec.tsx
index da3838bf..8c7da939 100644
--- a/__tests__/Rules-isUrl.spec.tsx
+++ b/__tests__/Rules-isUrl.spec.tsx
@@ -1,33 +1,33 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isUrl', () => {
-  it('should pass with default value', () => {
-    expectIsValid(<ValidationForm validations="isUrl" />).toEqual(true);
+  it('should pass with default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" />)).toEqual(true);
   });
 
-  it('should fail with "foo"', () => {
-    expectIsValid(<ValidationForm validations="isUrl" value="foo" />).toEqual(false);
+  it('should fail with "foo"', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" value="foo" />)).toEqual(false);
   });
 
-  it('should pass with "https://www.google.com/"', () => {
-    expectIsValid(<ValidationForm validations="isUrl" value="https://www.google.com/" />).toEqual(true);
+  it('should pass with "https://www.google.com/"', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" value="https://www.google.com/" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isUrl" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isUrl" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isUrl" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" value={42} />)).toEqual(false);
   });
 
-  it('should pass with an empty string', () => {
-    expectIsValid(<ValidationForm validations="isUrl" value="" />).toEqual(true);
+  it('should pass with an empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="isUrl" value="" />)).toEqual(true);
   });
 });
diff --git a/__tests__/Rules-isWords.spec.tsx b/__tests__/Rules-isWords.spec.tsx
index 7c3553b0..0b4d87b0 100644
--- a/__tests__/Rules-isWords.spec.tsx
+++ b/__tests__/Rules-isWords.spec.tsx
@@ -1,37 +1,39 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('isWords', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="isWords" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" />)).toEqual(true);
   });
 
-  it('should pass with a 1 word', () => {
-    expectIsValid(<ValidationForm validations="isWords" value="sup" />).toEqual(true);
+  it('should pass with a 1 word', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" value="sup" />)).toEqual(true);
   });
 
-  it('should pass with 2 words', () => {
-    expectIsValid(<ValidationForm validations="isWords" value="sup dude" />).toEqual(true);
+  it('should pass with 2 words', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" value="sup dude" />)).toEqual(true);
   });
 
-  it('should fail with special charachters', () => {
-    expectIsValid(<ValidationForm validations="isWords" value="including special letters à ú ø æ å" />).toEqual(false);
+  it('should fail with special charachters', async () => {
+    expect(
+      await getValidState(<ValidationForm validations="isWords" value="including special letters à ú ø æ å" />),
+    ).toEqual(false);
   });
 
-  it('should fail with a string with numbers', () => {
-    expectIsValid(<ValidationForm validations="isWords" value="sup 42" />).toEqual(false);
+  it('should fail with a string with numbers', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" value="sup 42" />)).toEqual(false);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="isWords" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="isWords" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="isWords" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="isWords" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-maxLength.spec.tsx b/__tests__/Rules-maxLength.spec.tsx
index 94bde0d4..67babc12 100644
--- a/__tests__/Rules-maxLength.spec.tsx
+++ b/__tests__/Rules-maxLength.spec.tsx
@@ -1,37 +1,37 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('maxLength', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" />)).toEqual(true);
   });
 
-  it("should pass when a string's length is smaller", () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value="hi" />).toEqual(true);
+  it("should pass when a string's length is smaller", async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value="hi" />)).toEqual(true);
   });
 
-  it("should pass when a string's length is equal", () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value="bar" />).toEqual(true);
+  it("should pass when a string's length is equal", async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value="bar" />)).toEqual(true);
   });
 
-  it("should fail when a string's length is bigger", () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value="foobar" />).toEqual(false);
+  it("should fail when a string's length is bigger", async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value="foobar" />)).toEqual(false);
   });
 
-  it('should pass with empty string', () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value="" />).toEqual(true);
+  it('should pass with empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value="" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="maxLength:3" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="maxLength:3" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Rules-minLength.spec.tsx b/__tests__/Rules-minLength.spec.tsx
index 8ea98014..478ff47f 100644
--- a/__tests__/Rules-minLength.spec.tsx
+++ b/__tests__/Rules-minLength.spec.tsx
@@ -1,59 +1,59 @@
 import React from 'react';
 
-import ValidationForm, { expectIsValid } from '../__test_utils__/expectIsValid';
+import ValidationForm, { getValidState } from '../__test_utils__/getValidState';
 
 describe('minLength:3', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="minLength:3" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" />)).toEqual(true);
   });
 
-  it("should pass when a string's length is bigger", () => {
-    expectIsValid(<ValidationForm validations="minLength:3" value="myValue" />).toEqual(true);
+  it("should pass when a string's length is bigger", async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" value="myValue" />)).toEqual(true);
   });
 
-  it("should fail when a string's length is smaller", () => {
-    expectIsValid(<ValidationForm validations="minLength:3" value="my" />).toEqual(false);
+  it("should fail when a string's length is smaller", async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" value="my" />)).toEqual(false);
   });
 
-  it('should pass with empty string', () => {
-    expectIsValid(<ValidationForm validations="minLength:3" value="" />).toEqual(true);
+  it('should pass with empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" value="" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="minLength:3" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="minLength:3" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="minLength:3" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:3" value={42} />)).toEqual(false);
   });
 });
 
 describe('minLength:0', () => {
-  it('should pass with a default value', () => {
-    expectIsValid(<ValidationForm validations="minLength:0" />).toEqual(true);
+  it('should pass with a default value', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:0" />)).toEqual(true);
   });
 
-  it("should pass when a string's length is bigger", () => {
-    expectIsValid(<ValidationForm validations="minLength:0" value="myValue" />).toEqual(true);
+  it("should pass when a string's length is bigger", async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:0" value="myValue" />)).toEqual(true);
   });
 
-  it('should pass with empty string', () => {
-    expectIsValid(<ValidationForm validations="minLength:0" value="" />).toEqual(true);
+  it('should pass with empty string', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:0" value="" />)).toEqual(true);
   });
 
-  it('should pass with an undefined', () => {
-    expectIsValid(<ValidationForm validations="minLength:0" value={undefined} />).toEqual(true);
+  it('should pass with an undefined', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:0" value={undefined} />)).toEqual(true);
   });
 
-  it('should pass with a null', () => {
-    expectIsValid(<ValidationForm validations="minLength:0" value={null} />).toEqual(true);
+  it('should pass with a null', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:0" value={null} />)).toEqual(true);
   });
 
-  it('should fail with a number', () => {
-    expectIsValid(<ValidationForm validations="minLength:0" value={42} />).toEqual(false);
+  it('should fail with a number', async () => {
+    expect(await getValidState(<ValidationForm validations="minLength:0" value={42} />)).toEqual(false);
   });
 });
diff --git a/__tests__/Utils.spec.tsx b/__tests__/Utils.spec.tsx
index db936384..c87609d7 100644
--- a/__tests__/Utils.spec.tsx
+++ b/__tests__/Utils.spec.tsx
@@ -65,9 +65,17 @@ describe('Utils', () => {
       success: [],
     });
 
-    expect(utils.runRules('', {}, { rule: () => true }, {})).toEqual({ errors: [], failed: [], success: ['rule'] });
+    expect(utils.runRules('', {}, { rule: () => true }, {})).toEqual({
+      errors: [],
+      failed: [],
+      success: ['rule'],
+    });
 
-    expect(utils.runRules('', {}, { rule: () => false }, {})).toEqual({ errors: [], failed: ['rule'], success: [] });
+    expect(utils.runRules('', {}, { rule: () => false }, {})).toEqual({
+      errors: [],
+      failed: ['rule'],
+      success: [],
+    });
     expect(utils.runRules('', {}, { rule: true }, { rule: () => false })).toEqual({
       errors: [],
       failed: ['rule'],
diff --git a/__tests__/Validation.spec.tsx b/__tests__/Validation.spec.tsx
index 1ff9a01c..cdc3a5c7 100644
--- a/__tests__/Validation.spec.tsx
+++ b/__tests__/Validation.spec.tsx
@@ -1,13 +1,13 @@
-import { mount } from 'enzyme';
+import { fireEvent, render } from '@testing-library/react';
 import React from 'react';
-import { getFormInstance, getWrapperInstance } from '../__test_utils__/getInput';
-import immediate from '../__test_utils__/immediate';
 import { InputFactory } from '../__test_utils__/TestInput';
 
 import Formsy, { withFormsy } from '../src';
 import { PassDownProps } from '../src/withFormsy';
 
-class MyTest extends React.Component<{ type?: string } & PassDownProps<string>> {
+type MyTestProps = { type?: string; testId?: string };
+
+class MyTest extends React.Component<MyTestProps & PassDownProps<string>> {
   public static defaultProps = { type: 'text' };
 
   handleChange = (event) => {
@@ -16,61 +16,69 @@ class MyTest extends React.Component<{ type?: string } & PassDownProps<string>>
   };
 
   render() {
-    const { type, value } = this.props;
-    return <input type={type} value={value || ''} onChange={this.handleChange} />;
+    const { type, value, testId, errorMessage, isValid } = this.props;
+    return (
+      <input
+        type={type}
+        value={value || ''}
+        onChange={this.handleChange}
+        data-is-valid={isValid}
+        data-error-message={errorMessage}
+        data-testid={testId}
+      />
+    );
   }
 }
 
-const FormsyTest = withFormsy<{ type?: string }, string>(MyTest);
+const FormsyTest = withFormsy<MyTestProps, string>(MyTest);
 
 describe('Validation', () => {
   it('should reset only changed form element when external error is passed', () => {
-    const form = mount(
-      <Formsy onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar', bar: 'foo' })}>
-        <FormsyTest name="foo" />
-        <FormsyTest name="bar" />
+    const screen = render(
+      <Formsy onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar', bar: 'foo' })} data-testid="form">
+        <FormsyTest name="foo" testId="test-input1" />
+        <FormsyTest name="bar" testId="test-input2" />
       </Formsy>,
     );
 
-    const input = form.find('input').at(0);
-    const inputComponents = form.find('Formsy(MyTest)');
+    const form = screen.getByTestId('form');
+    const input1 = screen.getByTestId('test-input1');
+    const input2 = screen.getByTestId('test-input2');
 
-    getFormInstance(form).submit();
-    expect(getWrapperInstance(inputComponents.at(0)).isValid()).toEqual(false);
-    expect(getWrapperInstance(inputComponents.at(1)).isValid()).toEqual(false);
+    fireEvent.submit(form);
 
-    input.simulate('change', { target: { value: 'bar' } });
-    immediate(() => {
-      expect(getWrapperInstance(inputComponents.at(0)).isValid()).toEqual(true);
-      expect(getWrapperInstance(inputComponents).isValid()).toEqual(false);
-    });
+    expect(input1.dataset.isValid).toEqual('false');
+    expect(input2.dataset.isValid).toEqual('false');
+
+    fireEvent.change(input1, { target: { value: 'bar' } });
+
+    expect(input1.dataset.isValid).toEqual('true');
   });
 
   it('should let normal validation take over when component with external error is changed', () => {
-    const form = mount(
-      <Formsy onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })}>
-        <FormsyTest name="foo" validations="isEmail" />
+    const screen = render(
+      <Formsy onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })} data-testid="form">
+        <FormsyTest name="foo" validations="isEmail" testId="test-input" />
       </Formsy>,
     );
 
-    const input = form.find('input');
-    const inputComponent = form.find('Formsy(MyTest)');
+    const form = screen.getByTestId('form');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
 
-    getFormInstance(form).submit();
-    expect(getWrapperInstance(inputComponent).isValid()).toEqual(false);
+    fireEvent.submit(form);
+    expect(input.dataset.isValid).toEqual('false');
 
-    input.simulate('change', { target: { value: 'bar' } });
-    immediate(() => {
-      expect(getWrapperInstance(inputComponent).getValue()).toEqual('bar');
-      expect(getWrapperInstance(inputComponent).isValid()).toEqual(false);
-    });
+    fireEvent.change(input, { target: { value: 'bar' } });
+
+    expect(input.value).toEqual('bar');
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should trigger an onValid handler, if passed, when form is valid', () => {
     const onValid = jest.fn();
     const onInvalid = jest.fn();
 
-    mount(
+    render(
       <Formsy onValid={onValid} onInvalid={onInvalid}>
         <FormsyTest name="foo" value="bar" required />
       </Formsy>,
@@ -84,7 +92,7 @@ describe('Validation', () => {
     const onValid = jest.fn();
     const onInvalid = jest.fn();
 
-    mount(
+    render(
       <Formsy onValid={onValid} onInvalid={onInvalid}>
         <FormsyTest name="foo" required />
       </Formsy>,
@@ -98,7 +106,7 @@ describe('Validation', () => {
     const onValid = jest.fn();
     const onInvalid = jest.fn();
 
-    mount(
+    render(
       <Formsy onValid={onValid} onInvalid={onInvalid}>
         <FormsyTest value={null} name="foo" required />
       </Formsy>,
@@ -115,7 +123,8 @@ describe('Validation', () => {
         isValid = this.props.isValid;
       },
     });
-    mount(
+
+    render(
       <Formsy>
         <CustomInput name="foo" value="foo" required />
       </Formsy>,
@@ -127,66 +136,77 @@ describe('Validation', () => {
   it('should provide invalidate callback on onValidSubmit', () => {
     function TestForm() {
       return (
-        <Formsy onValidSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })}>
-          <FormsyTest name="foo" value="foo" />
+        <Formsy onValidSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })} data-testid="form">
+          <FormsyTest name="foo" value="foo" testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
+    const screen = render(<TestForm />);
 
-    const formEl = form.find('form');
-    const input = form.find('Formsy(MyTest)');
-    formEl.simulate('submit');
-    expect(getWrapperInstance(input).isValid()).toEqual(false);
+    const form = screen.getByTestId('form');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+
+    fireEvent.submit(form);
+
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should provide invalidate callback on onInvalidSubmit', () => {
     function TestForm() {
       return (
-        <Formsy onInvalidSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })}>
-          <FormsyTest name="foo" value="foo" validations="isEmail" />
+        <Formsy onInvalidSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })} data-testid="form">
+          <FormsyTest name="foo" value="foo" validations="isEmail" testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const formEl = form.find('form');
-    const input = form.find('Formsy(MyTest)');
-    formEl.simulate('submit');
-    expect(getWrapperInstance(input).getErrorMessage()).toEqual('bar');
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+
+    fireEvent.submit(form);
+
+    expect(input.dataset.errorMessage).toEqual('bar');
   });
 
   it('should not invalidate inputs on external errors with preventExternalInvalidation prop', () => {
     function TestForm() {
       return (
-        <Formsy preventExternalInvalidation onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })}>
-          <FormsyTest name="foo" value="foo" />
+        <Formsy
+          preventExternalInvalidation
+          onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })}
+          data-testid="form"
+        >
+          <FormsyTest name="foo" value="foo" testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const formEl = form.find('form');
-    const input = form.find('Formsy(MyTest)');
-    formEl.simulate('submit');
-    expect(getWrapperInstance(input).isValid()).toEqual(true);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+
+    fireEvent.submit(form);
+
+    expect(input.dataset.isValid).toEqual('true');
   });
 
   it('should invalidate inputs on external errors without preventExternalInvalidation prop', () => {
     function TestForm() {
       return (
-        <Formsy onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })}>
-          <FormsyTest name="foo" value="foo" />
+        <Formsy onSubmit={(_model, _reset, invalidate) => invalidate({ foo: 'bar' })} data-testid="form">
+          <FormsyTest name="foo" value="foo" testId="test-input" />
         </Formsy>
       );
     }
 
-    const form = mount(<TestForm />);
-    const formEl = form.find('form');
-    const input = form.find('Formsy(MyTest)');
-    formEl.simulate('submit');
-    expect(getWrapperInstance(input).isValid()).toEqual(false);
+    const screen = render(<TestForm />);
+    const form = screen.getByTestId('form');
+    const input = screen.getByTestId('test-input') as HTMLInputElement;
+    fireEvent.submit(form);
+
+    expect(input.dataset.isValid).toEqual('false');
   });
 
   it('should throw errors on invalid validation string', () => {
@@ -203,7 +223,7 @@ describe('Validation', () => {
       );
     }
 
-    expect(() => mount(<TestForm />)).toThrow(
+    expect(() => render(<TestForm />)).toThrow(
       'Formsy does not support multiple args on string validations. Use object format of validations instead.',
     );
 
@@ -224,7 +244,7 @@ describe('Validation', () => {
       );
     }
 
-    expect(() => mount(<TestForm />)).toThrow('Form Input requires a name property when used');
+    expect(() => render(<TestForm />)).toThrow('Form Input requires a name property when used');
 
     mockConsoleError.mockRestore();
   });
diff --git a/package.json b/package.json
index 9ebfcd67..87ed2a4f 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,8 @@
     "prop-types": "^15.8.1"
   },
   "devDependencies": {
-    "@types/enzyme": "^3.10.3",
+    "@testing-library/jest-dom": "^5.16.4",
+    "@testing-library/react": "^12.1.5",
     "@types/jest": "^26.0.13",
     "@types/lodash": "^4.14.168",
     "@types/prop-types": "^15.7.1",
@@ -53,8 +54,6 @@
     "@types/react-dom": "^17.0.0",
     "auto-changelog": "^2.4.0",
     "coveralls": "^3.1.1",
-    "enzyme": "^3.11.0",
-    "enzyme-adapter-react-16": "^1.15.6",
     "eslint-plugin-prettier": "^3.4.1",
     "husky": "^4.2.1",
     "np": "^5.0.0",
@@ -91,9 +90,6 @@
     "collectCoverageFrom": [
       "src/**/*.tsx",
       "src/**/*.ts"
-    ],
-    "setupFilesAfterEnv": [
-      "./setupTests.ts"
     ]
   }
 }
diff --git a/setupTests.ts b/setupTests.ts
deleted file mode 100644
index 32a0790c..00000000
--- a/setupTests.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-import enzyme from 'enzyme';
-import Adapter from 'enzyme-adapter-react-16';
-
-enzyme.configure({ adapter: new Adapter() });
diff --git a/yarn.lock b/yarn.lock
index df570ce4..6ddea74a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -817,6 +817,13 @@
   dependencies:
     regenerator-runtime "^0.13.4"
 
+"@babel/runtime@^7.12.5", "@babel/runtime@^7.9.2":
+  version "7.18.9"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.18.9.tgz#b4fcfce55db3d2e5e080d2490f608a3b9f407f4a"
+  integrity sha512-lkqXDcvlFT5rvEjiu6+QYO+1GXrEHRo2LOtS7E4GtX5ESIZOgepqsZBVIj6Pv+a6zqsya9VCgiK1KAK4BvJDAw==
+  dependencies:
+    regenerator-runtime "^0.13.4"
+
 "@babel/template@^7.10.4", "@babel/template@^7.12.7", "@babel/template@^7.3.3":
   version "7.12.7"
   resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.12.7.tgz#c817233696018e39fbb6c491d2fb684e05ed43bc"
@@ -985,6 +992,13 @@
   optionalDependencies:
     node-notifier "^6.0.0"
 
+"@jest/schemas@^28.1.3":
+  version "28.1.3"
+  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-28.1.3.tgz#ad8b86a66f11f33619e3d7e1dcddd7f2d40ff905"
+  integrity sha512-/l/VWsdt/aBXgjshLWOFyFt3IVdYypu5y2Wn2rOO1un6nkqIn8SLXzgIMYXFyYsRWDyF5EthmKJMIdJvk08grg==
+  dependencies:
+    "@sinclair/typebox" "^0.24.1"
+
 "@jest/source-map@^25.5.0":
   version "25.5.0"
   resolved "https://registry.yarnpkg.com/@jest/source-map/-/source-map-25.5.0.tgz#df5c20d6050aa292c2c6d3f0d2c7606af315bd1b"
@@ -1122,6 +1136,11 @@
   dependencies:
     any-observable "^0.3.0"
 
+"@sinclair/typebox@^0.24.1":
+  version "0.24.20"
+  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.24.20.tgz#11a657875de6008622d53f56e063a6347c51a6dd"
+  integrity sha512-kVaO5aEFZb33nPMTZBxiPEkY+slxiPtqC7QX8f9B3eGOMBvEfuMfxp9DSTTCsRJPumPKjrge4yagyssO4q6qzQ==
+
 "@sindresorhus/is@^0.14.0":
   version "0.14.0"
   resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.14.0.tgz#9fb3a3cf3132328151f353de4632e01e52102bea"
@@ -1141,6 +1160,49 @@
   dependencies:
     defer-to-connect "^1.0.1"
 
+"@testing-library/dom@^8.0.0":
+  version "8.16.0"
+  resolved "https://registry.yarnpkg.com/@testing-library/dom/-/dom-8.16.0.tgz#d6fc50250aed17b1035ca1bd64655e342db3936a"
+  integrity sha512-uxF4zmnLHHDlmW4l+0WDjcgLVwCvH+OVLpD8Dfp+Bjfz85prwxWGbwXgJdLtkgjD0qfOzkJF9SmA6YZPsMYX4w==
+  dependencies:
+    "@babel/code-frame" "^7.10.4"
+    "@babel/runtime" "^7.12.5"
+    "@types/aria-query" "^4.2.0"
+    aria-query "^5.0.0"
+    chalk "^4.1.0"
+    dom-accessibility-api "^0.5.9"
+    lz-string "^1.4.4"
+    pretty-format "^27.0.2"
+
+"@testing-library/jest-dom@^5.16.4":
+  version "5.16.4"
+  resolved "https://registry.yarnpkg.com/@testing-library/jest-dom/-/jest-dom-5.16.4.tgz#938302d7b8b483963a3ae821f1c0808f872245cd"
+  integrity sha512-Gy+IoFutbMQcky0k+bqqumXZ1cTGswLsFqmNLzNdSKkU9KGV2u9oXhukCbbJ9/LRPKiqwxEE8VpV/+YZlfkPUA==
+  dependencies:
+    "@babel/runtime" "^7.9.2"
+    "@types/testing-library__jest-dom" "^5.9.1"
+    aria-query "^5.0.0"
+    chalk "^3.0.0"
+    css "^3.0.0"
+    css.escape "^1.5.1"
+    dom-accessibility-api "^0.5.6"
+    lodash "^4.17.15"
+    redent "^3.0.0"
+
+"@testing-library/react@^12.1.5":
+  version "12.1.5"
+  resolved "https://registry.yarnpkg.com/@testing-library/react/-/react-12.1.5.tgz#bb248f72f02a5ac9d949dea07279095fa577963b"
+  integrity sha512-OfTXCJUFgjd/digLUuPxa0+/3ZxsQmE7ub9kcbW/wi96Bh3o/p5vrETcBGfP17NWPGqeYYl5LTRpwyGoMC4ysg==
+  dependencies:
+    "@babel/runtime" "^7.12.5"
+    "@testing-library/dom" "^8.0.0"
+    "@types/react-dom" "<18.0.0"
+
+"@types/aria-query@^4.2.0":
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/@types/aria-query/-/aria-query-4.2.2.tgz#ed4e0ad92306a704f9fb132a0cfcf77486dbe2bc"
+  integrity sha512-HnYpAE1Y6kRyKM/XkEuiRQhTHvkzMBurTHnpFLYLBGPIylZNPs9jJcuOOYWxPLJCSEtmZT0Y8rHDokKN7rRTig==
+
 "@types/babel__core@^7.1.7":
   version "7.1.12"
   resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.1.12.tgz#4d8e9e51eb265552a7e4f1ff2219ab6133bdfb2d"
@@ -1174,21 +1236,6 @@
   dependencies:
     "@babel/types" "^7.3.0"
 
-"@types/cheerio@*":
-  version "0.22.23"
-  resolved "https://registry.yarnpkg.com/@types/cheerio/-/cheerio-0.22.23.tgz#74bcfee9c5ee53f619711dca953a89fe5cfa4eb4"
-  integrity sha512-QfHLujVMlGqcS/ePSf3Oe5hK3H8wi/yN2JYuxSB1U10VvW1fO3K8C+mURQesFYS1Hn7lspOsTT75SKq/XtydQg==
-  dependencies:
-    "@types/node" "*"
-
-"@types/enzyme@^3.10.3":
-  version "3.10.8"
-  resolved "https://registry.yarnpkg.com/@types/enzyme/-/enzyme-3.10.8.tgz#ad7ac9d3af3de6fd0673773123fafbc63db50d42"
-  integrity sha512-vlOuzqsTHxog6PV79+tvOHFb6hq4QZKMq1lLD9MaWD1oec2lHTKndn76XOpSwCA0oFTaIbKVPrgM3k78Jjd16g==
-  dependencies:
-    "@types/cheerio" "*"
-    "@types/react" "*"
-
 "@types/eslint-visitor-keys@^1.0.0":
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/@types/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#1ee30d79544ca84d68d4b3cdb0af4f205663dd2d"
@@ -1246,6 +1293,14 @@
   dependencies:
     "@types/istanbul-lib-report" "*"
 
+"@types/jest@*":
+  version "28.1.6"
+  resolved "https://registry.yarnpkg.com/@types/jest/-/jest-28.1.6.tgz#d6a9cdd38967d2d746861fb5be6b120e38284dd4"
+  integrity sha512-0RbGAFMfcBJKOmqRazM8L98uokwuwD5F8rHrv/ZMbrZBwVOWZUyPG6VFNscjYr/vjM3Vu4fRrCPbOs42AfemaQ==
+  dependencies:
+    jest-matcher-utils "^28.0.0"
+    pretty-format "^28.0.0"
+
 "@types/jest@^25.2.1":
   version "25.2.3"
   resolved "https://registry.yarnpkg.com/@types/jest/-/jest-25.2.3.tgz#33d27e4c4716caae4eced355097a47ad363fdcaf"
@@ -1307,6 +1362,13 @@
   resolved "https://registry.yarnpkg.com/@types/prop-types/-/prop-types-15.7.3.tgz#2ab0d5da2e5815f94b0b9d4b95d1e5f243ab2ca7"
   integrity sha512-KfRL3PuHmqQLOG+2tGpRO26Ctg+Cq1E01D2DMriKEATHgWLfeNDmq9e29Q9WIky0dQ3NPkd1mzYH8Lm936Z9qw==
 
+"@types/react-dom@<18.0.0":
+  version "17.0.17"
+  resolved "https://registry.yarnpkg.com/@types/react-dom/-/react-dom-17.0.17.tgz#2e3743277a793a96a99f1bf87614598289da68a1"
+  integrity sha512-VjnqEmqGnasQKV0CWLevqMTXBYG9GbwuE6x3VetERLh0cq2LTptFE73MrQi2S7GkKXCf2GgwItB/melLnxfnsg==
+  dependencies:
+    "@types/react" "^17"
+
 "@types/react-dom@^17.0.0":
   version "17.0.0"
   resolved "https://registry.yarnpkg.com/@types/react-dom/-/react-dom-17.0.0.tgz#b3b691eb956c4b3401777ee67b900cb28415d95a"
@@ -1322,6 +1384,15 @@
     "@types/prop-types" "*"
     csstype "^3.0.2"
 
+"@types/react@^17":
+  version "17.0.47"
+  resolved "https://registry.yarnpkg.com/@types/react/-/react-17.0.47.tgz#4ee71aaf4c5a9e290e03aa4d0d313c5d666b3b78"
+  integrity sha512-mk0BL8zBinf2ozNr3qPnlu1oyVTYq+4V7WA76RgxUAtf0Em/Wbid38KN6n4abEkvO4xMTBWmnP1FtQzgkEiJoA==
+  dependencies:
+    "@types/prop-types" "*"
+    "@types/scheduler" "*"
+    csstype "^3.0.2"
+
 "@types/resolve@1.17.1":
   version "1.17.1"
   resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-1.17.1.tgz#3afd6ad8967c77e4376c598a82ddd58f46ec45d6"
@@ -1329,11 +1400,23 @@
   dependencies:
     "@types/node" "*"
 
+"@types/scheduler@*":
+  version "0.16.2"
+  resolved "https://registry.yarnpkg.com/@types/scheduler/-/scheduler-0.16.2.tgz#1a62f89525723dde24ba1b01b092bf5df8ad4d39"
+  integrity sha512-hppQEBDmlwhFAXKJX2KnWLYu5yMfi91yazPb2l+lbJiwW+wdo1gNeRA+3RgNSO39WYX2euey41KEwnqesU2Jew==
+
 "@types/stack-utils@^1.0.1":
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-1.0.1.tgz#0a851d3bd96498fa25c33ab7278ed3bd65f06c3e"
   integrity sha512-l42BggppR6zLmpfU6fq9HEa2oGPEI8yrSPL3GITjfRInppYFahObbIQOQK3UGxEnyQpltZLaPe75046NOZQikw==
 
+"@types/testing-library__jest-dom@^5.9.1":
+  version "5.14.5"
+  resolved "https://registry.yarnpkg.com/@types/testing-library__jest-dom/-/testing-library__jest-dom-5.14.5.tgz#d113709c90b3c75fdb127ec338dad7d5f86c974f"
+  integrity sha512-SBwbxYoyPIvxHbeHxTZX2Pe/74F/tX2/D3mMvzabdeJ25bBojfW0TyB8BHrbq/9zaaKICJZjLP+8r6AeZMFCuQ==
+  dependencies:
+    "@types/jest" "*"
+
 "@types/yargs-parser@*":
   version "20.2.0"
   resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-20.2.0.tgz#dd3e6699ba3237f0348cd085e4698780204842f9"
@@ -1422,21 +1505,6 @@ acorn@^7.1.0, acorn@^7.1.1:
   resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa"
   integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==
 
-airbnb-prop-types@^2.16.0:
-  version "2.16.0"
-  resolved "https://registry.yarnpkg.com/airbnb-prop-types/-/airbnb-prop-types-2.16.0.tgz#b96274cefa1abb14f623f804173ee97c13971dc2"
-  integrity sha512-7WHOFolP/6cS96PhKNrslCLMYAI8yB1Pp6u6XmxozQOiZbsI5ycglZr5cHhBFfuRcQQjzCMith5ZPZdYiJCxUg==
-  dependencies:
-    array.prototype.find "^2.1.1"
-    function.prototype.name "^1.1.2"
-    is-regex "^1.1.0"
-    object-is "^1.1.2"
-    object.assign "^4.1.0"
-    object.entries "^1.1.2"
-    prop-types "^15.7.2"
-    prop-types-exact "^1.2.0"
-    react-is "^16.13.1"
-
 ajv@^6.10.0, ajv@^6.10.2, ajv@^6.12.3:
   version "6.12.6"
   resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4"
@@ -1491,6 +1559,11 @@ ansi-regex@^5.0.0:
   resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75"
   integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg==
 
+ansi-regex@^5.0.1:
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304"
+  integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==
+
 ansi-styles@^2.2.1:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe"
@@ -1510,6 +1583,11 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   dependencies:
     color-convert "^2.0.1"
 
+ansi-styles@^5.0.0:
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
+  integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
+
 any-observable@^0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/any-observable/-/any-observable-0.3.0.tgz#af933475e5806a67d0d7df090dd5e8bef65d119b"
@@ -1551,6 +1629,11 @@ aria-query@^4.2.2:
     "@babel/runtime" "^7.10.2"
     "@babel/runtime-corejs3" "^7.10.2"
 
+aria-query@^5.0.0:
+  version "5.0.0"
+  resolved "https://registry.yarnpkg.com/aria-query/-/aria-query-5.0.0.tgz#210c21aaf469613ee8c9a62c7f86525e058db52c"
+  integrity sha512-V+SM7AbUwJ+EBnB8+DXs0hPZHO0W6pqBcc0dW90OwtVG02PswOu/teuARoLQjdDOH+t9pJgGnW5/Qmouf3gPJg==
+
 arr-diff@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520"
@@ -1571,11 +1654,6 @@ array-equal@^1.0.0:
   resolved "https://registry.yarnpkg.com/array-equal/-/array-equal-1.0.0.tgz#8c2a5ef2472fd9ea742b04c77a75093ba2757c93"
   integrity sha1-jCpe8kcv2ep0KwTHenUJO6J1fJM=
 
-array-filter@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/array-filter/-/array-filter-1.0.0.tgz#baf79e62e6ef4c2a4c0b831232daffec251f9d83"
-  integrity sha1-uveeYubvTCpMC4MSMtr/7CUfnYM=
-
 array-find-index@^1.0.1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1"
@@ -1609,14 +1687,6 @@ array-unique@^0.3.2:
   resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428"
   integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=
 
-array.prototype.find@^2.1.1:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/array.prototype.find/-/array.prototype.find-2.1.1.tgz#3baca26108ca7affb08db06bf0be6cb3115a969c"
-  integrity sha512-mi+MYNJYLTx2eNYy+Yh6raoQacCsNeeMUaspFPh9Y141lFSsWxxB8V9mM2ye+eqiRs917J6/pJ4M9ZPzenWckA==
-  dependencies:
-    define-properties "^1.1.3"
-    es-abstract "^1.17.4"
-
 array.prototype.flat@^1.2.3:
   version "1.2.4"
   resolved "https://registry.yarnpkg.com/array.prototype.flat/-/array.prototype.flat-1.2.4.tgz#6ef638b43312bd401b4c6199fdec7e2dc9e9a123"
@@ -1858,11 +1928,6 @@ bcrypt-pbkdf@^1.0.0:
   dependencies:
     tweetnacl "^0.14.3"
 
-boolbase@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/boolbase/-/boolbase-1.0.0.tgz#68dff5fbe60c51eb37725ea9e3ed310dcc1e776e"
-  integrity sha1-aN/1++YMUes3cl6p4+0xDcwed24=
-
 boxen@^3.0.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/boxen/-/boxen-3.2.0.tgz#fbdff0de93636ab4450886b6ff45b92d098f45eb"
@@ -2107,30 +2172,6 @@ chardet@^0.7.0:
   resolved "https://registry.yarnpkg.com/chardet/-/chardet-0.7.0.tgz#90094849f0937f2eedc2425d0d28a9e5f0cbad9e"
   integrity sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==
 
-cheerio-select-tmp@^0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/cheerio-select-tmp/-/cheerio-select-tmp-0.1.1.tgz#55bbef02a4771710195ad736d5e346763ca4e646"
-  integrity sha512-YYs5JvbpU19VYJyj+F7oYrIE2BOll1/hRU7rEy/5+v9BzkSo3bK81iAeeQEMI92vRIxz677m72UmJUiVwwgjfQ==
-  dependencies:
-    css-select "^3.1.2"
-    css-what "^4.0.0"
-    domelementtype "^2.1.0"
-    domhandler "^4.0.0"
-    domutils "^2.4.4"
-
-cheerio@^1.0.0-rc.3:
-  version "1.0.0-rc.5"
-  resolved "https://registry.yarnpkg.com/cheerio/-/cheerio-1.0.0-rc.5.tgz#88907e1828674e8f9fee375188b27dadd4f0fa2f"
-  integrity sha512-yoqps/VCaZgN4pfXtenwHROTp8NG6/Hlt4Jpz2FEP0ZJQ+ZUkVDd0hAPDNKhj3nakpfPt/CNs57yEtxD1bXQiw==
-  dependencies:
-    cheerio-select-tmp "^0.1.0"
-    dom-serializer "~1.2.0"
-    domhandler "^4.0.0"
-    entities "~2.1.0"
-    htmlparser2 "^6.0.0"
-    parse5 "^6.0.0"
-    parse5-htmlparser2-tree-adapter "^6.0.0"
-
 ci-info@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/ci-info/-/ci-info-2.0.0.tgz#67a9e964be31a51e15e5010d58e6f12834002f46"
@@ -2273,7 +2314,7 @@ combined-stream@^1.0.6, combined-stream@~1.0.6:
   dependencies:
     delayed-stream "~1.0.0"
 
-commander@^2.19.0, commander@^2.20.0:
+commander@^2.20.0:
   version "2.20.3"
   resolved "https://registry.yarnpkg.com/commander/-/commander-2.20.3.tgz#fd485e84c03eb4881c20722ba48035e8531aeb33"
   integrity sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==
@@ -2432,21 +2473,19 @@ crypto-random-string@^1.0.0:
   resolved "https://registry.yarnpkg.com/crypto-random-string/-/crypto-random-string-1.0.0.tgz#a230f64f568310e1498009940790ec99545bca7e"
   integrity sha1-ojD2T1aDEOFJgAmUB5DsmVRbyn4=
 
-css-select@^3.1.2:
-  version "3.1.2"
-  resolved "https://registry.yarnpkg.com/css-select/-/css-select-3.1.2.tgz#d52cbdc6fee379fba97fb0d3925abbd18af2d9d8"
-  integrity sha512-qmss1EihSuBNWNNhHjxzxSfJoFBM/lERB/Q4EnsJQQC62R2evJDW481091oAdOr9uh46/0n4nrg0It5cAnj1RA==
-  dependencies:
-    boolbase "^1.0.0"
-    css-what "^4.0.0"
-    domhandler "^4.0.0"
-    domutils "^2.4.3"
-    nth-check "^2.0.0"
+css.escape@^1.5.1:
+  version "1.5.1"
+  resolved "https://registry.yarnpkg.com/css.escape/-/css.escape-1.5.1.tgz#42e27d4fa04ae32f931a4b4d4191fa9cddee97cb"
+  integrity sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==
 
-css-what@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/css-what/-/css-what-4.0.0.tgz#35e73761cab2eeb3d3661126b23d7aa0e8432233"
-  integrity sha512-teijzG7kwYfNVsUh2H/YN62xW3KK9YhXEgSlbxMlcyjPNvdKJqFx5lrwlJgoFP1ZHlB89iGDlo/JyshKeRhv5A==
+css@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/css/-/css-3.0.0.tgz#4447a4d58fdd03367c516ca9f64ae365cee4aa5d"
+  integrity sha512-DG9pFfwOrzc+hawpmqX/dHYHJG+Bsdb0klhyi1sDneOgGOXy9wQIC8hzyVp1e4NRYDBdxcylvywPkkXCHAzTyQ==
+  dependencies:
+    inherits "^2.0.4"
+    source-map "^0.6.1"
+    source-map-resolve "^0.6.0"
 
 cssom@^0.4.1:
   version "0.4.4"
@@ -2631,10 +2670,10 @@ diff-sequences@^26.6.2:
   resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-26.6.2.tgz#48ba99157de1923412eed41db6b6d4aa9ca7c0b1"
   integrity sha512-Mv/TDa3nZ9sbc5soK+OoA74BsS3mL37yixCvUAQkiuA4Wz6YtwP/K47n2rv2ovzHZvoiQeA5FTQOschKkEwB0Q==
 
-discontinuous-range@1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/discontinuous-range/-/discontinuous-range-1.0.0.tgz#e38331f0844bba49b9a9cb71c771585aab1bc65a"
-  integrity sha1-44Mx8IRLukm5qctxx3FYWqsbxlo=
+diff-sequences@^28.1.1:
+  version "28.1.1"
+  resolved "https://registry.yarnpkg.com/diff-sequences/-/diff-sequences-28.1.1.tgz#9989dc731266dc2903457a70e996f3a041913ac6"
+  integrity sha512-FU0iFaH/E23a+a718l8Qa/19bF9p06kgE0KipMOMadwa3SjnaElKzPaUC0vnibs6/B/9ni97s61mcejk8W1fQw==
 
 doctrine@1.5.0:
   version "1.5.0"
@@ -2658,19 +2697,10 @@ doctrine@^3.0.0:
   dependencies:
     esutils "^2.0.2"
 
-dom-serializer@^1.0.1, dom-serializer@~1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/dom-serializer/-/dom-serializer-1.2.0.tgz#3433d9136aeb3c627981daa385fc7f32d27c48f1"
-  integrity sha512-n6kZFH/KlCrqs/1GHMOd5i2fd/beQHuehKdWvNNffbGHTr/almdhuVvTVFb3V7fglz+nC50fFusu3lY33h12pA==
-  dependencies:
-    domelementtype "^2.0.1"
-    domhandler "^4.0.0"
-    entities "^2.0.0"
-
-domelementtype@^2.0.1, domelementtype@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/domelementtype/-/domelementtype-2.1.0.tgz#a851c080a6d1c3d94344aed151d99f669edf585e"
-  integrity sha512-LsTgx/L5VpD+Q8lmsXSHW2WpA+eBlZ9HPf3erD1IoPF00/3JKHZ3BknUVA2QGDNu69ZNmyFmCWBSO45XjYKC5w==
+dom-accessibility-api@^0.5.6, dom-accessibility-api@^0.5.9:
+  version "0.5.14"
+  resolved "https://registry.yarnpkg.com/dom-accessibility-api/-/dom-accessibility-api-0.5.14.tgz#56082f71b1dc7aac69d83c4285eef39c15d93f56"
+  integrity sha512-NMt+m9zFMPZe0JcY9gN224Qvk6qLIdqex29clBvc/y75ZBX9YA9wNK3frsYvu2DI1xcCIwxwnX+TlsJ2DSOADg==
 
 domexception@^1.0.1:
   version "1.0.1"
@@ -2679,22 +2709,6 @@ domexception@^1.0.1:
   dependencies:
     webidl-conversions "^4.0.2"
 
-domhandler@^4.0.0:
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/domhandler/-/domhandler-4.0.0.tgz#01ea7821de996d85f69029e81fa873c21833098e"
-  integrity sha512-KPTbnGQ1JeEMQyO1iYXoagsI6so/C96HZiFyByU3T6iAzpXn8EGEvct6unm1ZGoed8ByO2oirxgwxBmqKF9haA==
-  dependencies:
-    domelementtype "^2.1.0"
-
-domutils@^2.4.3, domutils@^2.4.4:
-  version "2.4.4"
-  resolved "https://registry.yarnpkg.com/domutils/-/domutils-2.4.4.tgz#282739c4b150d022d34699797369aad8d19bbbd3"
-  integrity sha512-jBC0vOsECI4OMdD0GC9mGn7NXPLb+Qt6KW1YDQzeQYRUFKmNG8lh7mO5HiELfr+lLQE7loDVI4QcAxV80HS+RA==
-  dependencies:
-    dom-serializer "^1.0.1"
-    domelementtype "^2.0.1"
-    domhandler "^4.0.0"
-
 dot-prop@^4.1.0:
   version "4.2.1"
   resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-4.2.1.tgz#45884194a71fc2cda71cbb4bceb3a4dd2f433ba4"
@@ -2754,75 +2768,6 @@ enquirer@^2.3.4:
   dependencies:
     ansi-colors "^4.1.1"
 
-entities@^2.0.0, entities@~2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/entities/-/entities-2.1.0.tgz#992d3129cf7df6870b96c57858c249a120f8b8b5"
-  integrity sha512-hCx1oky9PFrJ611mf0ifBLBRW8lUUVRlFolb5gWRfIELabBlbp9xZvrqZLZAs+NxFnbfQoeGd8wDkygjg7U85w==
-
-enzyme-adapter-react-16@^1.15.6:
-  version "1.15.6"
-  resolved "https://registry.yarnpkg.com/enzyme-adapter-react-16/-/enzyme-adapter-react-16-1.15.6.tgz#fd677a658d62661ac5afd7f7f541f141f8085901"
-  integrity sha512-yFlVJCXh8T+mcQo8M6my9sPgeGzj85HSHi6Apgf1Cvq/7EL/J9+1JoJmJsRxZgyTvPMAqOEpRSu/Ii/ZpyOk0g==
-  dependencies:
-    enzyme-adapter-utils "^1.14.0"
-    enzyme-shallow-equal "^1.0.4"
-    has "^1.0.3"
-    object.assign "^4.1.2"
-    object.values "^1.1.2"
-    prop-types "^15.7.2"
-    react-is "^16.13.1"
-    react-test-renderer "^16.0.0-0"
-    semver "^5.7.0"
-
-enzyme-adapter-utils@^1.14.0:
-  version "1.14.0"
-  resolved "https://registry.yarnpkg.com/enzyme-adapter-utils/-/enzyme-adapter-utils-1.14.0.tgz#afbb0485e8033aa50c744efb5f5711e64fbf1ad0"
-  integrity sha512-F/z/7SeLt+reKFcb7597IThpDp0bmzcH1E9Oabqv+o01cID2/YInlqHbFl7HzWBl4h3OdZYedtwNDOmSKkk0bg==
-  dependencies:
-    airbnb-prop-types "^2.16.0"
-    function.prototype.name "^1.1.3"
-    has "^1.0.3"
-    object.assign "^4.1.2"
-    object.fromentries "^2.0.3"
-    prop-types "^15.7.2"
-    semver "^5.7.1"
-
-enzyme-shallow-equal@^1.0.1, enzyme-shallow-equal@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/enzyme-shallow-equal/-/enzyme-shallow-equal-1.0.4.tgz#b9256cb25a5f430f9bfe073a84808c1d74fced2e"
-  integrity sha512-MttIwB8kKxypwHvRynuC3ahyNc+cFbR8mjVIltnmzQ0uKGqmsfO4bfBuLxb0beLNPhjblUEYvEbsg+VSygvF1Q==
-  dependencies:
-    has "^1.0.3"
-    object-is "^1.1.2"
-
-enzyme@^3.11.0:
-  version "3.11.0"
-  resolved "https://registry.yarnpkg.com/enzyme/-/enzyme-3.11.0.tgz#71d680c580fe9349f6f5ac6c775bc3e6b7a79c28"
-  integrity sha512-Dw8/Gs4vRjxY6/6i9wU0V+utmQO9kvh9XLnz3LIudviOnVYDEe2ec+0k+NQoMamn1VrjKgCUOWj5jG/5M5M0Qw==
-  dependencies:
-    array.prototype.flat "^1.2.3"
-    cheerio "^1.0.0-rc.3"
-    enzyme-shallow-equal "^1.0.1"
-    function.prototype.name "^1.1.2"
-    has "^1.0.3"
-    html-element-map "^1.2.0"
-    is-boolean-object "^1.0.1"
-    is-callable "^1.1.5"
-    is-number-object "^1.0.4"
-    is-regex "^1.0.5"
-    is-string "^1.0.5"
-    is-subset "^0.1.1"
-    lodash.escape "^4.0.1"
-    lodash.isequal "^4.5.0"
-    object-inspect "^1.7.0"
-    object-is "^1.0.2"
-    object.assign "^4.1.0"
-    object.entries "^1.1.1"
-    object.values "^1.1.1"
-    raf "^3.4.1"
-    rst-selector-parser "^2.2.3"
-    string.prototype.trim "^1.2.1"
-
 error-ex@^1.2.0, error-ex@^1.3.1:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf"
@@ -2830,7 +2775,7 @@ error-ex@^1.2.0, error-ex@^1.3.1:
   dependencies:
     is-arrayish "^0.2.1"
 
-es-abstract@^1.17.0-next.1, es-abstract@^1.17.4:
+es-abstract@^1.17.0-next.1:
   version "1.17.7"
   resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.17.7.tgz#a4de61b2f66989fc7421676c1cb9787573ace54c"
   integrity sha512-VBl/gnfcJ7OercKA9MVaegWsBHFjV492syMudcnQZvt/Dw8ezpcOHYZXa/J96O8vx+g4x65YKhxOwDUh63aS5g==
@@ -3466,26 +3411,11 @@ function-bind@^1.1.1:
   resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
   integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==
 
-function.prototype.name@^1.1.2, function.prototype.name@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.3.tgz#0bb034bb308e7682826f215eb6b2ae64918847fe"
-  integrity sha512-H51qkbNSp8mtkJt+nyW1gyStBiKZxfRqySNUR99ylq6BPXHKI4SEvIlTKp4odLfjRKJV04DFWMU3G/YRlQOsag==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    es-abstract "^1.18.0-next.1"
-    functions-have-names "^1.2.1"
-
 functional-red-black-tree@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327"
   integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=
 
-functions-have-names@^1.2.1:
-  version "1.2.2"
-  resolved "https://registry.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.2.tgz#98d93991c39da9361f8e50b337c4f6e41f120e21"
-  integrity sha512-bLgc3asbWdwPbx2mNk2S49kmJCuQeu0nfmaOgbs8WIyzzkw3r4htszdIi9Q9EMezDPTYuJx2wvjZ/EwgAthpnA==
-
 gensync@^1.0.0-beta.1:
   version "1.0.0-beta.2"
   resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0"
@@ -3746,13 +3676,6 @@ hosted-git-info@^3.0.0:
   dependencies:
     lru-cache "^6.0.0"
 
-html-element-map@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/html-element-map/-/html-element-map-1.2.0.tgz#dfbb09efe882806af63d990cf6db37993f099f22"
-  integrity sha512-0uXq8HsuG1v2TmQ8QkIhzbrqeskE4kn52Q18QJ9iAA/SnHoEKXWiUxHQtclRsCFWEUD2So34X+0+pZZu862nnw==
-  dependencies:
-    array-filter "^1.0.0"
-
 html-encoding-sniffer@^1.0.2:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/html-encoding-sniffer/-/html-encoding-sniffer-1.0.2.tgz#e70d84b94da53aa375e11fe3a351be6642ca46f8"
@@ -3765,16 +3688,6 @@ html-escaper@^2.0.0:
   resolved "https://registry.yarnpkg.com/html-escaper/-/html-escaper-2.0.2.tgz#dfd60027da36a36dfcbe236262c00a5822681453"
   integrity sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==
 
-htmlparser2@^6.0.0:
-  version "6.0.0"
-  resolved "https://registry.yarnpkg.com/htmlparser2/-/htmlparser2-6.0.0.tgz#c2da005030390908ca4c91e5629e418e0665ac01"
-  integrity sha512-numTQtDZMoh78zJpaNdJ9MXb2cv5G3jwUoe3dMQODubZvLoGvTE/Ofp6sHvH8OGKcN/8A47pGLi/k58xHP/Tfw==
-  dependencies:
-    domelementtype "^2.0.1"
-    domhandler "^4.0.0"
-    domutils "^2.4.4"
-    entities "^2.0.0"
-
 http-cache-semantics@^4.0.0:
   version "4.1.0"
   resolved "https://registry.yarnpkg.com/http-cache-semantics/-/http-cache-semantics-4.1.0.tgz#49e91c5cbf36c9b94bcfcd71c23d5249ec74e390"
@@ -3866,6 +3779,11 @@ indent-string@^3.0.0:
   resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-3.2.0.tgz#4a5fd6d27cc332f37e5419a504dbb837105c9289"
   integrity sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok=
 
+indent-string@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251"
+  integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==
+
 inflight@^1.0.4:
   version "1.0.6"
   resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
@@ -3874,7 +3792,7 @@ inflight@^1.0.4:
     once "^1.3.0"
     wrappy "1"
 
-inherits@2:
+inherits@2, inherits@^2.0.4:
   version "2.0.4"
   resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
   integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
@@ -3979,19 +3897,12 @@ is-arrayish@^0.2.1:
   resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
   integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=
 
-is-boolean-object@^1.0.1:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.0.tgz#e2aaad3a3a8fca34c28f6eee135b156ed2587ff0"
-  integrity sha512-a7Uprx8UtD+HWdyYwnD1+ExtTgqQtD2k/1yJgtXP6wnMm8byhkoTZRl+95LLThpzNZJ5aEvi46cdH+ayMFRwmA==
-  dependencies:
-    call-bind "^1.0.0"
-
 is-buffer@^1.1.5:
   version "1.1.6"
   resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be"
   integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==
 
-is-callable@^1.1.4, is-callable@^1.1.5, is-callable@^1.2.2:
+is-callable@^1.1.4, is-callable@^1.2.2:
   version "1.2.2"
   resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.2.tgz#c7c6715cd22d4ddb48d3e19970223aceabb080d9"
   integrity sha512-dnMqspv5nU3LoewK2N/y7KLtxtakvTuaCsU9FU50/QDmdbHNy/4/JuRtMHqRU22o3q+W89YQndQEeCVwK+3qrA==
@@ -4146,11 +4057,6 @@ is-npm@^3.0.0:
   resolved "https://registry.yarnpkg.com/is-npm/-/is-npm-3.0.0.tgz#ec9147bfb629c43f494cf67936a961edec7e8053"
   integrity sha512-wsigDr1Kkschp2opC4G3yA6r9EgVA6NjRpWzIi9axXqeIaAATPRJc4uLujXe3Nd9uO8KoDyA4MD6aZSeXTADhA==
 
-is-number-object@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.4.tgz#36ac95e741cf18b283fc1ddf5e83da798e3ec197"
-  integrity sha512-zohwelOAur+5uXtk8O3GPQ1eAcu4ZX3UwxQhUlfFFMNpUd83gXgjbhJh6HmB6LUNV/ieOLQuDwJO3dWJosUeMw==
-
 is-number@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195"
@@ -4230,7 +4136,7 @@ is-reference@^1.1.2:
   dependencies:
     "@types/estree" "*"
 
-is-regex@^1.0.5, is-regex@^1.1.0, is-regex@^1.1.1:
+is-regex@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.1.tgz#c6f98aacc546f6cec5468a07b7b153ab564a57b9"
   integrity sha512-1+QkEcxiLlB7VEyFtyBg94e08OAsvq7FUBgApTq/w2ymCLyKJgDPsybBENVtA7XCQEgEXxKPonG+mvYRxh/LIg==
@@ -4259,11 +4165,6 @@ is-string@^1.0.5:
   resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.5.tgz#40493ed198ef3ff477b8c7f92f644ec82a5cd3a6"
   integrity sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==
 
-is-subset@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/is-subset/-/is-subset-0.1.1.tgz#8a59117d932de1de00f245fcdd39ce43f1e939a6"
-  integrity sha1-ilkRfZMt4d4A8kX83TnOQ/HpOaY=
-
 is-symbol@^1.0.2:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.3.tgz#38e1014b9e6329be0de9d24a414fd7441ec61937"
@@ -4447,6 +4348,16 @@ jest-diff@^26.0.0:
     jest-get-type "^26.3.0"
     pretty-format "^26.6.2"
 
+jest-diff@^28.1.3:
+  version "28.1.3"
+  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-28.1.3.tgz#948a192d86f4e7a64c5264ad4da4877133d8792f"
+  integrity sha512-8RqP1B/OXzjjTWkqMX67iqgwBVJRgCyKD3L9nq+6ZqJMdvjE8RgHktqZ6jNrkdMT+dJuYNI3rhQpxaz7drJHfw==
+  dependencies:
+    chalk "^4.0.0"
+    diff-sequences "^28.1.1"
+    jest-get-type "^28.0.2"
+    pretty-format "^28.1.3"
+
 jest-docblock@^25.3.0:
   version "25.3.0"
   resolved "https://registry.yarnpkg.com/jest-docblock/-/jest-docblock-25.3.0.tgz#8b777a27e3477cd77a168c05290c471a575623ef"
@@ -4499,6 +4410,11 @@ jest-get-type@^26.3.0:
   resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-26.3.0.tgz#e97dc3c3f53c2b406ca7afaed4493b1d099199e0"
   integrity sha512-TpfaviN1R2pQWkIihlfEanwOXK0zcxrKEE4MlU6Tn7keoXdN6/3gK/xl0yEh8DOunn5pOVGKf8hB4R9gVh04ig==
 
+jest-get-type@^28.0.2:
+  version "28.0.2"
+  resolved "https://registry.yarnpkg.com/jest-get-type/-/jest-get-type-28.0.2.tgz#34622e628e4fdcd793d46db8a242227901fcf203"
+  integrity sha512-ioj2w9/DxSYHfOm5lJKCdcAmPJzQXmbM/Url3rhlghrPvT3tt+7a/+oXc9azkKmLvoiXjtV83bEWqi+vs5nlPA==
+
 jest-haste-map@^25.5.1:
   version "25.5.1"
   resolved "https://registry.yarnpkg.com/jest-haste-map/-/jest-haste-map-25.5.1.tgz#1df10f716c1d94e60a1ebf7798c9fb3da2620943"
@@ -4560,6 +4476,16 @@ jest-matcher-utils@^25.5.0:
     jest-get-type "^25.2.6"
     pretty-format "^25.5.0"
 
+jest-matcher-utils@^28.0.0:
+  version "28.1.3"
+  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-28.1.3.tgz#5a77f1c129dd5ba3b4d7fc20728806c78893146e"
+  integrity sha512-kQeJ7qHemKfbzKoGjHHrRKH6atgxMk8Enkk2iPQ3XwO6oE/KYD8lMYOziCkeSB9G4adPM4nR1DE8Tf5JeWH6Bw==
+  dependencies:
+    chalk "^4.0.0"
+    jest-diff "^28.1.3"
+    jest-get-type "^28.0.2"
+    pretty-format "^28.1.3"
+
 jest-message-util@^25.5.0:
   version "25.5.0"
   resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-25.5.0.tgz#ea11d93204cc7ae97456e1d8716251185b8880ea"
@@ -5105,21 +5031,6 @@ lodash.debounce@^4.0.8:
   resolved "https://registry.yarnpkg.com/lodash.debounce/-/lodash.debounce-4.0.8.tgz#82d79bff30a67c4005ffd5e2515300ad9ca4d7af"
   integrity sha1-gteb/zCmfEAF/9XiUVMArZyk168=
 
-lodash.escape@^4.0.1:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/lodash.escape/-/lodash.escape-4.0.1.tgz#c9044690c21e04294beaa517712fded1fa88de98"
-  integrity sha1-yQRGkMIeBClL6qUXcS/e0fqI3pg=
-
-lodash.flattendeep@^4.4.0:
-  version "4.4.0"
-  resolved "https://registry.yarnpkg.com/lodash.flattendeep/-/lodash.flattendeep-4.4.0.tgz#fb030917f86a3134e5bc9bec0d69e0013ddfedb2"
-  integrity sha1-+wMJF/hqMTTlvJvsDWngAT3f7bI=
-
-lodash.isequal@^4.5.0:
-  version "4.5.0"
-  resolved "https://registry.yarnpkg.com/lodash.isequal/-/lodash.isequal-4.5.0.tgz#415c4478f2bcc30120c22ce10ed3226f7d3e18e0"
-  integrity sha1-QVxEePK8wwEgwizhDtMib30+GOA=
-
 lodash.memoize@4.x:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe"
@@ -5232,6 +5143,11 @@ lru-cache@^6.0.0:
   dependencies:
     yallist "^4.0.0"
 
+lz-string@^1.4.4:
+  version "1.4.4"
+  resolved "https://registry.yarnpkg.com/lz-string/-/lz-string-1.4.4.tgz#c0d8eaf36059f705796e1e344811cf4c498d3a26"
+  integrity sha512-0ckx7ZHRPqb0oUm8zNr+90mtf9DQB60H1wMCjBtfi62Kl3a7JbHob6gA2bC+xRvZoOL+1hzUK8jeuEIQE8svEQ==
+
 magic-string@^0.25.2, magic-string@^0.25.7:
   version "0.25.7"
   resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.25.7.tgz#3f497d6fd34c669c6798dcb821f2ef31f5445051"
@@ -5377,6 +5293,11 @@ mimic-response@^1.0.0, mimic-response@^1.0.1:
   resolved "https://registry.yarnpkg.com/mimic-response/-/mimic-response-1.0.1.tgz#4923538878eef42063cb8a3e3b0798781487ab1b"
   integrity sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==
 
+min-indent@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869"
+  integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==
+
 minimatch@^3.0.4:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
@@ -5412,11 +5333,6 @@ mkdirp@0.x, mkdirp@^0.5.1:
   dependencies:
     minimist "^1.2.5"
 
-moo@^0.5.0:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/moo/-/moo-0.5.1.tgz#7aae7f384b9b09f620b6abf6f74ebbcd1b65dbc4"
-  integrity sha512-I1mnb5xn4fO80BH9BLcF0yLypy2UKl+Cb01Fu0hJRkJjlCRtxZMWkTdAtDd5ZqCOxtCkhmRwyI57vWT+1iZ67w==
-
 mri@^1.1.0:
   version "1.1.6"
   resolved "https://registry.yarnpkg.com/mri/-/mri-1.1.6.tgz#49952e1044db21dbf90f6cd92bc9c9a777d415a6"
@@ -5464,16 +5380,6 @@ natural-compare@^1.4.0:
   resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7"
   integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=
 
-nearley@^2.7.10:
-  version "2.20.1"
-  resolved "https://registry.yarnpkg.com/nearley/-/nearley-2.20.1.tgz#246cd33eff0d012faf197ff6774d7ac78acdd474"
-  integrity sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==
-  dependencies:
-    commander "^2.19.0"
-    moo "^0.5.0"
-    railroad-diagrams "^1.0.0"
-    randexp "0.4.6"
-
 neo-async@^2.6.0:
   version "2.6.2"
   resolved "https://registry.yarnpkg.com/neo-async/-/neo-async-2.6.2.tgz#b4aafb93e3aeb2d8174ca53cf163ab7d7308305f"
@@ -5618,13 +5524,6 @@ npm-run-path@^4.0.0:
   dependencies:
     path-key "^3.0.0"
 
-nth-check@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/nth-check/-/nth-check-2.0.0.tgz#1bb4f6dac70072fc313e8c9cd1417b5074c0a125"
-  integrity sha512-i4sc/Kj8htBrAiH1viZ0TgU8Y5XqCaV/FziYK6TBczxmeKm3AEFWqqF3195yKudrarqy7Zu80Ra5dobFjn9X/Q==
-  dependencies:
-    boolbase "^1.0.0"
-
 number-is-nan@^1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d"
@@ -5654,19 +5553,11 @@ object-copy@^0.1.0:
     define-property "^0.2.5"
     kind-of "^3.0.3"
 
-object-inspect@^1.7.0, object-inspect@^1.8.0, object-inspect@^1.9.0:
+object-inspect@^1.8.0, object-inspect@^1.9.0:
   version "1.9.0"
   resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.9.0.tgz#c90521d74e1127b67266ded3394ad6116986533a"
   integrity sha512-i3Bp9iTqwhaLZBxGkRfo5ZbE07BQRT7MGu8+nNgwW9ItGp1TzCTw2DLEoWwjClxBjOFI/hWljTAmYGCEwmtnOw==
 
-object-is@^1.0.2, object-is@^1.1.2:
-  version "1.1.4"
-  resolved "https://registry.yarnpkg.com/object-is/-/object-is-1.1.4.tgz#63d6c83c00a43f4cbc9434eb9757c8a5b8565068"
-  integrity sha512-1ZvAZ4wlF7IyPVOcE1Omikt7UpaFlOQq0HlSti+ZvDH3UiD2brwGMwDbyV43jao2bKJ+4+WdPJHSd7kgzKYVqg==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-
 object-keys@^1.0.12, object-keys@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e"
@@ -5689,7 +5580,7 @@ object.assign@^4.1.0, object.assign@^4.1.1, object.assign@^4.1.2:
     has-symbols "^1.0.1"
     object-keys "^1.1.1"
 
-object.entries@^1.1.1, object.entries@^1.1.2:
+object.entries@^1.1.2:
   version "1.1.3"
   resolved "https://registry.yarnpkg.com/object.entries/-/object.entries-1.1.3.tgz#c601c7f168b62374541a07ddbd3e2d5e4f7711a6"
   integrity sha512-ym7h7OZebNS96hn5IJeyUmaWhaSM4SVtAPPfNLQEI2MYWCO2egsITb9nab2+i/Pwibx+R0mtn+ltKJXRSeTMGg==
@@ -5699,7 +5590,7 @@ object.entries@^1.1.1, object.entries@^1.1.2:
     es-abstract "^1.18.0-next.1"
     has "^1.0.3"
 
-object.fromentries@^2.0.2, object.fromentries@^2.0.3:
+object.fromentries@^2.0.2:
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/object.fromentries/-/object.fromentries-2.0.3.tgz#13cefcffa702dc67750314a3305e8cb3fad1d072"
   integrity sha512-IDUSMXs6LOSJBWE++L0lzIbSqHl9KDCfff2x/JSEIDtEUavUnyMYC2ZGay/04Zq4UT8lvd4xNhU4/YHKibAOlw==
@@ -5716,7 +5607,7 @@ object.pick@^1.3.0:
   dependencies:
     isobject "^3.0.1"
 
-object.values@^1.1.1, object.values@^1.1.2:
+object.values@^1.1.1:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.1.2.tgz#7a2015e06fcb0f546bd652486ce8583a4731c731"
   integrity sha512-MYC0jvJopr8EK6dPBiO8Nb9mvjdypOachO5REGk6MXzujbBrAisKo3HmdEI6kZDL6fC31Mwee/5YbtMebixeag==
@@ -5947,23 +5838,11 @@ parse-json@^5.0.0:
     json-parse-even-better-errors "^2.3.0"
     lines-and-columns "^1.1.6"
 
-parse5-htmlparser2-tree-adapter@^6.0.0:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/parse5-htmlparser2-tree-adapter/-/parse5-htmlparser2-tree-adapter-6.0.1.tgz#2cdf9ad823321140370d4dbf5d3e92c7c8ddc6e6"
-  integrity sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==
-  dependencies:
-    parse5 "^6.0.1"
-
 parse5@5.1.0:
   version "5.1.0"
   resolved "https://registry.yarnpkg.com/parse5/-/parse5-5.1.0.tgz#c59341c9723f414c452975564c7c00a68d58acd2"
   integrity sha512-fxNG2sQjHvlVAYmzBZS9YlDp6PTSSDwa98vkD4QgVDDCAo84z5X1t5XyJQ62ImdLXx5NdIIfihey6xpum9/gRQ==
 
-parse5@^6.0.0, parse5@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/parse5/-/parse5-6.0.1.tgz#e1a1c085c569b3dc08321184f19a39cc27f7c30b"
-  integrity sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==
-
 pascal-case@^3.1.1:
   version "3.1.2"
   resolved "https://registry.yarnpkg.com/pascal-case/-/pascal-case-3.1.2.tgz#b48e0ef2b98e205e7c1dae747d0b1508237660eb"
@@ -6007,12 +5886,7 @@ path-key@^3.0.0, path-key@^3.1.0:
   resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375"
   integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==
 
-path-parse@^1.0.6:
-  version "1.0.7"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
-  integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
-
-path-parse@^1.0.7:
+path-parse@^1.0.6, path-parse@^1.0.7:
   version "1.0.7"
   resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
   integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==
@@ -6165,6 +6039,25 @@ pretty-format@^26.0.0, pretty-format@^26.6.2:
     ansi-styles "^4.0.0"
     react-is "^17.0.1"
 
+pretty-format@^27.0.2:
+  version "27.5.1"
+  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-27.5.1.tgz#2181879fdea51a7a5851fb39d920faa63f01d88e"
+  integrity sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==
+  dependencies:
+    ansi-regex "^5.0.1"
+    ansi-styles "^5.0.0"
+    react-is "^17.0.1"
+
+pretty-format@^28.0.0, pretty-format@^28.1.3:
+  version "28.1.3"
+  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-28.1.3.tgz#c9fba8cedf99ce50963a11b27d982a9ae90970d5"
+  integrity sha512-8gFb/To0OmxHR9+ZTb14Df2vNxdGCX8g1xWGUTqUw5TiZvcQf5sHKObd5UcPyLLyowNwDAMTF3XWOG1B6mxl1Q==
+  dependencies:
+    "@jest/schemas" "^28.1.3"
+    ansi-regex "^5.0.1"
+    ansi-styles "^5.0.0"
+    react-is "^18.0.0"
+
 progress-estimator@^0.2.2:
   version "0.2.2"
   resolved "https://registry.yarnpkg.com/progress-estimator/-/progress-estimator-0.2.2.tgz#1c3947a5782ea56e40c8fccc290ac7ceeb1b91cb"
@@ -6188,15 +6081,6 @@ prompts@^2.0.1:
     kleur "^3.0.3"
     sisteransi "^1.0.5"
 
-prop-types-exact@^1.2.0:
-  version "1.2.0"
-  resolved "https://registry.yarnpkg.com/prop-types-exact/-/prop-types-exact-1.2.0.tgz#825d6be46094663848237e3925a98c6e944e9869"
-  integrity sha512-K+Tk3Kd9V0odiXFP9fwDHUYRyvK3Nun3GVyPapSIs5OBkITAm15W0CPFD/YKTkMUAbc0b9CUwRQp2ybiBIq+eA==
-  dependencies:
-    has "^1.0.3"
-    object.assign "^4.1.0"
-    reflect.ownkeys "^0.2.0"
-
 prop-types@^15.6.2, prop-types@^15.7.2:
   version "15.7.2"
   resolved "https://registry.yarnpkg.com/prop-types/-/prop-types-15.7.2.tgz#52c41e75b8c87e72b9d9360e0206b99dcbffa6c5"
@@ -6248,26 +6132,6 @@ quick-lru@^1.0.0:
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8"
   integrity sha1-Q2CxfGETatOAeDl/8RQW4Ybc+7g=
 
-raf@^3.4.1:
-  version "3.4.1"
-  resolved "https://registry.yarnpkg.com/raf/-/raf-3.4.1.tgz#0742e99a4a6552f445d73e3ee0328af0ff1ede39"
-  integrity sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==
-  dependencies:
-    performance-now "^2.1.0"
-
-railroad-diagrams@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/railroad-diagrams/-/railroad-diagrams-1.0.0.tgz#eb7e6267548ddedfb899c1b90e57374559cddb7e"
-  integrity sha1-635iZ1SN3t+4mcG5Dlc3RVnN234=
-
-randexp@0.4.6:
-  version "0.4.6"
-  resolved "https://registry.yarnpkg.com/randexp/-/randexp-0.4.6.tgz#e986ad5e5e31dae13ddd6f7b3019aa7c87f60ca3"
-  integrity sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==
-  dependencies:
-    discontinuous-range "1.0.0"
-    ret "~0.1.10"
-
 randombytes@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/randombytes/-/randombytes-2.1.0.tgz#df6f84372f0270dc65cdf6291349ab7a473d4f2a"
@@ -6295,7 +6159,7 @@ rc@^1.2.8:
     prop-types "^15.6.2"
     scheduler "^0.19.1"
 
-react-is@^16.12.0, react-is@^16.13.1, react-is@^16.8.1, react-is@^16.8.6:
+react-is@^16.12.0, react-is@^16.13.1, react-is@^16.8.1:
   version "16.13.1"
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
@@ -6305,15 +6169,10 @@ react-is@^17.0.1:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-17.0.1.tgz#5b3531bd76a645a4c9fb6e693ed36419e3301339"
   integrity sha512-NAnt2iGDXohE5LI7uBnLnqvLQMtzhkiAOLXTmv+qnF9Ky7xAPcX8Up/xWIhxvLVGJvuLiNc4xQLtuqDRzb4fSA==
 
-react-test-renderer@^16.0.0-0:
-  version "16.14.0"
-  resolved "https://registry.yarnpkg.com/react-test-renderer/-/react-test-renderer-16.14.0.tgz#e98360087348e260c56d4fe2315e970480c228ae"
-  integrity sha512-L8yPjqPE5CZO6rKsKXRO/rVPiaCOy0tQQJbC+UjPNlobl5mad59lvPjwFsQHTvL03caVDIVr9x9/OSgDe6I5Eg==
-  dependencies:
-    object-assign "^4.1.1"
-    prop-types "^15.6.2"
-    react-is "^16.8.6"
-    scheduler "^0.19.1"
+react-is@^18.0.0:
+  version "18.2.0"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.2.0.tgz#199431eeaaa2e09f86427efbb4f1473edb47609b"
+  integrity sha512-xWGDIW6x921xtzPkhiULtthJHoJvBbF3q26fzloPCK0hsvxtPVelvftw3zjbHWSkR2km9Z+4uxbDDK/6Zw9B8w==
 
 "react@^16.2.0 || ^16.0.0":
   version "16.14.0"
@@ -6397,10 +6256,13 @@ redent@^2.0.0:
     indent-string "^3.0.0"
     strip-indent "^2.0.0"
 
-reflect.ownkeys@^0.2.0:
-  version "0.2.0"
-  resolved "https://registry.yarnpkg.com/reflect.ownkeys/-/reflect.ownkeys-0.2.0.tgz#749aceec7f3fdf8b63f927a04809e90c5c0b3460"
-  integrity sha1-dJrO7H8/34tj+SegSAnpDFwLNGA=
+redent@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f"
+  integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==
+  dependencies:
+    indent-string "^4.0.0"
+    strip-indent "^3.0.0"
 
 regenerate-unicode-properties@^8.2.0:
   version "8.2.0"
@@ -6708,14 +6570,6 @@ rollup@^1.32.1:
     "@types/node" "*"
     acorn "^7.1.0"
 
-rst-selector-parser@^2.2.3:
-  version "2.2.3"
-  resolved "https://registry.yarnpkg.com/rst-selector-parser/-/rst-selector-parser-2.2.3.tgz#81b230ea2fcc6066c89e3472de794285d9b03d91"
-  integrity sha1-gbIw6i/MYGbInjRy3nlChdmwPZE=
-  dependencies:
-    lodash.flattendeep "^4.4.0"
-    nearley "^2.7.10"
-
 rsvp@^4.8.4:
   version "4.8.5"
   resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734"
@@ -6814,7 +6668,7 @@ semver-regex@^3.1.2:
   resolved "https://registry.yarnpkg.com/semver-regex/-/semver-regex-3.1.2.tgz#34b4c0d361eef262e07199dbef316d0f2ab11807"
   integrity sha512-bXWyL6EAKOJa81XG1OZ/Yyuq+oT0b2YLlxx7c+mrdYPaPbnj6WgVULXhinMIeZGufuUBu/eVRqXEhiv4imfwxA==
 
-"semver@2 || 3 || 4 || 5", semver@^5.0.3, semver@^5.4.1, semver@^5.5.0, semver@^5.7.0, semver@^5.7.1:
+"semver@2 || 3 || 4 || 5", semver@^5.0.3, semver@^5.4.1, semver@^5.5.0:
   version "5.7.1"
   resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7"
   integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==
@@ -7159,15 +7013,6 @@ string.prototype.matchall@^4.0.2:
     regexp.prototype.flags "^1.3.0"
     side-channel "^1.0.3"
 
-string.prototype.trim@^1.2.1:
-  version "1.2.3"
-  resolved "https://registry.yarnpkg.com/string.prototype.trim/-/string.prototype.trim-1.2.3.tgz#d23a22fde01c1e6571a7fadcb9be11decd8061a7"
-  integrity sha512-16IL9pIBA5asNOSukPfxX2W68BaBvxyiRK16H3RA/lWW9BDosh+w7f+LhomPHpXJ82QEe7w7/rY/S1CV97raLg==
-  dependencies:
-    call-bind "^1.0.0"
-    define-properties "^1.1.3"
-    es-abstract "^1.18.0-next.1"
-
 string.prototype.trimend@^1.0.1, string.prototype.trimend@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.3.tgz#a22bd53cca5c7cf44d7c9d5c732118873d6cd18b"
@@ -7237,6 +7082,13 @@ strip-indent@^2.0.0:
   resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68"
   integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g=
 
+strip-indent@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001"
+  integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==
+  dependencies:
+    min-indent "^1.0.0"
+
 strip-json-comments@^3.0.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006"