mirror of
https://github.com/nasa/openmct.git
synced 2024-12-29 01:18:52 +00:00
621 lines
25 KiB
JavaScript
621 lines
25 KiB
JavaScript
/*****************************************************************************
|
|
* Open MCT, Copyright (c) 2014-2024, United States Government
|
|
* as represented by the Administrator of the National Aeronautics and Space
|
|
* Administration. All rights reserved.
|
|
*
|
|
* Open MCT is licensed under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
* http://www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
* Open MCT includes source code licensed under additional open source
|
|
* licenses. See the Open Source Licenses file (LICENSES.md) included with
|
|
* this source code distribution or the Licensing information page available
|
|
* at runtime from the About dialog for additional information.
|
|
*****************************************************************************/
|
|
import { fileURLToPath } from 'url';
|
|
|
|
import {
|
|
createDomainObjectWithDefaults,
|
|
navigateToObjectWithFixedTimeBounds,
|
|
setFixedTimeMode,
|
|
setIndependentTimeConductorBounds,
|
|
setRealTimeMode,
|
|
setStartOffset
|
|
} from '../../../../appActions.js';
|
|
import { expect, test } from '../../../../pluginFixtures.js';
|
|
|
|
const CHILD_LAYOUT_STORAGE_STATE_PATH = fileURLToPath(
|
|
new URL('../../../../test-data/display_layout_with_child_layouts.json', import.meta.url)
|
|
);
|
|
const CHILD_PLOT_STORAGE_STATE_PATH = fileURLToPath(
|
|
new URL('../../../../test-data/display_layout_with_child_overlay_plot.json', import.meta.url)
|
|
);
|
|
const TINY_IMAGE_BASE64 =
|
|
'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAIAQMAAAD+wSzIAAAABlBMVEX///+/v7+jQ3Y5AAAADklEQVQI12P4AIX8EAgALgAD/aNpbtEAAAAASUVORK5CYII';
|
|
|
|
test.describe('Display Layout Sub-object Actions @localStorage', () => {
|
|
const INIT_ITC_START_BOUNDS = '2024-11-12 19:11:11.000Z';
|
|
const INIT_ITC_END_BOUNDS = '2024-11-12 20:11:11.000Z';
|
|
const NEW_GLOBAL_START_BOUNDS = '2024-11-11 19:11:11.000Z';
|
|
const NEW_GLOBAL_END_BOUNDS = '2024-11-11 20:11:11.000Z';
|
|
|
|
test.use({
|
|
storageState: CHILD_PLOT_STORAGE_STATE_PATH
|
|
});
|
|
|
|
test.beforeEach(async ({ page }) => {
|
|
await page.goto('./', { waitUntil: 'domcontentloaded' });
|
|
await page.getByLabel('Expand My Items folder').click();
|
|
const waitForMyItemsNavigation = page.waitForURL(`**/mine/?*`);
|
|
await page
|
|
.getByLabel('Main Tree')
|
|
.getByLabel('Navigate to Parent Display Layout layout Object')
|
|
.click();
|
|
// Wait for the URL to change to the display layout
|
|
await waitForMyItemsNavigation;
|
|
});
|
|
test('Open in New Tab action preserves time bounds @2p', async ({ page }) => {
|
|
test.info().annotations.push({
|
|
type: 'issue',
|
|
description: 'https://github.com/nasa/openmct/issues/7524'
|
|
});
|
|
test.info().annotations.push({
|
|
type: 'issue',
|
|
description: 'https://github.com/nasa/openmct/issues/6982'
|
|
});
|
|
|
|
const TEST_FIXED_START_TIME = 1731352271000; // 2024-11-11 19:11:11.000Z
|
|
const TEST_FIXED_END_TIME = TEST_FIXED_START_TIME + 3600000; // 2024-11-11 20:11:11.000Z
|
|
|
|
// Verify the ITC has the expected initial bounds
|
|
expect(
|
|
await page
|
|
.getByLabel('Child Overlay Plot 1 Frame Controls')
|
|
.getByLabel('Start bounds')
|
|
.textContent()
|
|
).toEqual(INIT_ITC_START_BOUNDS);
|
|
expect(
|
|
await page
|
|
.getByLabel('Child Overlay Plot 1 Frame Controls')
|
|
.getByLabel('End bounds')
|
|
.textContent()
|
|
).toEqual(INIT_ITC_END_BOUNDS);
|
|
|
|
// Update the global fixed bounds to 2024-11-11 19:11:11.000Z / 2024-11-11 20:11:11.000Z
|
|
const url = page.url().split('?')[0];
|
|
await navigateToObjectWithFixedTimeBounds(
|
|
page,
|
|
url,
|
|
TEST_FIXED_START_TIME,
|
|
TEST_FIXED_END_TIME
|
|
);
|
|
|
|
// ITC bounds should still match the initial ITC bounds
|
|
expect(
|
|
await page
|
|
.getByLabel('Child Overlay Plot 1 Frame Controls')
|
|
.getByLabel('Start bounds')
|
|
.textContent()
|
|
).toEqual(INIT_ITC_START_BOUNDS);
|
|
expect(
|
|
await page
|
|
.getByLabel('Child Overlay Plot 1 Frame Controls')
|
|
.getByLabel('End bounds')
|
|
.textContent()
|
|
).toEqual(INIT_ITC_END_BOUNDS);
|
|
|
|
// Open the Child Overlay Plot 1 in a new tab
|
|
await page.getByLabel('View menu items').click();
|
|
const pagePromise = page.context().waitForEvent('page');
|
|
await page.getByLabel('Open In New Tab').click();
|
|
|
|
const newPage = await pagePromise;
|
|
await newPage.waitForLoadState('domcontentloaded');
|
|
|
|
// Verify that the global time conductor bounds in the new page match the updated global bounds
|
|
expect(
|
|
await newPage.getByLabel('Global Time Conductor').getByLabel('Start bounds').textContent()
|
|
).toEqual(NEW_GLOBAL_START_BOUNDS);
|
|
expect(
|
|
await newPage.getByLabel('Global Time Conductor').getByLabel('End bounds').textContent()
|
|
).toEqual(NEW_GLOBAL_END_BOUNDS);
|
|
|
|
// Verify that the ITC is enabled in the new page
|
|
await expect(newPage.getByLabel('Disable Independent Time Conductor')).toBeVisible();
|
|
// Verify that the ITC bounds in the new page match the original ITC bounds
|
|
expect(
|
|
await newPage
|
|
.getByLabel('Independent Time Conductor Panel')
|
|
.getByLabel('Start bounds')
|
|
.textContent()
|
|
).toEqual(INIT_ITC_START_BOUNDS);
|
|
expect(
|
|
await newPage
|
|
.getByLabel('Independent Time Conductor Panel')
|
|
.getByLabel('End bounds')
|
|
.textContent()
|
|
).toEqual(INIT_ITC_END_BOUNDS);
|
|
});
|
|
});
|
|
|
|
test.describe('Display Layout Toolbar Actions @localStorage', () => {
|
|
const PARENT_DISPLAY_LAYOUT_NAME = 'Parent Display Layout';
|
|
const CHILD_DISPLAY_LAYOUT_NAME1 = 'Child Layout 1';
|
|
test.beforeEach(async ({ page }) => {
|
|
await page.goto('./', { waitUntil: 'domcontentloaded' });
|
|
await setRealTimeMode(page);
|
|
await page
|
|
.locator('a')
|
|
.filter({ hasText: 'Parent Display Layout Display Layout' })
|
|
.first()
|
|
.click();
|
|
await page.getByLabel('Edit Object').click();
|
|
});
|
|
test.use({
|
|
storageState: CHILD_LAYOUT_STORAGE_STATE_PATH
|
|
});
|
|
|
|
test('can add/remove Text element to a single layout', async ({ page }) => {
|
|
const layoutObject = 'Text';
|
|
await test.step(`Add and remove ${layoutObject} from the parent's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, PARENT_DISPLAY_LAYOUT_NAME);
|
|
});
|
|
await test.step(`Add and remove ${layoutObject} from the child's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, CHILD_DISPLAY_LAYOUT_NAME1);
|
|
});
|
|
});
|
|
test('can add/remove Image to a single layout', async ({ page }) => {
|
|
const layoutObject = 'Image';
|
|
await test.step("Add and remove image element from the parent's layout", async () => {
|
|
expect(await page.getByLabel(`Move ${layoutObject} Frame`).count()).toBe(0);
|
|
await addLayoutObject(page, PARENT_DISPLAY_LAYOUT_NAME, layoutObject);
|
|
expect(await page.getByLabel(`Move ${layoutObject} Frame`).count()).toBe(1);
|
|
await removeLayoutObject(page, layoutObject);
|
|
expect(await page.getByLabel(`Move ${layoutObject} Frame`).count()).toBe(0);
|
|
});
|
|
await test.step("Add and remove image from the child's layout", async () => {
|
|
await addLayoutObject(page, CHILD_DISPLAY_LAYOUT_NAME1, layoutObject);
|
|
expect(await page.getByLabel(`Move ${layoutObject} Frame`).count()).toBe(1);
|
|
await removeLayoutObject(page, layoutObject);
|
|
expect(await page.getByLabel(`Move ${layoutObject} Frame`).count()).toBe(0);
|
|
});
|
|
});
|
|
test(`can add/remove Box to a single layout`, async ({ page }) => {
|
|
const layoutObject = 'Box';
|
|
await test.step(`Add and remove ${layoutObject} from the parent's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, PARENT_DISPLAY_LAYOUT_NAME);
|
|
});
|
|
await test.step(`Add and remove ${layoutObject} from the child's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, CHILD_DISPLAY_LAYOUT_NAME1);
|
|
});
|
|
});
|
|
test(`can add/remove Line to a single layout`, async ({ page }) => {
|
|
const layoutObject = 'Line';
|
|
await test.step(`Add and remove ${layoutObject} from the parent's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, PARENT_DISPLAY_LAYOUT_NAME);
|
|
});
|
|
await test.step(`Add and remove ${layoutObject} from the child's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, CHILD_DISPLAY_LAYOUT_NAME1);
|
|
});
|
|
});
|
|
test(`can add/remove Ellipse to a single layout`, async ({ page }) => {
|
|
const layoutObject = 'Ellipse';
|
|
await test.step(`Add and remove ${layoutObject} from the parent's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, PARENT_DISPLAY_LAYOUT_NAME);
|
|
});
|
|
await test.step(`Add and remove ${layoutObject} from the child's layout`, async () => {
|
|
await addAndRemoveDrawingObjectAndAssert(page, layoutObject, CHILD_DISPLAY_LAYOUT_NAME1);
|
|
});
|
|
});
|
|
test.fixme('Can switch view types of a single SWG in a layout', async ({ page }) => {});
|
|
test.fixme('Can merge multiple plots in a layout', async ({ page }) => {});
|
|
test.fixme('Can adjust stack order of a single object in a layout', async ({ page }) => {});
|
|
test.fixme('Can duplicate a single object in a layout', async ({ page }) => {});
|
|
});
|
|
|
|
test.describe('Display Layout', () => {
|
|
/** @type {import('../../../../appActions').CreatedObjectInfo} */
|
|
let sineWaveObject;
|
|
test.beforeEach(async ({ page }) => {
|
|
await page.goto('./', { waitUntil: 'domcontentloaded' });
|
|
await setRealTimeMode(page);
|
|
|
|
// Create Sine Wave Generator
|
|
sineWaveObject = await createDomainObjectWithDefaults(page, {
|
|
type: 'Sine Wave Generator'
|
|
});
|
|
});
|
|
|
|
test('alpha-numeric widget telemetry value exactly matches latest telemetry value received in real time', async ({
|
|
page
|
|
}) => {
|
|
// Create a Display Layout
|
|
await createDomainObjectWithDefaults(page, {
|
|
type: 'Display Layout',
|
|
name: 'Test Display Layout'
|
|
});
|
|
// Edit Display Layout
|
|
await page.getByLabel('Edit Object').click();
|
|
|
|
// Expand the 'My Items' folder in the left tree
|
|
await page.locator('.c-tree__item__view-control.c-disclosure-triangle').click();
|
|
// Add the Sine Wave Generator to the Display Layout and save changes
|
|
const treePane = page.getByRole('tree', {
|
|
name: 'Main Tree'
|
|
});
|
|
const sineWaveGeneratorTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(sineWaveObject.name)
|
|
});
|
|
const layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
await sineWaveGeneratorTreeItem.dragTo(layoutGridHolder);
|
|
await page.locator('button[title="Save"]').click();
|
|
await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
|
|
|
|
// Subscribe to the Sine Wave Generator data
|
|
// On getting data, check if the value found in the Display Layout is the most recent value
|
|
// from the Sine Wave Generator
|
|
const getTelemValuePromise = await subscribeToTelemetry(page, sineWaveObject.uuid);
|
|
const formattedTelemetryValue = getTelemValuePromise;
|
|
const displayLayoutValuePromise = await page.waitForSelector(
|
|
`text="${formattedTelemetryValue}"`
|
|
);
|
|
const displayLayoutValue = await displayLayoutValuePromise.textContent();
|
|
const trimmedDisplayValue = displayLayoutValue.trim();
|
|
|
|
expect(trimmedDisplayValue).toBe(formattedTelemetryValue);
|
|
|
|
// ensure we can right click on the alpha-numeric widget and view historical data
|
|
await page.getByLabel(/Alpha-numeric telemetry value of.*/).click({
|
|
button: 'right'
|
|
});
|
|
await page.getByLabel('View Historical Data').click();
|
|
await expect(page.getByLabel('Plot Container Style Target')).toBeVisible();
|
|
});
|
|
test('alpha-numeric widget telemetry value exactly matches latest telemetry value received in fixed time', async ({
|
|
page
|
|
}) => {
|
|
// Create a Display Layout
|
|
await createDomainObjectWithDefaults(page, {
|
|
type: 'Display Layout',
|
|
name: 'Test Display Layout'
|
|
});
|
|
// Edit Display Layout
|
|
await page.getByLabel('Edit Object').click();
|
|
|
|
// Expand the 'My Items' folder in the left tree
|
|
await page.locator('.c-tree__item__view-control.c-disclosure-triangle').click();
|
|
// Add the Sine Wave Generator to the Display Layout and save changes
|
|
const treePane = page.getByRole('tree', {
|
|
name: 'Main Tree'
|
|
});
|
|
const sineWaveGeneratorTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(sineWaveObject.name)
|
|
});
|
|
const layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
await sineWaveGeneratorTreeItem.dragTo(layoutGridHolder);
|
|
await page.locator('button[title="Save"]').click();
|
|
await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
|
|
|
|
// Subscribe to the Sine Wave Generator data
|
|
const getTelemValuePromise = await subscribeToTelemetry(page, sineWaveObject.uuid);
|
|
// Set an offset of 1 minute and then change the time mode to fixed to set a 1 minute historical window
|
|
await setStartOffset(page, { mins: '1' });
|
|
await setFixedTimeMode(page);
|
|
|
|
// On getting data, check if the value found in the Display Layout is the most recent value
|
|
// from the Sine Wave Generator
|
|
const formattedTelemetryValue = getTelemValuePromise;
|
|
const displayLayoutValuePromise = await page.waitForSelector(
|
|
`text="${formattedTelemetryValue}"`
|
|
);
|
|
const displayLayoutValue = await displayLayoutValuePromise.textContent();
|
|
const trimmedDisplayValue = displayLayoutValue.trim();
|
|
|
|
expect(trimmedDisplayValue).toBe(formattedTelemetryValue);
|
|
});
|
|
test('items in a display layout can be removed with object tree context menu when viewing the display layout', async ({
|
|
page
|
|
}) => {
|
|
// Create a Display Layout
|
|
await createDomainObjectWithDefaults(page, {
|
|
type: 'Display Layout',
|
|
name: 'Test Display Layout'
|
|
});
|
|
// Edit Display Layout
|
|
await page.getByLabel('Edit Object').click();
|
|
|
|
// Expand the 'My Items' folder in the left tree
|
|
await page.locator('.c-tree__item__view-control.c-disclosure-triangle').click();
|
|
// Add the Sine Wave Generator to the Display Layout and save changes
|
|
const treePane = page.getByRole('tree', {
|
|
name: 'Main Tree'
|
|
});
|
|
const sineWaveGeneratorTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(sineWaveObject.name)
|
|
});
|
|
const layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
await sineWaveGeneratorTreeItem.dragTo(layoutGridHolder);
|
|
await page.locator('button[title="Save"]').click();
|
|
await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
|
|
|
|
expect.soft(await page.locator('.l-layout .l-layout__frame').count()).toEqual(1);
|
|
|
|
// Expand the Display Layout so we can remove the sine wave generator
|
|
await page.locator('.c-tree__item.is-navigated-object .c-disclosure-triangle').click();
|
|
|
|
// Bring up context menu and remove
|
|
await sineWaveGeneratorTreeItem.nth(1).click({ button: 'right' });
|
|
await page.locator('li[role="menuitem"]:has-text("Remove")').click();
|
|
await page.locator('button:has-text("OK")').click();
|
|
|
|
// delete
|
|
|
|
expect(await page.locator('.l-layout .l-layout__frame').count()).toEqual(0);
|
|
});
|
|
test('items in a display layout can be removed with object tree context menu when viewing another item', async ({
|
|
page
|
|
}) => {
|
|
test.info().annotations.push({
|
|
type: 'issue',
|
|
description: 'https://github.com/nasa/openmct/issues/3117'
|
|
});
|
|
// Create a Display Layout
|
|
const displayLayout = await createDomainObjectWithDefaults(page, {
|
|
type: 'Display Layout'
|
|
});
|
|
// Edit Display Layout
|
|
await page.getByLabel('Edit Object').click();
|
|
|
|
// Expand the 'My Items' folder in the left tree
|
|
await page.locator('.c-tree__item__view-control.c-disclosure-triangle').click();
|
|
// Add the Sine Wave Generator to the Display Layout and save changes
|
|
const treePane = page.getByRole('tree', {
|
|
name: 'Main Tree'
|
|
});
|
|
const sineWaveGeneratorTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(sineWaveObject.name)
|
|
});
|
|
const layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
await sineWaveGeneratorTreeItem.dragTo(layoutGridHolder);
|
|
await page.locator('button[title="Save"]').click();
|
|
await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
|
|
|
|
expect.soft(await page.locator('.l-layout .l-layout__frame').count()).toEqual(1);
|
|
|
|
// Expand the Display Layout so we can remove the sine wave generator
|
|
await page.locator('.c-tree__item.is-navigated-object .c-disclosure-triangle').click();
|
|
|
|
// Go to the original Sine Wave Generator to navigate away from the Display Layout
|
|
await page.goto(sineWaveObject.url);
|
|
|
|
// Bring up context menu and remove
|
|
await sineWaveGeneratorTreeItem.first().click({ button: 'right' });
|
|
await page.locator('li[role="menuitem"]:has-text("Remove")').click();
|
|
await page.locator('button:has-text("OK")').click();
|
|
|
|
// navigate back to the display layout to confirm it has been removed
|
|
await page.goto(displayLayout.url);
|
|
|
|
expect(await page.locator('.l-layout .l-layout__frame').count()).toEqual(0);
|
|
});
|
|
|
|
test('independent time works with display layouts and its children', async ({ page }) => {
|
|
await setFixedTimeMode(page);
|
|
// Create Example Imagery
|
|
const exampleImageryObject = await createDomainObjectWithDefaults(page, {
|
|
type: 'Example Imagery'
|
|
});
|
|
// Create a Display Layout
|
|
await createDomainObjectWithDefaults(page, {
|
|
type: 'Display Layout'
|
|
});
|
|
// Edit Display Layout
|
|
await page.getByLabel('Edit Object').click();
|
|
|
|
// Expand the 'My Items' folder in the left tree
|
|
await page.locator('.c-tree__item__view-control.c-disclosure-triangle').click();
|
|
// Add the Sine Wave Generator to the Display Layout and save changes
|
|
const treePane = page.getByRole('tree', {
|
|
name: 'Main Tree'
|
|
});
|
|
const exampleImageryTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(exampleImageryObject.name)
|
|
});
|
|
let layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
await exampleImageryTreeItem.dragTo(layoutGridHolder);
|
|
|
|
//adjust so that we can see the independent time conductor toggle
|
|
// Adjust object height
|
|
await page.locator('div[title="Resize object height"] > input').click();
|
|
await page.locator('div[title="Resize object height"] > input').fill('70');
|
|
|
|
// Adjust object width
|
|
await page.locator('div[title="Resize object width"] > input').click();
|
|
await page.locator('div[title="Resize object width"] > input').fill('70');
|
|
|
|
await page.locator('button[title="Save"]').click();
|
|
await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
|
|
|
|
const startDate = '2021-12-30 01:01:00.000Z';
|
|
const endDate = '2021-12-30 01:11:00.000Z';
|
|
await setIndependentTimeConductorBounds(page, { start: startDate, end: endDate });
|
|
|
|
// check image date
|
|
await expect(page.getByText('2021-12-30 01:11:00.000Z').first()).toBeVisible();
|
|
|
|
// flip it off
|
|
await page.getByRole('switch').click();
|
|
// timestamp shouldn't be in the past anymore
|
|
await expect(page.getByText('2021-12-30 01:11:00.000Z')).toBeHidden();
|
|
});
|
|
|
|
test('When multiple plots are contained in a layout, we only ask for annotations once @couchdb', async ({
|
|
page
|
|
}) => {
|
|
await setFixedTimeMode(page);
|
|
// Create another Sine Wave Generator
|
|
const anotherSineWaveObject = await createDomainObjectWithDefaults(page, {
|
|
type: 'Sine Wave Generator',
|
|
customParameters: {
|
|
'[aria-label="Data Rate (hz)"]': '0.01'
|
|
}
|
|
});
|
|
// Create a Display Layout
|
|
await createDomainObjectWithDefaults(page, {
|
|
type: 'Display Layout',
|
|
name: 'Test Display Layout'
|
|
});
|
|
// Edit Display Layout
|
|
await page.getByLabel('Edit Object').click();
|
|
|
|
// Expand the 'My Items' folder in the left tree
|
|
await page.locator('.c-tree__item__view-control.c-disclosure-triangle').click();
|
|
// Add the Sine Wave Generator to the Display Layout and save changes
|
|
const treePane = page.getByRole('tree', {
|
|
name: 'Main Tree'
|
|
});
|
|
const sineWaveGeneratorTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(sineWaveObject.name)
|
|
});
|
|
|
|
let layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
// eslint-disable-next-line playwright/no-force-option
|
|
await sineWaveGeneratorTreeItem.dragTo(layoutGridHolder, { force: true });
|
|
|
|
await page.getByText('View type').click();
|
|
await page.getByText('Overlay Plot').click();
|
|
|
|
const anotherSineWaveGeneratorTreeItem = treePane.getByRole('treeitem', {
|
|
name: new RegExp(anotherSineWaveObject.name)
|
|
});
|
|
layoutGridHolder = page.locator('.l-layout__grid-holder');
|
|
// eslint-disable-next-line playwright/no-force-option
|
|
await anotherSineWaveGeneratorTreeItem.dragTo(layoutGridHolder, { force: true });
|
|
|
|
await page.getByText('View type').click();
|
|
await page.getByText('Overlay Plot').click();
|
|
|
|
await page.locator('button[title="Save"]').click();
|
|
await page.getByRole('listitem', { name: 'Save and Finish Editing' }).click();
|
|
|
|
// Time to inspect some network traffic
|
|
let networkRequests = [];
|
|
page.on('request', (request) => {
|
|
const searchRequest =
|
|
request.url().endsWith('_find') || request.url().includes('by_keystring');
|
|
const fetchRequest = request.resourceType() === 'fetch';
|
|
if (searchRequest && fetchRequest) {
|
|
networkRequests.push(request);
|
|
}
|
|
});
|
|
|
|
await page.reload();
|
|
|
|
// wait for annotations requests to be batched and requested
|
|
await page.waitForLoadState('networkidle');
|
|
// Network requests for the composite telemetry with multiple items should be:
|
|
// 1. a single batched request for annotations
|
|
expect(networkRequests.length).toBe(1);
|
|
|
|
await setRealTimeMode(page);
|
|
|
|
networkRequests = [];
|
|
|
|
await page.reload();
|
|
|
|
// wait for annotations to not load (if we have any, we've got a problem)
|
|
await page.waitForLoadState('networkidle');
|
|
|
|
// In real time mode, we don't fetch annotations at all
|
|
expect(networkRequests.length).toBe(0);
|
|
});
|
|
});
|
|
|
|
async function addAndRemoveDrawingObjectAndAssert(page, layoutObject, DISPLAY_LAYOUT_NAME) {
|
|
expect(await page.getByLabel(layoutObject, { exact: true }).count()).toBe(0);
|
|
await addLayoutObject(page, DISPLAY_LAYOUT_NAME, layoutObject);
|
|
expect(
|
|
await page
|
|
.getByLabel(layoutObject, {
|
|
exact: true
|
|
})
|
|
.count()
|
|
).toBe(1);
|
|
await removeLayoutObject(page, layoutObject);
|
|
expect(await page.getByLabel(layoutObject, { exact: true }).count()).toBe(0);
|
|
}
|
|
|
|
/**
|
|
* Remove the first matching layout object from the layout
|
|
* @param {import('@playwright/test').Page} page
|
|
* @param {'Box' | 'Ellipse' | 'Line' | 'Text' | 'Image'} layoutObject
|
|
*/
|
|
async function removeLayoutObject(page, layoutObject) {
|
|
await page
|
|
.getByLabel(`Move ${layoutObject} Frame`, { exact: true })
|
|
.or(page.getByLabel(layoutObject, { exact: true }))
|
|
.first()
|
|
// eslint-disable-next-line playwright/no-force-option
|
|
.click({ force: true });
|
|
await page.getByTitle('Delete the selected object').click();
|
|
await page.getByRole('button', { name: 'OK', exact: true }).click();
|
|
}
|
|
|
|
/**
|
|
* Add a layout object to the specified layout
|
|
* @param {import('@playwright/test').Page} page
|
|
* @param {string} layoutName
|
|
* @param {'Box' | 'Ellipse' | 'Line' | 'Text' | 'Image'} layoutObject
|
|
*/
|
|
async function addLayoutObject(page, layoutName, layoutObject) {
|
|
await page.getByLabel(`${layoutName} Layout`, { exact: true }).click();
|
|
await page.getByText('Add Drawing Object').click();
|
|
await page
|
|
.getByRole('menuitem', {
|
|
name: layoutObject
|
|
})
|
|
.click();
|
|
if (layoutObject === 'Text') {
|
|
await page.getByRole('textbox', { name: 'Text' }).fill('Hello, Universe!');
|
|
await page.getByText('OK').click();
|
|
} else if (layoutObject === 'Image') {
|
|
await page.getByLabel('Image URL').fill(TINY_IMAGE_BASE64);
|
|
await page.getByText('OK').click();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Util for subscribing to a telemetry object by object identifier
|
|
* Limitations: Currently only works to return telemetry once to the node scope
|
|
* To Do: See if there's a way to await this multiple times to allow for multiple
|
|
* values to be returned over time
|
|
* @param {import('@playwright/test').Page} page
|
|
* @param {string} objectIdentifier identifier for object
|
|
* @returns {Promise<string>} the formatted sin telemetry value
|
|
*/
|
|
async function subscribeToTelemetry(page, objectIdentifier) {
|
|
const getTelemValuePromise = new Promise((resolve) =>
|
|
page.exposeFunction('getTelemValue', resolve)
|
|
);
|
|
|
|
await page.evaluate(async (telemetryIdentifier) => {
|
|
const telemetryObject = await window.openmct.objects.get(telemetryIdentifier);
|
|
const metadata = window.openmct.telemetry.getMetadata(telemetryObject);
|
|
const formats = await window.openmct.telemetry.getFormatMap(metadata);
|
|
window.openmct.telemetry.subscribe(telemetryObject, (obj) => {
|
|
const sinVal = obj.sin;
|
|
const formattedSinVal = formats.sin.format(sinVal);
|
|
window.getTelemValue(formattedSinVal);
|
|
});
|
|
}, objectIdentifier);
|
|
|
|
return getTelemValuePromise;
|
|
}
|