@mui/internal-test-utils 2.0.15 → 2.0.16

package/src/describeSkipIf.tsx

@@ -1,11 +0,0 @@
-import type { PendingSuiteFunction } from 'mocha';
-
-// Shim for vitest describe.skipIf to be able to run mocha and vitest side-by-side
-// TODO: Remove after migration to vitest is complete
-const describeSkipIf: (condition: boolean) => PendingSuiteFunction =
-  (describe as any).skipIf ??
-  function describeSkipIf(condition: boolean) {
-    return condition ? describe.skip : describe;
-  };
-
-export default describeSkipIf;

package/src/index.ts

@@ -1,25 +0,0 @@
-import * as React from 'react';
-
-export * from './components';
-export { default as describeConformance } from './describeConformance';
-export * from './describeConformance';
-export { default as createDescribe } from './createDescribe';
-export * from './createRenderer';
-export {
-  default as focusVisible,
-  simulatePointerDevice,
-  simulateKeyboardDevice,
-  programmaticFocusTriggersFocusVisible,
-} from './focusVisible';
-export {} from './initMatchers';
-export * as fireDiscreteEvent from './fireDiscreteEvent';
-export { default as flushMicrotasks } from './flushMicrotasks';
-export { default as reactMajor } from './reactMajor';
-
-/**
- * Set to true if console logs during [lifecycles that are invoked twice in `React.StrictMode`](https://reactjs.org/docs/strict-mode.html#detecting-unexpected-side-effects) are suppressed.
- * Useful for asserting on `console.warn` or `console.error` via `toErrorDev()`.
- * TODO: Refactor to use reactMajor when fixing the React 17 cron test.
- * https://github.com/mui/material-ui/issues/43153
- */
-export const strictModeDoubleLoggingSuppressed = React.version.startsWith('17');

package/src/initMatchers.test.js

@@ -1,124 +0,0 @@
-import { expect } from 'chai';
-import { createSandbox } from 'sinon';
-
-describe('custom matchers', () => {
-  const consoleSandbox = createSandbox();
-
-  beforeEach(() => {
-    // otherwise our global setup throws on unexpected calls in afterEach
-    consoleSandbox.stub(console, 'warn');
-    consoleSandbox.stub(console, 'error');
-  });
-
-  afterEach(() => {
-    consoleSandbox.restore();
-  });
-
-  describe('toErrorDev()', () => {
-    it('passes if the message is exactly the same', () => {
-      expect(() => console.error('expected message')).toErrorDev('expected message');
-    });
-
-    it('passes if the message is a subset', () => {
-      expect(() => console.error('expected message')).toErrorDev('pected messa');
-    });
-
-    it('passes if multiple messages are expected', () => {
-      expect(() => {
-        console.error('expected message');
-        console.error('another message');
-      }).toErrorDev(['expected message', 'another message']);
-    });
-
-    it("fails if an expected console.error call wasn't recorded with a useful stacktrace", () => {
-      let caughtError;
-      try {
-        console.error('expected message');
-        expect(() => {}).toErrorDev('expected message');
-      } catch (error) {
-        caughtError = error;
-      }
-
-      expect(caughtError).to.have.property('stack');
-      expect(caughtError.stack).to.include(
-        'Could not match the following console.error calls. ' +
-          "Make sure previous actions didn't call console.error by wrapping them in expect(() => {}).not.toErrorDev(): \n\n" +
-          '  - "expected message"\n',
-      );
-      // check that the top stackframe points to this test
-      // if this test is moved to another file the next assertion fails
-      expect(caughtError.stack).to.match(
-        /- "expected message"\s+at .*\/initMatchers\.test\.js:\d+:\d+/,
-      );
-    });
-
-    it('is case sensitive', () => {
-      let caughtError;
-      try {
-        expect(() => console.error('expected Message')).toErrorDev('expected message');
-      } catch (error) {
-        caughtError = error;
-      }
-
-      expect(caughtError).to.have.property('stack');
-      expect(caughtError.stack).to.include(
-        'Recorded unexpected console.error calls: \n\n' +
-          '  - Expected #1 "expected message" to be included in \n' +
-          '"expected Message"\n',
-      );
-      // check that the top stackframe points to this test
-      // if this test is moved to another file the next assertion fails
-      expect(caughtError.stack).to.match(
-        /"expected Message"\s+at .*\/initMatchers\.test\.js:\d+:\d+/,
-      );
-    });
-
-    it('fails if the order of calls does not match', () => {
-      expect(() => {
-        expect(() => {
-          console.error('another message');
-          console.error('expected message');
-        }).toErrorDev(['expected message', 'another message']);
-      }).to.throw('Recorded unexpected console.error calls');
-    });
-
-    it('fails if there are fewer messages than expected', () => {
-      expect(() => {
-        expect(() => {
-          console.error('expected message');
-        }).toErrorDev(['expected message', 'another message']);
-      }).to.throw('Could not match the following console.error calls');
-    });
-
-    it('passes if no messages were recorded if expected', () => {
-      expect(() => {}).not.toErrorDev();
-      expect(() => {}).not.toErrorDev([]);
-    });
-
-    it('fails if no arguments are used as a way of negating', () => {
-      expect(() => {
-        expect(() => {}).toErrorDev();
-      }).to.throw(
-        "Expected to call console.error but didn't provide messages. " +
-          "If you don't expect any messages prefer `expect().not.toErrorDev();",
-      );
-    });
-
-    it('fails if arguments are passed when negated', () => {
-      expect(() => {
-        expect(() => {}).not.toErrorDev('not unexpected?');
-      }).to.throw(
-        'Expected no call to console.error but provided messages. ' +
-          "If you want to make sure a certain message isn't logged prefer the positive. " +
-          'By expecting certain messages you automatically expect that no other messages are logged',
-      );
-    });
-
-    it('ignores `false` messages', () => {
-      const isReact16 = false;
-      expect(() => {
-        expect(() => {}).toErrorDev([isReact16 && 'some legacy error message']);
-      }).not.to.throw();
-    });
-  });
-});

package/src/initMatchers.ts

@@ -1,7 +0,0 @@
-import * as chai from 'chai';
-import chaiDom from 'chai-dom';
-import './chai.types';
-import chaiPlugin from './chaiPlugin';
-
-chai.use(chaiDom);
-chai.use(chaiPlugin);

package/src/initPlaywrightMatchers.ts

@@ -1,101 +0,0 @@
-import * as chai from 'chai';
-import * as DomTestingLibrary from '@testing-library/dom';
-import type { ElementHandle } from '@playwright/test';
-
-// https://stackoverflow.com/a/46755166/3406963
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace Chai {
-    interface Assertion {
-      /**
-       * Checks if the element handle is actually focused i.e. the element handle is pointing to `document.activeElement`.
-       */
-      toHaveFocus(): Promise<void>;
-      /**
-       * Checks if the element handle has the given attribute.
-       * @example expect($element).toHaveAttribute('aria-expanded') is like `[aria-expanded]` CSS selector
-       * @example expect($element).toHaveAttribute('aria-expanded', 'true') is like `[aria-expanded="true"]` CSS selector
-       */
-      toHaveAttribute(attributeName: string, attributeValue?: string): Promise<void>;
-    }
-  }
-
-  interface Window {
-    DomTestingLibrary: typeof DomTestingLibrary;
-    /**
-     * @example $element.evaluate(element => window.pageElementToString(element))
-     */
-    elementToString(element: Node | null | undefined): string | false;
-  }
-}
-
-chai.use((chaiAPI, utils) => {
-  chai.Assertion.addMethod('toHaveFocus', async function elementHandleIsFocused() {
-    const $elementOrHandle: ElementHandle | Promise<ElementHandle> = utils.flag(this, 'object');
-    if ($elementOrHandle == null) {
-      throw new chai.AssertionError(
-        `Expected an element handle but got ${String($elementOrHandle)}.`,
-      );
-    }
-    const $element =
-      typeof ($elementOrHandle as Promise<any>).then === 'function'
-        ? await ($elementOrHandle as Promise<ElementHandle>)
-        : ($elementOrHandle as ElementHandle);
-
-    const { isFocused, stringifiedActiveElement, stringifiedElement } = await $element.evaluate(
-      (element) => {
-        const activeElement =
-          element.ownerDocument !== null ? element.ownerDocument.activeElement : null;
-        return {
-          isFocused: activeElement === element,
-          stringifiedElement: window.elementToString(element),
-          stringifiedActiveElement: window.elementToString(activeElement),
-        };
-      },
-    );
-
-    this.assert(
-      isFocused,
-      `expected element to have focus`,
-      `expected element to NOT have focus \n${stringifiedElement}`,
-      stringifiedElement,
-      stringifiedActiveElement,
-    );
-  });
-
-  chai.Assertion.addMethod(
-    'toHaveAttribute',
-    async function elementHandleHasAttribute(attributeName: string, attributeValue?: string) {
-      const $elementOrHandle: ElementHandle | Promise<ElementHandle> = utils.flag(this, 'object');
-      if ($elementOrHandle == null) {
-        throw new chai.AssertionError(
-          `Expected an element handle but got ${String($elementOrHandle)}.`,
-        );
-      }
-      const $element =
-        typeof ($elementOrHandle as Promise<any>).then === 'function'
-          ? await ($elementOrHandle as Promise<ElementHandle>)
-          : ($elementOrHandle as ElementHandle);
-
-      const actualAttributeValue = await $element.getAttribute(attributeName);
-
-      if (attributeValue === undefined) {
-        this.assert(
-          actualAttributeValue !== null,
-          `expected element to have attribute \`${attributeName}\``,
-          `expected element to NOT have attribute \`${attributeName}\``,
-          null,
-          null,
-        );
-      } else {
-        this.assert(
-          actualAttributeValue === attributeValue,
-          `expected element to have attribute \`${attributeName}="${attributeValue}"\``,
-          `expected element to NOT have attribute \`${attributeName}="${attributeValue}"\``,
-          attributeValue,
-          actualAttributeValue,
-        );
-      }
-    },
-  );
-});

package/src/mochaHooks.js

@@ -1,200 +0,0 @@
-// @ts-check
-const formatUtil = require('format-util');
-
-/**
- * @typedef {(this: import('mocha').Context) => void} MochaHook
- *
- * @typedef {object} MochaHooks
- * @property {MochaHook[]} beforeAll
- * @property {MochaHook[]} afterAll
- * @property {MochaHook[]} beforeEach
- * @property {MochaHook[]} afterEach
- *
- * @typedef {object} Mocha -- custom definition for `const mocha = require('mocha')`
- * @property {import('mocha').utils} utils
- */
-
-const isKarma = Boolean(process.env.KARMA);
-
-/**
- * Polyfills for https://github.com/facebook/react/issues/19416.
- * @param {[stack: string, message: string][]} consoleCalls
- * @returns {[stack: string, message: string][]}
- */
-function dedupeActWarningsByComponent(consoleCalls) {
-  /**
-   * @type {[stack: string, message: string][]}
-   */
-  const dedupedCalls = [];
-
-  /**
-   * @type {string | undefined}
-   */
-  let updatingComponentOutsideAct;
-
-  consoleCalls.forEach(([stack, message]) => {
-    const componentName = message.match(
-      /An update to (.+?) ran an effect, but was not wrapped in act/,
-    )?.[1];
-
-    const duplicateMissingActWarning =
-      componentName !== undefined && componentName === updatingComponentOutsideAct;
-    if (!duplicateMissingActWarning) {
-      dedupedCalls.push([stack, message]);
-    }
-    updatingComponentOutsideAct = componentName;
-  });
-
-  return dedupedCalls;
-}
-
-/**
- * @param {Mocha} Mocha
- * @param {'warn' | 'error'} methodName
- * @param {string} expectedMatcher
- * @returns MochaHooks
- */
-function createUnexpectedConsoleMessagesHooks(Mocha, methodName, expectedMatcher) {
-  /**
-   * @type {MochaHooks}
-   */
-  const mochaHooks = {
-    beforeAll: [],
-    afterAll: [],
-    beforeEach: [],
-    afterEach: [],
-  };
-  /**
-   * @type {[stack: string, message: string][]}
-   */
-  const unexpectedCalls = [];
-  const stackTraceFilter = Mocha.utils.stackTraceFilter();
-
-  /**
-   * @param {string} format
-   * @param  {...unknown} args
-   * @returns {void}
-   */
-  function logUnexpectedConsoleCalls(format, ...args) {
-    const message = formatUtil(format, ...args);
-
-    // Safe stack so that test dev can track where the unexpected console message was created.
-    const { stack } = new Error();
-    if (stack === undefined) {
-      throw new TypeError(
-        `Unable to get stack. Logging unexpected console calls is only supported in environments where Error.prototype.stack is implemented.`,
-      );
-    }
-
-    if (process.env.NODE_ENV === 'production') {
-      // TODO: mock scheduler
-      if (message.includes('act(...) is not supported in production builds of React')) {
-        return;
-      }
-    }
-
-    if (message.includes('Warning: useLayoutEffect does nothing on the server')) {
-      // Controversial warning that is commonly ignored by switching to `useEffect` on the server.
-      // https://github.com/facebook/react/issues/14927
-      // However, this switch doesn't work since it relies on environment sniffing and we test SSR in a browser environment.
-      return;
-    }
-
-    // Unclear why this is an issue for the current occurrences of this warning.
-    // TODO: Revisit once https://github.com/facebook/react/issues/22796 is resolved
-    if (
-      message.includes(
-        'Detected multiple renderers concurrently rendering the same context provider.',
-      )
-    ) {
-      return;
-    }
-
-    unexpectedCalls.push([
-      // first line includes the (empty) error message
-      // i.e. Remove the `Error:` line
-      // second line is this frame
-      stackTraceFilter(stack.split('\n').slice(2).join('\n')),
-      message,
-    ]);
-  }
-
-  /**
-   * @type {Console['warn' | 'error']}
-   */
-  let originalConsoleMethod;
-  mochaHooks.beforeAll.push(function registerConsoleStub() {
-    // eslint-disable-next-line no-console
-    originalConsoleMethod = console[methodName];
-    // eslint-disable-next-line no-console
-    console[methodName] = logUnexpectedConsoleCalls;
-  });
-
-  mochaHooks.afterAll.push(function registerConsoleStub() {
-    // eslint-disable-next-line no-console
-    console[methodName] = originalConsoleMethod;
-  });
-
-  mochaHooks.afterEach.push(function flushUnexpectedCalls() {
-    const actionableCalls = dedupeActWarningsByComponent(unexpectedCalls);
-    const actionableCallCount = actionableCalls.length;
-    const formattedCalls = actionableCalls.map(
-      ([stack, message], index) =>
-        `console.${methodName} message #${index + 1}:\n  ${message}\n\nStack:\n${stack}`,
-    );
-    unexpectedCalls.length = 0;
-
-    // eslint-disable-next-line no-console
-    if (console[methodName] !== logUnexpectedConsoleCalls) {
-      throw new Error(`Did not tear down spy or stub of console.${methodName} in your test.`);
-    }
-    if (actionableCallCount > 0) {
-      // In karma `file` is `null`.
-      // We still have the stacktrace though
-      // @ts-expect-error -- this.currentTest being undefined would be a bug
-      const location = this.currentTest.file ?? '(unknown file)';
-      const message =
-        `Expected test not to call console.${methodName}() but instead received ${actionableCallCount} calls.\n\n` +
-        'If the warning is expected, test for it explicitly by ' +
-        // Don't add any punctuation after the location.
-        // Otherwise it's not clickable in IDEs
-        `using the ${expectedMatcher}() matcher.\nTest location:\n  ${location} `;
-
-      const error = new Error(`${message}\n\n${formattedCalls.join('\n\n')}`);
-      // The stack of `flushUnexpectedCalls` is irrelevant.
-      // It includes no clue where the test was triggered
-      error.stack = '';
-
-      if (isKarma) {
-        // @ts-expect-error -- this.currentTest being undefined would be a bug
-        const testPath = `"${this.currentTest.fullTitle()}"`;
-
-        error.message += `\n\nin ${testPath}`;
-        throw error;
-      } else {
-        // @ts-expect-error -- this.test being undefined would be a bug
-        this.test.error(error);
-      }
-    }
-  });
-
-  return mochaHooks;
-}
-
-/**
- * @param {Mocha} Mocha
- * @returns MochaHooks
- */
-function createMochaHooks(Mocha) {
-  const warnHooks = createUnexpectedConsoleMessagesHooks(Mocha, 'warn', 'toWarnDev');
-  const errorHooks = createUnexpectedConsoleMessagesHooks(Mocha, 'error', 'toErrorDev');
-
-  return {
-    beforeAll: [...warnHooks.beforeAll, ...errorHooks.beforeAll],
-    afterAll: [...warnHooks.afterAll, ...errorHooks.afterAll],
-    beforeEach: [...warnHooks.beforeEach, ...errorHooks.beforeEach],
-    afterEach: [...warnHooks.afterEach, ...errorHooks.afterEach],
-  };
-}
-
-module.exports = { createMochaHooks };

package/src/mochaHooks.test.js

@@ -1,116 +0,0 @@
-import * as Mocha from 'mocha';
-import { expect } from 'chai';
-import * as React from 'react';
-import { stub } from 'sinon';
-import { createMochaHooks } from './mochaHooks';
-import { createRenderer, act } from './createRenderer';
-import describeSkipIf from './describeSkipIf';
-
-describeSkipIf(process.env.VITEST)('mochaHooks', () => {
-  // one block per hook.
-  describe('afterEach', () => {
-    describe('on unexpected console.(warn|error) in afterEach', function suite() {
-      const mochaHooks = createMochaHooks(Mocha);
-
-      beforeEach(function beforeEachHook() {
-        mochaHooks.beforeAll.forEach((beforeAllMochaHook) => {
-          beforeAllMochaHook.call(this);
-        });
-        mochaHooks.beforeEach.forEach((beforeEachMochaHook) => {
-          beforeEachMochaHook.call(this);
-        });
-      });
-
-      it('throws an error', () => {
-        console.warn('unexpected warning');
-        console.error('unexpected error');
-      });
-
-      afterEach(function afterEachHook() {
-        const errorStub = stub(this.test, 'error');
-        mochaHooks.afterEach.forEach((afterEachMochaHook) => {
-          afterEachMochaHook.call(this);
-        });
-        mochaHooks.afterAll.forEach((afterAllMochaHook) => {
-          afterAllMochaHook.call(this);
-        });
-
-        expect(errorStub.callCount).to.equal(2);
-        expect(String(errorStub.firstCall.args[0])).to.include(
-          'console.warn message #1:\n  unexpected warning\n\nStack:',
-        );
-        expect(String(errorStub.secondCall.args[0])).to.include(
-          'console.error message #1:\n  unexpected error\n\nStack:',
-        );
-      });
-    });
-
-    // TODO: May not be relevant in React 18
-    describe('when having missing act() warnings by component', () => {
-      const mochaHooks = createMochaHooks(Mocha);
-      // missing act warnings only happen in StrictMode
-      const { render } = createRenderer({ strict: true });
-
-      beforeEach(function beforeEachHook() {
-        mochaHooks.beforeAll.forEach((beforeAllMochaHook) => {
-          beforeAllMochaHook.call(this);
-        });
-        mochaHooks.beforeEach.forEach((beforeEachMochaHook) => {
-          beforeEachMochaHook.call(this);
-        });
-      });
-
-      it('dedupes them', () => {
-        const Child = React.forwardRef(function Child() {
-          React.useEffect(() => {});
-          React.useEffect(() => {});
-          return null;
-        });
-
-        let unsafeSetState;
-        function Parent() {
-          const [state, setState] = React.useState(0);
-          // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- unsafeSetState is required outside the component
-          unsafeSetState = setState;
-
-          React.useEffect(() => {});
-          React.useEffect(() => {});
-
-          return <Child rerender={state} />;
-        }
-
-        render(<Parent />);
-
-        // not wrapped in act()
-        unsafeSetState(1);
-        // make sure effects are flushed
-        // eslint-disable-next-line testing-library/no-unnecessary-act
-        act(() => {});
-      });
-
-      afterEach(function afterEachHook() {
-        const errorStub = stub(this.test, 'error');
-        mochaHooks.afterEach.forEach((afterEachMochaHook) => {
-          afterEachMochaHook.call(this);
-        });
-        mochaHooks.afterAll.forEach((afterAllMochaHook) => {
-          afterAllMochaHook.call(this);
-        });
-
-        expect(errorStub.callCount).to.equal(1);
-        const error = String(errorStub.firstCall.args[0]);
-        expect(
-          error.match(/An update to Parent inside a test was not wrapped in act/g),
-        ).to.have.lengthOf(1);
-        expect(
-          error.match(/An update to Parent ran an effect, but was not wrapped in act/g) ?? [],
-        ).to.have.lengthOf(React.startTransition !== undefined ? 0 : 1);
-        expect(
-          error.match(
-            /An update to ForwardRef\(Child\) ran an effect, but was not wrapped in act/g,
-          ) ?? [],
-        ).to.have.lengthOf(React.startTransition !== undefined ? 0 : 1);
-      });
-    });
-  });
-});

package/src/reactMajor.ts

@@ -1,3 +0,0 @@
-import * as React from 'react';
-
-export default parseInt(React.version, 10);

package/src/setupBabel.js

@@ -1,3 +0,0 @@
-require('@babel/register')({
-  extensions: ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx'],
-});

package/src/setupBabelPlaywright.js

@@ -1,13 +0,0 @@
-// In playwright we sometimes write functions that are executed in the browser environment.
-// Since we can't tell babel which parts of the code are executed in which environment we can only disable it entirely.
-// We're only stripping types and compiling ES6 to CommonJS modules which should be safe.
-
-require('@babel/register')({
-  configFile: false,
-  extensions: ['.js', '.ts', '.tsx'],
-  presets: [require.resolve('@babel/preset-typescript')],
-  plugins: [
-    require.resolve('@babel/plugin-transform-modules-commonjs'),
-    require.resolve('babel-plugin-transform-import-meta'),
-  ],
-});

package/src/setupJSDOM.js

@@ -1,20 +0,0 @@
-const testingLibrary = require('@testing-library/dom');
-const Mocha = require('mocha');
-const createDOM = require('./createDOM');
-const { createMochaHooks } = require('./mochaHooks');
-
-// Enable missing act warnings: https://github.com/reactwg/react-18/discussions/102
-globalThis.jest = null;
-globalThis.IS_REACT_ACT_ENVIRONMENT = true;
-
-createDOM();
-require('./init');
-
-testingLibrary.configure({
-  // JSDOM logs errors otherwise on `getComputedStyle(element, pseudoElement)` calls.
-  computedStyleSupportsPseudoElements: false,
-});
-
-const mochaHooks = createMochaHooks(Mocha);
-
-module.exports = { mochaHooks };