testaro 60.11.0 → 60.13.0

package/testaro/hover-draft0.js

@@ -0,0 +1,110 @@
+/*
+  © 2021–2024 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2025 Jonathan Robert Pool. All rights reserved.
+
+  MIT License
+
+  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.
+*/
+
+/*
+  hover
+  This test reports unexpected impacts of hovering. The elements that are subjected to hovering
+  (called “triggers”) include all the elements that have ARIA attributes associated with control
+  over the visibility of other elements and all the elements that have onmouseenter or
+  onmouseover attributes, as well as a sample of all visible elements in the body. If hovering over
+  an element results in an increase or decrease in the total count of visible elements in the body,
+  the rule is considered violated.
+*/
+
+// IMPORTS
+
+const {doTest} = require('../procs/testaro');
+
+// FUNCTIONS
+
+exports.reporter = async (page, withItems) => {
+  const getBadWhat = element => {
+    let violationDescription;
+    const hoverEvent = new MouseEvent('mouseover', {
+      bubbles: true,
+      cancelable: true,
+      view: window
+    });
+    let timer;
+    // Create a mutation observer.
+    const observer = new MutationObserver(mutations => {
+      // When any mutation occurs in any other element(s):
+      const otherMutatedRecords = mutations.filter(
+        record => record.target !== element && record.target.getAttribute('role') !== 'tooltip'
+      );
+      // Update the count of mutated elements and the violation description.
+      const impactCount = otherMutatedRecords.length;
+      const impactWhat = impactCount === 1 ? '1 other element1' : `${impactCount} other elements`;
+      violationDescription = `Hovering over the element adds, removes, or changes ${impactWhat}`;
+      // Stop the observer.
+      observer.disconnect();
+      // Clear the timer.
+      clearTimeout(timer);
+    });
+    // Ensure that the mouse is in the home position.
+    document.body.dispatchEvent(hoverEvent);
+    // Start observing.
+    observer.observe(document.body, {
+      attributes: true,
+      subtree: true,
+      childList: true
+    });
+    // Start hovering over the element.
+    element.dispatchEvent(hoverEvent);
+    // In case no other elements were mutated within 200ms, stop the observer.
+    timer = setTimeout(() => {
+      observer.disconnect();
+    }, 200);
+    // If any other elements were mutated within 200ms:
+    if (violationDescription) {
+      // Return the violation description.
+      return violationDescription;
+    }
+  };
+  const selector = [
+   '[aria-controls]',
+   '[aria-expanded]',
+   '[aria-haspopup]',
+   '[onmouseenter]',
+   '[onmouseover]',
+   '[onmouseenter]',
+   '[onmouseover]',
+   '[role="menu"]',
+   '[role="menubar"]',
+   '[role="menuitem"]',
+   '[data-tooltip]',
+   '[data-popover]',
+   '[data-hover]',
+   '[data-menu]',
+   '[data-dropdown]',
+   '[role="tab"]',
+   '[role="combobox"]',
+   'li'
+  ].join(', ');
+  const whats = 'Hovering over elements adds, removes, or changes other elements';
+  return await doTest(
+    page, withItems, 'hover', selector, whats, 0, '', getBadWhat.toString()
+  );
+};

package/testaro/hover-draft1.js

@@ -0,0 +1,185 @@
+/*
+  © 2021–2024 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2025 Jonathan Robert Pool. All rights reserved.
+
+  MIT License
+
+  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.
+*/
+
+/*
+  hover
+  This test reports unexpected impacts of hovering. The elements that are subjected to hovering
+  (called “triggers”) include all the elements that have ARIA attributes associated with control
+  over the visibility of other elements and all the elements that have onmouseenter or
+  onmouseover attributes, as well as a sample of all visible elements in the body. If hovering over
+  an element results in an increase or decrease in the total count of visible elements in the body,
+  the rule is considered violated.
+*/
+
+// IMPORTS
+
+const {doTest} = require('../procs/testaro');
+
+// FUNCTIONS
+
+exports.reporter = async (page, withItems) => {
+  const getBadWhat = async element => {
+    const isVisible = element.checkVisibility({
+      contentVisibilityAuto: true,
+      opacityProperty: true,
+      visibilityProperty: true
+    });
+    // If the element is visible and is not a tooltip:
+    if (isVisible && element.getAttribute('role') !== 'tooltip') {
+      let timer;
+      let observer;
+      const options = {
+        bubbles: true,
+        cancelable: true,
+        view: window
+      };
+      const hoverEvents = [
+        new MouseEvent('mouseover', options),
+        new MouseEvent('mousemove', options),
+        new PointerEvent('pointerover', options),
+        new PointerEvent('pointermove', options)
+      ];
+      const {__lastHoveredElement} = window;
+      // Exit the prior hover location, if any.
+      if (__lastHoveredElement) {
+        [
+          [MouseEvent, 'mouseout', true],
+          [MouseEvent, 'mouseleave', false],
+          [PointerEvent, 'pointerout', true],
+          [PointerEvent, 'pointerleave', false]
+        ].forEach(([event, type, bubbles]) => {
+          __lastHoveredElement.dispatchEvent(new event(type, {bubbles}));
+        });
+      }
+      // Allow time for handlers of these events to complete execution.
+      await new Promise(resolve => setTimeout(resolve, 800));
+      // Check whether the visibility of the element was due solely to the prior hovering.
+      const isStillVisible = element.checkVisibility({
+        contentVisibilityAuto: true,
+        opacityProperty: true,
+        visibilityProperty: true
+      });
+      // If so:
+      if (isStillVisible) {
+        const observationStart = Date.now();
+        // Execute a Promise that resolves when a mutation is observed.
+        const mutationPromise = new Promise(resolve => {
+          // When mutations are observed:
+          observer = new MutationObserver(mutationRecords => {
+            const otherMutationRecords = mutationRecords.filter(record => {
+              const {target, type} = record;
+              return type !== 'childList'
+              && target !== element
+              && target.getAttribute('role') !== 'tooltip';
+            });
+            // If any are reportable:
+            if (otherMutationRecords.length) {
+              // Get a non-duplicative set of their types and XPaths.
+              const impacts = new Set();
+              otherMutationRecords.forEach(record => {
+                const {attributeName, target, type} = record;
+                const xPath = getXPath(target);
+                const attributeSuffix = attributeName ? `:${attributeName}` : '';
+                const textStart = target.textContent?.slice(0, 20).trim().replace(/\s+/g, ' ') || '';
+                impacts.add(`${type}${attributeSuffix}@${xPath} (“${textStart}”)`);
+              });
+              const impactTime = Math.round(Date.now() - observationStart);
+              // Create a violation description with the elapsed time and the mutation details.
+              const violationWhat = `Hovering over the element makes these changes after ${impactTime}ms: ${Array.from(impacts).join(', ')}`;
+              // Clear the timer.
+              clearTimeout(timer);
+              // Stop the observer.
+              observer.disconnect();
+              // Resolve the Promise with the violation description.
+              resolve(violationWhat);
+            }
+          });
+          let observationRoot = element.parentElement.parentElement;
+          const rootTagName = observationRoot.tagName;
+          if (['MAIN', 'BODY'].includes(rootTagName)) {
+            observationRoot = element.parentElement;
+          }
+          // Start observing.
+          observer.observe(observationRoot, {
+            attributes: true,
+            attributeFilter: ['style', 'class', 'hidden', 'aria-hidden', 'disabled', 'open'],
+            subtree: true,
+            childList: true
+          });
+          // Start hovering over the element.
+          hoverEvents.forEach(event => {
+            element.dispatchEvent(event);
+          });
+          // Record the element for future mouseout events.
+          window.__lastHoveredElement = element;
+        });
+        // Execute a Promise that resolves when a time limit expires.
+        const timeoutPromise = new Promise(resolve => {
+          // If no mutation is observed before the time limit:
+          timer = setTimeout(() => {
+            // Stop the observer.
+            observer.disconnect();
+            // Resolve the Promise with an empty string.
+            resolve('');
+          }, 400);
+        });
+        // Get the violation description or timeout report.
+        const violationWhat = await Promise.race([mutationPromise, timeoutPromise]);
+        // If any mutations occurred before the time limit:
+        if (violationWhat) {
+          // Return the violation description.
+          return violationWhat;
+        }
+        //XXX Temp
+        return 'No mutations';
+      }
+    }
+  };
+  const selector = [
+   '[aria-controls]',
+   '[aria-expanded]',
+   '[aria-haspopup]',
+   '[onmouseenter]',
+   '[onmouseover]',
+   '[onmouseenter]',
+   '[onmouseover]',
+   '[role="menu"]',
+   '[role="menubar"]',
+   '[role="menuitem"]',
+   '[data-tooltip]',
+   '[data-popover]',
+   '[data-hover]',
+   '[data-menu]',
+   '[data-dropdown]',
+   '[role="tab"]',
+   '[role="combobox"]',
+   'a',
+   'button'
+  ].join(', ');
+  const whats = 'Hovering over elements adds, removes, or changes other elements';
+  return await doTest(
+    page, withItems, 'hover', selector, whats, 0, '', getBadWhat.toString()
+  );
+};

package/testaro/hover-draft2.js

@@ -0,0 +1,183 @@
+/*
+  © 2021–2024 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2025 Jonathan Robert Pool. All rights reserved.
+
+  MIT License
+
+  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.
+*/
+
+/*
+  hover
+  This test reports unexpected impacts of hovering over owning or controlling elements. The
+  elements that are subjected to hovering (called “triggers”) include the elements that have
+  attributes associated with control over the visibility of other elements. If hovering over an
+  element results in a change in the count or particular attributes of elements other than the
+  trigger within the tree rooted at the grandparent of the trigger, the rule is considered violated.
+  The times allowed for the settling of handlers of mouse and pointer events (30ms and 200ms) have
+  been derived from empirical testing but may need to be revised after more experience.
+*/
+
+// IMPORTS
+
+const {doTest} = require('../procs/testaro');
+
+// FUNCTIONS
+
+exports.reporter = async (page, withItems) => {
+  const getBadWhat = async element => {
+    const isVisible = element.checkVisibility({
+      contentVisibilityAuto: true,
+      opacityProperty: true,
+      visibilityProperty: true
+    });
+    // If the element is visible and is not a tooltip:
+    if (isVisible && element.getAttribute('role') !== 'tooltip') {
+      let timer;
+      let observer;
+      const options = {
+        bubbles: true,
+        cancelable: true,
+        view: window
+      };
+      const hoverEvents = [
+        new MouseEvent('mouseover', options),
+        new MouseEvent('mousemove', options),
+        new PointerEvent('pointerover', options),
+        new PointerEvent('pointermove', options)
+      ];
+      const {__lastHoveredElement} = window;
+      // Exit the prior hover location, if any.
+      if (__lastHoveredElement) {
+        [
+          [MouseEvent, 'mouseout', true],
+          [MouseEvent, 'mouseleave', false],
+          [PointerEvent, 'pointerout', true],
+          [PointerEvent, 'pointerleave', false]
+        ].forEach(([event, type, bubbles]) => {
+          __lastHoveredElement.dispatchEvent(new event(type, {bubbles}));
+        });
+      }
+      // Allow time for handlers of these events to complete execution.
+      await new Promise(resolve => setTimeout(resolve, 30));
+      // Check whether the visibility of the element was due solely to the prior hovering.
+      const isStillVisible = element.checkVisibility({
+        contentVisibilityAuto: true,
+        opacityProperty: true,
+        visibilityProperty: true
+      });
+      // If so:
+      if (isStillVisible) {
+        const observationStart = Date.now();
+        // Execute a Promise that resolves when a mutation is observed.
+        const mutationPromise = new Promise(resolve => {
+          // When mutations are observed:
+          observer = new MutationObserver(mutationRecords => {
+            const otherMutationRecords = mutationRecords.filter(record => {
+              const {target, type} = record;
+              return type !== 'childList'
+              && target !== element
+              && target.getAttribute('role') !== 'tooltip';
+            });
+            // If any are reportable:
+            if (otherMutationRecords.length) {
+              // Get a non-duplicative set of their types and XPaths.
+              const impacts = new Set();
+              otherMutationRecords.forEach(record => {
+                const {attributeName, target, type} = record;
+                const xPath = getXPath(target);
+                const attributeSuffix = attributeName ? `:${attributeName}` : '';
+                const textStart = target.textContent?.slice(0, 20).trim().replace(/\s+/g, ' ') || '';
+                impacts.add(`${type}${attributeSuffix}@${xPath} (“${textStart}”)`);
+              });
+              const impactTime = Math.round(Date.now() - observationStart);
+              // Create a violation description with the elapsed time and the mutation details.
+              const violationWhat = `Hovering over the element makes these changes after ${impactTime}ms: ${Array.from(impacts).join(', ')}`;
+              // Clear the timer.
+              clearTimeout(timer);
+              // Stop the observer.
+              observer.disconnect();
+              // Resolve the Promise with the violation description.
+              resolve(violationWhat);
+            }
+          });
+          let observationRoot = element.parentElement.parentElement;
+          const rootTagName = observationRoot.tagName;
+          if (['MAIN', 'BODY'].includes(rootTagName)) {
+            observationRoot = element.parentElement;
+          }
+          // Start observing.
+          observer.observe(observationRoot, {
+            attributes: true,
+            attributeFilter: ['style', 'class', 'hidden', 'aria-hidden', 'disabled', 'open'],
+            subtree: true,
+            childList: true
+          });
+          // Start hovering over the element.
+          hoverEvents.forEach(event => {
+            element.dispatchEvent(event);
+          });
+          // Record the element for future mouseout events.
+          window.__lastHoveredElement = element;
+        });
+        // Execute a Promise that resolves when a time limit expires.
+        const timeoutPromise = new Promise(resolve => {
+          // If no mutation is observed before the time limit:
+          timer = setTimeout(() => {
+            // Stop the observer.
+            observer.disconnect();
+            // Resolve the Promise with an empty string.
+            resolve('');
+          }, 200);
+        });
+        // Get the violation description or timeout report.
+        const violationWhat = await Promise.race([mutationPromise, timeoutPromise]);
+        // If any mutations occurred before the time limit:
+        if (violationWhat) {
+          // Return the violation description.
+          return violationWhat;
+        }
+        return 'No mutations';
+      }
+    }
+  };
+  const selector = [
+   '[aria-controls]',
+   '[aria-expanded]',
+   '[aria-haspopup]',
+   '[onmouseenter]',
+   '[onmouseover]',
+   '[onpointerenter]',
+   '[onpointerover]',
+   '[role="menu"]',
+   '[role="menubar"]',
+   '[role="menuitem"]',
+   '[data-tooltip]',
+   '[data-popover]',
+   '[data-hover]',
+   '[data-menu]',
+   '[data-dropdown]',
+   '[role="tab"]',
+   '[role="combobox"]'
+  ].join(', ');
+  const whats = 'Hovering over elements adds, removes, or changes other elements';
+  return await doTest(
+    page, withItems, 'hover', selector, whats, 0, '', getBadWhat.toString()
+  );
+};

package/testaro/hover-draft3.js

@@ -0,0 +1,143 @@
+/*
+  © 2021–2024 CVS Health and/or one of its affiliates. All rights reserved.
+  © 2025 Jonathan Robert Pool. All rights reserved.
+
+  MIT License
+
+  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.
+*/
+
+/*
+  hover
+  This test reports unexpected impacts of hovering. The elements that are subjected to hovering
+  (called “triggers”) include all the elements that have attributes associated with control over
+  the visibility of other elements. If hovering over an element results in an increase or decrease
+  in the total count of visible elements in the tree rooted in the grandparent of the trigger,
+  the rule is considered violated.
+*/
+
+// ########## IMPORTS
+
+// Module to perform common operations.
+const {getRuleResult} = require('../procs/testaro');
+
+// ########## FUNCTIONS
+
+// Runs the test and returns the result.
+exports.reporter = async (page, withItems) => {
+  // Initialize the locators and result.
+  const candidateLocs = await page.locator([
+   '[aria-controls]:visible',
+   '[aria-expanded]:visible',
+   '[aria-haspopup]:visible',
+   '[onmouseenter]:visible',
+   '[onmouseover]:visible',
+   '[onpointerenter]:visible',
+   '[onpointerover]:visible',
+   '[role="menu"]:visible',
+   '[role="menubar"]:visible',
+   '[role="menuitem"]:visible',
+   '[data-tooltip]:visible',
+   '[data-popover]:visible',
+   '[data-hover]:visible',
+   '[data-menu]:visible',
+   '[data-dropdown]:visible',
+   '[role="tab"]:visible',
+   '[role="combobox"]:visible'
+  ].join(', '));
+  const allLocs = await candidateLocs.all();
+  const all = {
+    allLocs,
+    locs: [],
+    result: {
+      data: {
+        populationRatio: 1
+      },
+      totals: [0, 0, 0, 0],
+      standardInstances: []
+    }
+  };
+  // For each locator:
+  for (const loc of allLocs) {
+    // Move the mouse to the top left corner of the page.
+    await page.mouse.move(0, 0);
+    // Get the XPath of the element referenced by the locator.
+    let xPath = await loc.evaluate(element => getXPath(element));
+    // Change it to the XPath of the desired observation root.
+    const pathSegments = xPath.split('/');
+    const {length} = pathSegments;
+    pathSegments.pop();
+    if (! ['main', 'body'].includes(pathSegments[length - 2])) {
+      pathSegments.pop();
+    }
+    xPath = pathSegments.join('/');
+    const rootLoc = page.locator(`xpath=${xPath}`);
+    // Get a count of the visible elements in the observation tree.
+    const loc0 = await rootLoc.locator('*:visible');
+    const elementCount0 = await loc0.count();
+    try {
+      // Hover over the element.
+      await loc.hover({timeout: 400});
+      // Get a count of the visible elements in the observation tree.
+      const loc1 = await rootLoc.locator('*:visible');
+      const elementCount1 = await loc1.count();
+      // Stop hovering over the element.
+      await page.mouse.move(0, 0);
+      let timeoutTimer;
+      let settleInterval;
+      const timeoutPromise = new Promise(resolve => {
+        timeoutTimer = setTimeout(() => {
+          clearTimeout(settleInterval);
+          resolve();
+        });
+      }, 400);
+      settlePromise = new Promise(resolve => {
+        settleInterval = setInterval(async () => {
+          const elementCount2 = await loc1.count();
+          if (elementCount2 < elementCount1) {
+            clearTimeout(timeoutTimer);
+            clearInterval(settleInterval);
+            resolve();
+          }
+        });
+      }, 75);
+      await Promise.race([timeoutPromise, settlePromise]);
+      // If the count has changed:
+      if (elementCount1 !== elementCount0) {
+        // Add the locator and a violation description to the array of violation locators.
+        const impact = elementCount1 - elementCount0;
+        all.locs.push([loc, impact]);
+      }
+    }
+    // If hovering times out:
+    catch(error) {
+      // Report the test prevented.
+      const {data} = all.result;
+      data.prevented = true;
+      data.error = 'ERROR hovering over an element';
+      break;
+    }
+  }
+  // Populate and return the result.
+  const whats = [
+    'Hovering over the element changes the number of elements on the page by __param__',
+    'Hovering over elements changes the number of elements on the page'
+  ];
+  return await getRuleResult(withItems, all, 'hover', whats, 0);
+};