@instructure/ui-checkbox 8.46.2-snapshot-0 → 8.46.2-snapshot-2

package/CHANGELOG.md

@@ -3,9 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [8.46.2-snapshot-0](https://github.com/instructure/instructure-ui/compare/v8.46.1...v8.46.2-snapshot-0) (2023-10-13)
+## [8.46.2-snapshot-2](https://github.com/instructure/instructure-ui/compare/v8.46.1...v8.46.2-snapshot-2) (2023-10-17)
 
-**Note:** Version bump only for package @instructure/ui-checkbox
+
+### Bug Fixes
+
+* **ui-checkbox,ui-spinner:** remove hover highlight from disabled checkbox ([3fe755f](https://github.com/instructure/instructure-ui/commit/3fe755f65127e3bd18a7ff2a2d974b386ab831b0))
 
 
 

package/es/Checkbox/{locator.js → CheckboxFacade/__new-tests__/CheckboxFacade.test.js}

@@ -1,3 +1,4 @@
+var _CheckboxFacade, _CheckboxFacade2;
 /*
  * The MIT License (MIT)
  *
@@ -22,6 +23,22 @@
  * SOFTWARE.
  */
 
-import { CheckboxLocator } from './CheckboxLocator';
-export { CheckboxLocator };
-export default CheckboxLocator;
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import { runAxeCheck } from '@instructure/ui-axe-check';
+import { CheckboxFacade } from '../index';
+const TEST_TEXT = 'test-text';
+describe('<CheckboxFacade />', () => {
+  it('should render', () => {
+    render(_CheckboxFacade || (_CheckboxFacade = /*#__PURE__*/React.createElement(CheckboxFacade, null, TEST_TEXT)));
+    const facade = screen.getByText(TEST_TEXT);
+    expect(facade).toBeInTheDocument();
+  });
+  it('should meet a11y standards', async () => {
+    const _render = render(_CheckboxFacade2 || (_CheckboxFacade2 = /*#__PURE__*/React.createElement(CheckboxFacade, null, TEST_TEXT))),
+      container = _render.container;
+    const axeCheck = await runAxeCheck(container);
+    expect(axeCheck).toBe(true);
+  });
+});

package/es/Checkbox/{CheckboxLocator.js → ToggleFacade/__new-tests__/ToggleFacade.test.js}

@@ -1,3 +1,4 @@
+var _ToggleFacade, _ToggleFacade2;
 /*
  * The MIT License (MIT)
  *
@@ -22,8 +23,22 @@
  * SOFTWARE.
  */
 
-import { locator } from '@instructure/ui-test-locator';
-import { Checkbox } from './index';
-
-// @ts-expect-error ts-migrate(2339) FIXME: Property 'selector' does not exist on type 'typeof... Remove this comment to see the full error message
-export const CheckboxLocator = locator(Checkbox.selector);
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import '@testing-library/jest-dom/extend-expect';
+import { runAxeCheck } from '@instructure/ui-axe-check';
+import { ToggleFacade } from '../index';
+const TEST_TEXT = 'test-text';
+describe('<ToggleFacade />', () => {
+  it('should render', () => {
+    render(_ToggleFacade || (_ToggleFacade = /*#__PURE__*/React.createElement(ToggleFacade, null, TEST_TEXT)));
+    const facade = screen.getByText(TEST_TEXT);
+    expect(facade).toBeInTheDocument();
+  });
+  it('should meet a11y standards', async () => {
+    const _render = render(_ToggleFacade2 || (_ToggleFacade2 = /*#__PURE__*/React.createElement(ToggleFacade, null, TEST_TEXT))),
+      container = _render.container;
+    const axeCheck = await runAxeCheck(container);
+    expect(axeCheck).toBe(true);
+  });
+});

package/es/Checkbox/__new-tests__/Checkbox.test.js

@@ -0,0 +1,210 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import React from 'react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom/extend-expect';
+import { runAxeCheck } from '@instructure/ui-axe-check';
+import { Checkbox } from '../index';
+const TEST_VALUE = 'test-value';
+const TEST_NAME = 'test-name';
+const TEST_LABEL = 'test-label';
+const initProps = {
+  label: TEST_LABEL,
+  defaultChecked: true,
+  value: TEST_VALUE,
+  name: TEST_NAME
+};
+const renderCheckbox = props => {
+  const allProps = {
+    ...initProps,
+    ...props
+  };
+  return render( /*#__PURE__*/React.createElement(Checkbox, allProps));
+};
+describe('<Checkbox />', () => {
+  it('renders an input with type "checkbox"', () => {
+    renderCheckbox();
+    const inputElem = screen.getByRole('checkbox');
+    expect(inputElem).toBeInTheDocument();
+    expect(inputElem.tagName).toBe('INPUT');
+    expect(inputElem).toHaveAttribute('type', 'checkbox');
+  });
+  it('`simple` variant only displays a checkmark when checked', async () => {
+    const _renderCheckbox = renderCheckbox({
+        variant: 'simple',
+        defaultChecked: false
+      }),
+      container = _renderCheckbox.container;
+    const checkboxElement = container.querySelector('input[type="checkbox"]');
+    const svgElement = container.querySelector('svg');
+    expect(svgElement).not.toBeInTheDocument();
+    userEvent.click(checkboxElement);
+    await waitFor(() => {
+      const svgElementAfterClick = container.querySelector('svg');
+      expect(svgElementAfterClick).toBeInTheDocument();
+    });
+  });
+  it('`simple` variant supports indeterminate/mixed state', () => {
+    renderCheckbox({
+      variant: 'simple',
+      indeterminate: true
+    });
+    const inputElem = screen.getByRole('checkbox');
+    expect(inputElem).toBeInTheDocument();
+    expect(inputElem).toHaveAttribute('aria-checked', 'mixed');
+  });
+  describe('events', () => {
+    it('when clicked, fires onClick and onChange events', async () => {
+      const onClick = jest.fn();
+      const onChange = jest.fn();
+      renderCheckbox({
+        onClick,
+        onChange
+      });
+      const checkboxElement = screen.getByRole('checkbox');
+      userEvent.click(checkboxElement);
+      await waitFor(() => {
+        expect(onClick).toHaveBeenCalled();
+        expect(onChange).toHaveBeenCalled();
+      });
+    });
+    it('when clicked, does not call onClick or onChange when disabled', async () => {
+      const onClick = jest.fn();
+      const onChange = jest.fn();
+      renderCheckbox({
+        onClick,
+        onChange,
+        disabled: true
+      });
+      const checkboxElement = screen.getByRole('checkbox');
+      fireEvent.click(checkboxElement);
+      await waitFor(() => {
+        expect(onClick).not.toHaveBeenCalled();
+        expect(onChange).not.toHaveBeenCalled();
+        expect(checkboxElement).toBeDisabled();
+      });
+    });
+    it('when clicked, does not call onClick or onChange when readOnly', async () => {
+      const onClick = jest.fn();
+      const onChange = jest.fn();
+      renderCheckbox({
+        onClick,
+        onChange,
+        readOnly: true
+      });
+      const checkboxElement = screen.getByRole('checkbox');
+      fireEvent.click(checkboxElement);
+      await waitFor(() => {
+        expect(onClick).not.toHaveBeenCalled();
+        expect(onChange).not.toHaveBeenCalled();
+      });
+    });
+    it('calls onChange when enter key is pressed', async () => {
+      const onChange = jest.fn();
+      renderCheckbox({
+        onChange
+      });
+      const checkboxElement = screen.getByRole('checkbox');
+      userEvent.type(checkboxElement, '{enter}');
+      await waitFor(() => {
+        expect(onChange).toHaveBeenCalled();
+      });
+    });
+    it('responds to onBlur event', async () => {
+      const onBlur = jest.fn();
+      renderCheckbox({
+        onBlur
+      });
+      userEvent.tab();
+      userEvent.tab();
+      await waitFor(() => {
+        expect(onBlur).toHaveBeenCalled();
+      });
+    });
+    it('responds to onFocus event', async () => {
+      const onFocus = jest.fn();
+      renderCheckbox({
+        onFocus
+      });
+      userEvent.tab();
+      await waitFor(() => {
+        expect(onFocus).toHaveBeenCalled();
+      });
+    });
+    it('focuses with the focus helper', () => {
+      var _checkboxRef$current;
+      const checkboxRef = /*#__PURE__*/React.createRef();
+      render( /*#__PURE__*/React.createElement(Checkbox, Object.assign({
+        ref: checkboxRef
+      }, initProps)));
+      const checkboxElement = screen.getByRole('checkbox');
+      expect(checkboxElement).not.toHaveFocus();
+      (_checkboxRef$current = checkboxRef.current) === null || _checkboxRef$current === void 0 ? void 0 : _checkboxRef$current.focus();
+      expect(checkboxElement).toHaveFocus();
+    });
+    it('calls onMouseOver', async () => {
+      const onMouseOver = jest.fn();
+      renderCheckbox({
+        onMouseOver
+      });
+      const checkboxElement = screen.getByRole('checkbox');
+      userEvent.hover(checkboxElement);
+      await waitFor(() => {
+        expect(onMouseOver).toHaveBeenCalled();
+      });
+    });
+    it('calls onMouseOut', async () => {
+      const onMouseOut = jest.fn();
+      renderCheckbox({
+        onMouseOut
+      });
+      const checkboxElement = screen.getByRole('checkbox');
+      userEvent.hover(checkboxElement);
+      userEvent.unhover(checkboxElement);
+      await waitFor(() => {
+        expect(onMouseOut).toHaveBeenCalled();
+      });
+    });
+  });
+  describe('for a11y', () => {
+    it('`simple` variant should meet standards', async () => {
+      const _renderCheckbox2 = renderCheckbox({
+          variant: 'simple'
+        }),
+        container = _renderCheckbox2.container;
+      const axeCheck = await runAxeCheck(container);
+      expect(axeCheck).toBe(true);
+    });
+    it('`toggle` variant should meet standards', async () => {
+      const _renderCheckbox3 = renderCheckbox({
+          variant: 'toggle'
+        }),
+        container = _renderCheckbox3.container;
+      const axeCheck = await runAxeCheck(container);
+      expect(axeCheck).toBe(true);
+    });
+  });
+});

package/es/Checkbox/index.js

@@ -90,7 +90,7 @@ let Checkbox = (_dec = withDeterministicId(), _dec2 = withStyle(generateStyle, n
       });
     };
     this.handleMouseOver = () => {
-      this.setState({
+      !this.props.disabled && this.setState({
         hovered: true
       });
     };

package/es/CheckboxGroup/__new-tests__/CheckboxGroup.test.js

@@ -0,0 +1,196 @@
+var _Checkbox, _Checkbox2;
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 - present Instructure, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import React from 'react';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import '@testing-library/jest-dom/extend-expect';
+import { runAxeCheck } from '@instructure/ui-axe-check';
+import { CheckboxGroup } from '../index';
+import { Checkbox } from '../../Checkbox';
+const TEST_NAME = 'test-name';
+const TEST_DESCRIPTION = 'test-description';
+const TEST_ERROR_MESSAGE = 'test-error-message';
+const TEST_VALUE_1 = 'test-value-1';
+const TEST_VALUE_2 = 'test-value-2';
+const TEST_LABEL_1 = 'test-label-1';
+const TEST_LABEL_2 = 'test-label-2';
+const renderCheckboxGroup = props => {
+  const allProps = {
+    name: TEST_NAME,
+    description: TEST_DESCRIPTION,
+    ...props
+  };
+  return render( /*#__PURE__*/React.createElement(CheckboxGroup, allProps, _Checkbox || (_Checkbox = /*#__PURE__*/React.createElement(Checkbox, {
+    label: TEST_LABEL_1,
+    value: TEST_VALUE_1
+  })), _Checkbox2 || (_Checkbox2 = /*#__PURE__*/React.createElement(Checkbox, {
+    label: TEST_LABEL_2,
+    value: TEST_VALUE_2
+  }))));
+};
+describe('<CheckboxGroup />', () => {
+  it('adds the name props to all Checkbox types', () => {
+    renderCheckboxGroup({
+      name: TEST_NAME
+    });
+    const checkboxes = screen.getAllByRole('checkbox');
+    expect(checkboxes.length).toBe(2);
+    expect(checkboxes[0]).toHaveAttribute('name', TEST_NAME);
+    expect(checkboxes[1]).toHaveAttribute('name', TEST_NAME);
+  });
+  it('links the messages to the fieldset via aria-describedby', () => {
+    const _renderCheckboxGroup = renderCheckboxGroup({
+        messages: [{
+          text: TEST_ERROR_MESSAGE,
+          type: 'error'
+        }]
+      }),
+      container = _renderCheckboxGroup.container;
+    const fieldset = screen.getByRole('group');
+    const ariaDesc = fieldset.getAttribute('aria-describedby');
+    const messageById = container.querySelector(`[id="${ariaDesc}"]`);
+    expect(messageById).toBeInTheDocument();
+    expect(messageById).toHaveTextContent(TEST_ERROR_MESSAGE);
+  });
+  it('displays description message inside the legend', () => {
+    const _renderCheckboxGroup2 = renderCheckboxGroup({
+        description: TEST_DESCRIPTION
+      }),
+      container = _renderCheckboxGroup2.container;
+    const legend = container.querySelector('legend');
+    expect(legend).toBeInTheDocument();
+    expect(legend).toHaveTextContent(TEST_DESCRIPTION);
+  });
+  it('does not call the onChange prop when disabled', async () => {
+    const onChange = jest.fn();
+    renderCheckboxGroup({
+      onChange,
+      disabled: true
+    });
+    const checkboxElement = screen.getAllByRole('checkbox')[0];
+    fireEvent.click(checkboxElement);
+    await waitFor(() => {
+      expect(onChange).not.toHaveBeenCalled();
+      expect(checkboxElement).toBeDisabled();
+    });
+  });
+  it('does not call the onChange prop when readOnly', async () => {
+    const onChange = jest.fn();
+    renderCheckboxGroup({
+      onChange,
+      readOnly: true
+    });
+    const checkboxElement = screen.getAllByRole('checkbox')[0];
+    fireEvent.click(checkboxElement);
+    await waitFor(() => {
+      expect(onChange).not.toHaveBeenCalled();
+      expect(checkboxElement).toBeDisabled();
+    });
+  });
+  it('should not update the value when the value prop is set', async () => {
+    const onChange = jest.fn();
+    renderCheckboxGroup({
+      onChange,
+      value: ['tester']
+    });
+    const checkboxes = screen.getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toBeChecked();
+    expect(checkboxes[1]).not.toBeChecked();
+    userEvent.click(checkboxes[0]);
+    await waitFor(() => {
+      expect(onChange).not.toHaveBeenCalled();
+      expect(checkboxes[0]).not.toBeChecked();
+      expect(checkboxes[1]).not.toBeChecked();
+    });
+  });
+  it('should add the checkbox value to the value list when it is checked', async () => {
+    const onChange = jest.fn();
+    renderCheckboxGroup({
+      onChange
+    });
+    const checkboxes = screen.getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toBeChecked();
+    expect(checkboxes[1]).not.toBeChecked();
+    userEvent.click(checkboxes[0]);
+    userEvent.click(checkboxes[1]);
+    await waitFor(() => {
+      expect(checkboxes[0]).toBeChecked();
+      expect(checkboxes[1]).toBeChecked();
+      expect(onChange).toHaveBeenCalledWith([TEST_VALUE_1, TEST_VALUE_2]);
+    });
+  });
+  it('should check the checkboxes based on the defaultValue prop', () => {
+    const defaultValue = [TEST_VALUE_2];
+    renderCheckboxGroup({
+      defaultValue
+    });
+    const checkboxes = screen.getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toBeChecked();
+    expect(checkboxes[1]).toBeChecked();
+  });
+  it('should remove the checkbox value from the value list when it is unchecked', async () => {
+    const onChange = jest.fn();
+    const defaultValue = [TEST_VALUE_1, TEST_VALUE_2];
+    renderCheckboxGroup({
+      onChange,
+      defaultValue
+    });
+    const checkboxes = screen.getAllByRole('checkbox');
+    expect(checkboxes[0]).toBeChecked();
+    expect(checkboxes[1]).toBeChecked();
+    userEvent.click(checkboxes[0]);
+    await waitFor(() => {
+      expect(checkboxes[0]).not.toBeChecked();
+      expect(checkboxes[1]).toBeChecked();
+      expect(onChange).toHaveBeenCalledWith([TEST_VALUE_2]);
+    });
+  });
+  it('passes the array of selected values to onChange handler', async () => {
+    const onChange = jest.fn();
+    const defaultValue = [TEST_VALUE_2];
+    renderCheckboxGroup({
+      onChange,
+      defaultValue
+    });
+    const checkboxes = screen.getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toBeChecked();
+    expect(checkboxes[1]).toBeChecked();
+    userEvent.click(checkboxes[0]);
+    await waitFor(() => {
+      expect(checkboxes[0]).toBeChecked();
+      expect(checkboxes[1]).toBeChecked();
+      expect(onChange).toHaveBeenCalledWith([TEST_VALUE_2, TEST_VALUE_1]);
+    });
+  });
+  describe('for a11y', () => {
+    it('should meet standards', async () => {
+      const _renderCheckboxGroup3 = renderCheckboxGroup(),
+        container = _renderCheckboxGroup3.container;
+      const axeCheck = await runAxeCheck(container);
+      expect(axeCheck).toBe(true);
+    });
+  });
+});

package/lib/Checkbox/{locator.js → CheckboxFacade/__new-tests__/CheckboxFacade.test.js}

@@ -1,16 +1,12 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "CheckboxLocator", {
-  enumerable: true,
-  get: function () {
-    return _CheckboxLocator.CheckboxLocator;
-  }
-});
-exports.default = void 0;
-var _CheckboxLocator = require("./CheckboxLocator");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+require("@testing-library/jest-dom/extend-expect");
+var _runAxeCheck = require("@instructure/ui-axe-check/lib/runAxeCheck.js");
+var _index = require("../index");
+var _CheckboxFacade, _CheckboxFacade2;
 /*
  * The MIT License (MIT)
  *
@@ -34,5 +30,17 @@ var _CheckboxLocator = require("./CheckboxLocator");
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-var _default = _CheckboxLocator.CheckboxLocator;
-exports.default = _default;
+const TEST_TEXT = 'test-text';
+describe('<CheckboxFacade />', () => {
+  it('should render', () => {
+    (0, _react2.render)(_CheckboxFacade || (_CheckboxFacade = /*#__PURE__*/_react.default.createElement(_index.CheckboxFacade, null, TEST_TEXT)));
+    const facade = _react2.screen.getByText(TEST_TEXT);
+    expect(facade).toBeInTheDocument();
+  });
+  it('should meet a11y standards', async () => {
+    const _render = (0, _react2.render)(_CheckboxFacade2 || (_CheckboxFacade2 = /*#__PURE__*/_react.default.createElement(_index.CheckboxFacade, null, TEST_TEXT))),
+      container = _render.container;
+    const axeCheck = await (0, _runAxeCheck.runAxeCheck)(container);
+    expect(axeCheck).toBe(true);
+  });
+});

package/lib/Checkbox/{CheckboxLocator.js → ToggleFacade/__new-tests__/ToggleFacade.test.js}

@@ -1,11 +1,12 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CheckboxLocator = void 0;
-var _locator = require("@instructure/ui-test-locator/lib/utils/locator.js");
-var _index = require("./index");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+var _react = _interopRequireDefault(require("react"));
+var _react2 = require("@testing-library/react");
+require("@testing-library/jest-dom/extend-expect");
+var _runAxeCheck = require("@instructure/ui-axe-check/lib/runAxeCheck.js");
+var _index = require("../index");
+var _ToggleFacade, _ToggleFacade2;
 /*
  * The MIT License (MIT)
  *
@@ -29,7 +30,17 @@ var _index = require("./index");
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-
-// @ts-expect-error ts-migrate(2339) FIXME: Property 'selector' does not exist on type 'typeof... Remove this comment to see the full error message
-const CheckboxLocator = (0, _locator.locator)(_index.Checkbox.selector);
-exports.CheckboxLocator = CheckboxLocator;
+const TEST_TEXT = 'test-text';
+describe('<ToggleFacade />', () => {
+  it('should render', () => {
+    (0, _react2.render)(_ToggleFacade || (_ToggleFacade = /*#__PURE__*/_react.default.createElement(_index.ToggleFacade, null, TEST_TEXT)));
+    const facade = _react2.screen.getByText(TEST_TEXT);
+    expect(facade).toBeInTheDocument();
+  });
+  it('should meet a11y standards', async () => {
+    const _render = (0, _react2.render)(_ToggleFacade2 || (_ToggleFacade2 = /*#__PURE__*/_react.default.createElement(_index.ToggleFacade, null, TEST_TEXT))),
+      container = _render.container;
+    const axeCheck = await (0, _runAxeCheck.runAxeCheck)(container);
+    expect(axeCheck).toBe(true);
+  });
+});