refactor: add appActions and stabilize overlayPlot and plotRendering e2e test suites (#6612)

* test: add appActions, stabilize overlayPlot test

- Adds `waitForPlotsToRender`, a function that waits for all active `.plot` elements on the page to load and draw their series data
- Adds `getCanvasPixels`, a function that takes a canvas selector and retrieves an array of canvas pixel data.
- Modifies `getCanvasPixels` to use `page.evaluateHandle()` so that the canvas handle lifetime exists throughout the test (this was causing flakiness before)

* test: refactor and stabilize `plotRendering` tests

* test: remove redundant test suite

* test: stabilize plot legend color swatch test

* docs: mention `waitForPlotsToLoad()` in e2e docs

* refactor: have getCanvasPixels return actual rgba values

* docs: fix typo

* test: use appAction and fix reload wait condition

* docs: add additional context for `waitForPlotsToRender()`

* refactor: one-liner

* docs: tidy up docs

e2e/appActions.js

@@ -55,6 +55,7 @@
 
 const Buffer = require('buffer').Buffer;
 const genUuid = require('uuid').v4;
+const { expect } = require('@playwright/test');
 
 /**
  * This common function creates a domain object with the default options. It is the preferred way of creating objects
@@ -405,19 +406,92 @@ async function selectInspectorTab(page, name) {
     }
 }
 
+/**
+* Waits and asserts that all plot series data on the page
+* is loaded and drawn.
+*
+* In lieu of a better way to detect when a plot is done rendering,
+* we [attach a class to the '.gl-plot' element](https://github.com/nasa/openmct/blob/5924d7ea95a0c2d4141c602a3c7d0665cb91095f/src/plugins/plot/MctPlot.vue#L27)
+* once all pending series data has been loaded. The following appAction retrieves
+* all plots on the page and waits up to the default timeout for the class to be
+* attached to each plot.
+* @param {import('@playwright/test').Page} page
+*/
+async function waitForPlotsToRender(page) {
+    const plotLocator = page.locator('.gl-plot');
+    for (const plot of await plotLocator.all()) {
+        await expect(plot).toHaveClass(/js-series-data-loaded/);
+    }
+}
+
+/**
+ * @typedef {Object} PlotPixel
+ * @property {number} r The value of the red channel (0-255)
+ * @property {number} g The value of the green channel (0-255)
+ * @property {number} b The value of the blue channel (0-255)
+ * @property {number} a The value of the alpha channel (0-255)
+ * @property {string} strValue The rgba string value of the pixel
+ */
+
+/**
+ * Wait for all plots to render and then retrieve and return an array
+ * of canvas plot pixel data (RGBA values).
+ * @param {import('@playwright/test').Page} page
+ * @param {string} canvasSelector The selector for the canvas element
+ * @return {Promise<PlotPixel[]>}
+ */
+async function getCanvasPixels(page, canvasSelector) {
+    const getTelemValuePromise = new Promise(resolve => page.exposeFunction('getCanvasValue', resolve));
+    const canvasHandle = await page.evaluateHandle((canvas) => document.querySelector(canvas), canvasSelector);
+    const canvasContextHandle = await page.evaluateHandle(canvas => canvas.getContext('2d'), canvasHandle);
+
+    await waitForPlotsToRender(page);
+    await page.evaluate(([canvas, ctx]) => {
+        // The document canvas is where the plot points and lines are drawn.
+        // The only way to access the canvas is using document (using page.evaluate)
+        /** @type {ImageData} */
+        const data = ctx.getImageData(0, 0, canvas.width, canvas.height).data;
+        /** @type {number[]} */
+        const imageDataValues = Object.values(data);
+        /** @type {PlotPixel[]} */
+        const plotPixels = [];
+        // Each pixel consists of four values within the ImageData.data array. The for loop iterates by multiples of four.
+        // The values associated with each pixel are R (red), G (green), B (blue), and A (alpha), in that order.
+        for (let i = 0; i < imageDataValues.length;) {
+            if (imageDataValues[i] > 0) {
+                plotPixels.push({
+                    r: imageDataValues[i],
+                    g: imageDataValues[i + 1],
+                    b: imageDataValues[i + 2],
+                    a: imageDataValues[i + 3],
+                    strValue: `rgb(${imageDataValues[i]}, ${imageDataValues[i + 1]}, ${imageDataValues[i + 2]}, ${imageDataValues[i + 3]})`
+                });
+            }
+
+            i = i + 4;
+        }
+
+        window.getCanvasValue(plotPixels);
+    }, [canvasHandle, canvasContextHandle]);
+
+    return getTelemValuePromise;
+}
+
 // eslint-disable-next-line no-undef
 module.exports = {
     createDomainObjectWithDefaults,
     createNotification,
-    expandTreePaneItemByName,
-    expandEntireTree,
     createPlanFromJSON,
-    openObjectTreeContextMenu,
+    expandEntireTree,
+    expandTreePaneItemByName,
+    getCanvasPixels,
     getHashUrlToDomainObject,
     getFocusedObjectUuid,
+    openObjectTreeContextMenu,
     setFixedTimeMode,
     setRealTimeMode,
     setStartOffset,
     setEndOffset,
-    selectInspectorTab
+    selectInspectorTab,
+    waitForPlotsToRender
 };