@mui/internal-test-utils 1.0.2 → 1.0.4

package/src/createMount.tsx

@@ -1,136 +0,0 @@
-/* eslint-env mocha */
-import * as React from 'react';
-import * as ReactDOM from 'react-dom';
-import * as ReactDOMTestUtils from 'react-dom/test-utils';
-import { Test, Suite } from 'mocha';
-import { mount as enzymeMount, MountRendererProps } from 'enzyme';
-
-interface ModeProps {
-  /**
-   * this is essentially children. However, we can't use children because then
-   * using `wrapper.setProps({ children })` would work differently if this component
-   * would be the root.
-   */
-  __element: React.ReactElement<any>;
-  __strict: boolean;
-}
-
-/**
- * Can't just mount <React.Fragment>{node}</React.Fragment>
- * because that swallows wrapper.setProps
- *
- * why class component:
- * https://github.com/airbnb/enzyme/issues/2043
- */
-// eslint-disable-next-line react/prefer-stateless-function
-class Mode extends React.Component<ModeProps> {
-  render() {
-    // Excess props will come from e.g. enzyme setProps
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    const { __element, __strict, ...other } = this.props;
-    const Component = __strict ? React.StrictMode : React.Fragment;
-
-    return <Component>{React.cloneElement(__element, other)}</Component>;
-  }
-}
-
-interface CreateMountOptions extends MountRendererProps {
-  mount?: typeof enzymeMount;
-  strict?: boolean;
-}
-// Generate an enhanced mount function.
-export default function createMount(options: CreateMountOptions = {}) {
-  const { mount = enzymeMount, strict: globalStrict = true, ...globalEnzymeOptions } = options;
-
-  let container: HTMLElement | null = null;
-
-  function computeTestName(test: Test | undefined) {
-    let current: Test | Suite | undefined = test;
-    const titles: string[] = [];
-    while (current != null) {
-      titles.push(current.title);
-      current = current.parent;
-    }
-
-    return titles.filter(Boolean).reverse().join(' -> ');
-  }
-
-  // save stack to re-use in test-hooks
-  const { stack: createMountStack } = new Error();
-
-  /**
-   * Flag whether `createMount` was called in a suite i.e. describe() block.
-   * For legacy reasons `createMount` might accidentally be called in a before(Each) hook.
-   */
-  let wasCalledInSuite = false;
-  before(() => {
-    wasCalledInSuite = true;
-  });
-
-  beforeEach(() => {
-    if (!wasCalledInSuite) {
-      const error = new Error(
-        'Unable to run `before` hook for `createMount`. This usually indicates that `createMount` was called in a `before` hook instead of in a `describe()` block.',
-      );
-      error.stack = createMountStack;
-      throw error;
-    }
-  });
-
-  beforeEach(function beforeEachMountTest() {
-    container = document.createElement('div');
-    container.setAttribute('data-test', computeTestName(this.currentTest));
-    document.body.insertBefore(container, document.body.firstChild);
-  });
-
-  afterEach(() => {
-    ReactDOMTestUtils.act(() => {
-      // eslint-disable-next-line react/no-deprecated
-      ReactDOM.unmountComponentAtNode(container!);
-    });
-    container!.parentElement!.removeChild(container!);
-    container = null;
-  });
-
-  const mountWithContext = function mountWithContext(
-    node: React.ReactElement<any>,
-    localOptions: Omit<CreateMountOptions, 'mount'> = {},
-  ) {
-    const { strict = globalStrict, ...localEnzymeOptions } = localOptions;
-
-    if (container === null) {
-      throw new Error(
-        `Tried to mount without setup. Mounting inside before() is not allowed. Try mounting in beforeEach or better: in each test`,
-      );
-    }
-    ReactDOMTestUtils.act(() => {
-      // eslint-disable-next-line react/no-deprecated
-      ReactDOM.unmountComponentAtNode(container!);
-    });
-
-    // some tests require that no other components are in the tree
-    // for example when doing .instance(), .state() etc.
-    const wrapper = mount(
-      strict == null ? node : <Mode __element={node} __strict={Boolean(strict)} />,
-      {
-        attachTo: container,
-        ...globalEnzymeOptions,
-        ...localEnzymeOptions,
-      },
-    );
-    const originalUnmount = wrapper.unmount;
-
-    wrapper.unmount = () => {
-      // flush effect cleanup functions
-      ReactDOMTestUtils.act(() => {
-        originalUnmount.call(wrapper);
-      });
-
-      return wrapper;
-    };
-
-    return wrapper;
-  };
-
-  return mountWithContext;
-}

package/src/findOutermostIntrinsic.test.js

@@ -1,68 +0,0 @@
-import * as React from 'react';
-import { expect } from 'chai';
-import createMount from './createMount';
-import findOutermostIntrinsic from './findOutermostIntrinsic';
-
-describe('findOutermostIntrinsic', () => {
-  const mount = createMount({ strict: null });
-  const expectIntrinsic = (node, expected) => {
-    const wrapper = mount(node);
-    const outermostIntrinsic = findOutermostIntrinsic(wrapper);
-
-    if (expected === null) {
-      expect(outermostIntrinsic.exists()).to.equal(false);
-    } else {
-      expect(outermostIntrinsic.type()).to.equal(expected);
-      expect(outermostIntrinsic.type()).to.equal(
-        outermostIntrinsic.getDOMNode().nodeName.toLowerCase(),
-      );
-    }
-  };
-  const Headless = ({ children }) => children;
-
-  it('returns immediate DOM nodes', () => {
-    expectIntrinsic(<div>Hello, World!</div>, 'div');
-  });
-
-  it('only returns the outermost', () => {
-    expectIntrinsic(
-      <span>
-        <div>Hello, World!</div>
-      </span>,
-      'span',
-    );
-  });
-
-  it('ignores components', () => {
-    expectIntrinsic(
-      <Headless>
-        <div>Hello, World!</div>
-      </Headless>,
-      'div',
-    );
-    expectIntrinsic(
-      <Headless>
-        <Headless>
-          <div>Hello, World!</div>
-        </Headless>
-      </Headless>,
-      'div',
-    );
-    expectIntrinsic(
-      <Headless>
-        <Headless>
-          <div>
-            <Headless>
-              <span>Hello, World!</span>
-            </Headless>
-          </div>
-        </Headless>
-      </Headless>,
-      'div',
-    );
-  });
-
-  it('can handle that no DOM node is rendered', () => {
-    expectIntrinsic(<Headless>{false && <Headless />}</Headless>, null);
-  });
-});

package/src/findOutermostIntrinsic.ts

@@ -1,19 +0,0 @@
-import { ReactWrapper } from 'enzyme';
-
-/**
- * checks if a given react wrapper wraps an intrinsic element i.e. a DOM node
- * @param {import('enzyme').ReactWrapper} reactWrapper
- * @returns {boolean} true if the given reactWrapper wraps an intrinsic element
- */
-export function wrapsIntrinsicElement(reactWrapper: ReactWrapper): boolean {
-  return typeof reactWrapper.type() === 'string';
-}
-
-/**
- * like ReactWrapper#getDOMNode() but returns a ReactWrapper
- * @param {import('enzyme').ReactWrapper} reactWrapper
- * @returns {import('enzyme').ReactWrapper} the wrapper for the outermost DOM node
- */
-export default function findOutermostIntrinsic(reactWrapper: ReactWrapper): ReactWrapper {
-  return reactWrapper.findWhere((n) => n.exists() && wrapsIntrinsicElement(n)).first();
-}

package/src/until.js

@@ -1,28 +0,0 @@
-function shallowRecursively(wrapper, selector, { context, ...other }) {
-  if (wrapper.isEmptyRender() || typeof wrapper.getElement().type === 'string') {
-    return wrapper;
-  }
-
-  let newContext = context;
-
-  const instance = wrapper.root().instance();
-  // The instance can be null with a stateless functional component and react >= 16.
-  if (instance && instance.getChildContext) {
-    newContext = {
-      ...context,
-      ...instance.getChildContext(),
-    };
-  }
-
-  const nextWrapper = wrapper.shallow({ context: newContext, ...other });
-
-  if (selector && wrapper.is(selector)) {
-    return nextWrapper;
-  }
-
-  return shallowRecursively(nextWrapper, selector, { context: newContext });
-}
-
-export default function until(selector, options = {}) {
-  return this.single('until', () => shallowRecursively(this, selector, options));
-}

package/src/until.test.js

@@ -1,120 +0,0 @@
-import * as React from 'react';
-import { expect } from 'chai';
-import PropTypes from 'prop-types';
-import { shallow } from 'enzyme';
-import until from './until';
-
-function Div() {
-  return <div />;
-}
-const hoc = (Component) =>
-  function Wrapper() {
-    return <Component />;
-  };
-
-describe('until', () => {
-  it('shallow renders the current wrapper one level deep', () => {
-    const EnhancedDiv = hoc(Div);
-    const wrapper = until.call(shallow(<EnhancedDiv />), 'Div');
-    expect(wrapper.contains(<div />)).to.equal(true);
-  });
-
-  it('shallow renders the current wrapper several levels deep', () => {
-    const EnhancedDiv = hoc(hoc(hoc(Div)));
-    const wrapper = until.call(shallow(<EnhancedDiv />), 'Div');
-    expect(wrapper.contains(<div />)).to.equal(true);
-  });
-
-  it('stops shallow rendering when the wrapper is empty', () => {
-    const nullHoc = () => () => null;
-    const EnhancedDiv = nullHoc();
-    const wrapper = until.call(shallow(<EnhancedDiv />), 'Div');
-    expect(wrapper.html()).to.equal(null);
-  });
-
-  it('shallow renders as much as possible when no selector is provided', () => {
-    const EnhancedDiv = hoc(hoc(Div));
-    const wrapper = until.call(shallow(<EnhancedDiv />));
-    expect(wrapper.contains(<div />)).to.equal(true);
-  });
-
-  it('shallow renders the current wrapper even if the selector never matches', () => {
-    const EnhancedDiv = hoc(Div);
-    const wrapper = until.call(shallow(<EnhancedDiv />), 'NotDiv');
-    expect(wrapper.contains(<div />)).to.equal(true);
-  });
-
-  it('stops shallow rendering when it encounters a HTML element', () => {
-    const wrapper = until.call(
-      shallow(
-        <div>
-          <Div />
-        </div>,
-      ),
-      'Div',
-    );
-    expect(
-      wrapper.contains(
-        <div>
-          <Div />
-        </div>,
-      ),
-    ).to.equal(true);
-  });
-
-  it('throws when until called on an empty wrapper', () => {
-    expect(() => {
-      until.call(shallow(<Div />).find('Foo'), 'div');
-    }).to.throw(Error);
-  });
-
-  it('shallow renders non-root wrappers', () => {
-    function Container() {
-      return (
-        <div>
-          <Div />
-        </div>
-      );
-    }
-    const wrapper = until.call(shallow(<Container />).find(Div));
-    expect(wrapper.contains(<div />)).to.equal(true);
-  });
-
-  // eslint-disable-next-line react/prefer-stateless-function
-  class Foo extends React.Component {
-    render() {
-      return <Div />;
-    }
-  }
-
-  Foo.contextTypes = {
-    quux: PropTypes.bool.isRequired,
-  };
-
-  it('context propagation passes down context from the root component', () => {
-    const EnhancedFoo = hoc(Foo);
-    const options = { context: { quux: true } };
-    const wrapper = until.call(shallow(<EnhancedFoo />, options), 'Foo', options);
-    expect(wrapper.context('quux')).to.equal(true);
-    expect(wrapper.contains(<Div />)).to.equal(true);
-  });
-
-  class Bar extends React.Component {
-    static childContextTypes = { quux: PropTypes.bool };
-
-    getChildContext() {
-      return { quux: true };
-    }
-
-    render() {
-      return <Foo />;
-    }
-  }
-
-  it('context propagation passes down context from an intermediary component', () => {
-    const EnhancedBar = hoc(Bar);
-    const wrapper = until.call(shallow(<EnhancedBar />), 'Foo');
-    expect(wrapper.context('quux')).to.equal(true);
-    expect(wrapper.contains(<Div />)).to.equal(true);
-  });
-});