test(contour): Add the ContourSegmentToggleLock.spec.ts test file to test contour locking (#6072)

tests/ContourSegmentToggleLock.spec.ts

@@ -0,0 +1,130 @@
+import {
+  contourShowOnlyNthSegment,
+  expect,
+  getSvgAttribute,
+  simulateNormalizedDragOnElement,
+  test,
+  visitStudyAndHydrate,
+} from './utils';
+import { expectRowLocked, expectRowUnlocked } from './utils/assertions';
+
+const studyInstanceUID = '1.2.840.113619.2.290.3.3767434740.226.1600859119.501';
+const defaultSegment0Name = 'Threshold';
+
+test.beforeEach(async ({ page, leftPanelPageObject, DOMOverlayPageObject }) => {
+  await visitStudyAndHydrate({
+    page,
+    leftPanelPageObject,
+    DOMOverlayPageObject,
+    studyInstanceUID,
+    modality: 'RTSTRUCT',
+  });
+});
+
+test('should show the lock indicator and flip the menu label between Lock and Unlock', async ({
+  rightPanelPageObject,
+}) => {
+  const panel = rightPanelPageObject.contourSegmentationPanel.panel;
+  const segment0 = panel.nthSegment(0);
+  await expect(segment0.title).toHaveText(defaultSegment0Name);
+
+  // The lock icon is only rendered inside the row once locked.
+  await expectRowUnlocked(segment0);
+
+  let lockToggle = await segment0.actions.lockToggleMenuItem();
+  await expect(lockToggle, 'Expected the menu item to read "Lock" before locking').toHaveText(
+    'Lock'
+  );
+
+  // Lock the segment by clicking the already-open menu item.
+  await lockToggle.click();
+  await expectRowLocked(segment0);
+
+  // Reopen the actions menu: the toggle label should now read "Unlock".
+  lockToggle = await segment0.actions.lockToggleMenuItem();
+  await expect(lockToggle, 'Expected the menu item to read "Unlock" after locking').toHaveText('Unlock');
+
+  // Unlock the segment again by clicking the already-open menu item.
+  await lockToggle.click();
+  await expectRowUnlocked(segment0);
+
+  lockToggle = await segment0.actions.lockToggleMenuItem();
+  await expect(
+    lockToggle,
+    'Expected the menu item to read "Lock" again after unlocking'
+  ).toHaveText('Lock');
+});
+
+test('should stop a locked contour segment from responding to drag edits', async ({
+  rightPanelPageObject,
+  viewportPageObject,
+}) => {
+  const panel = rightPanelPageObject.contourSegmentationPanel.panel;
+  const segment0 = panel.nthSegment(0);
+  await expect(
+    segment0.title,
+    'Expected the first segment to be the Threshold segment'
+  ).toHaveText(defaultSegment0Name);
+
+  // Isolate segment 0 so the viewport renders exactly one contour path and it is
+  // the active segment for the drag edits below.
+  await contourShowOnlyNthSegment({
+    segmentationPanel: rightPanelPageObject.contourSegmentationPanel,
+  });
+
+  const svgPath = (await viewportPageObject.getById('default')).svg('path');
+  await expect(svgPath, 'Expected exactly one visible contour path').toHaveCount(1);
+
+  const originalSvgPathDAttribute = await getSvgAttribute({
+    viewportPageObject,
+    svgInnerElement: 'path',
+    attributeName: 'd',
+  });
+  expect(originalSvgPathDAttribute, 'Expected a visible SVG path for the unlocked segment').not.toBeNull();
+
+  // Lock the segment via the actions menu and confirm the lock state has propagated
+  // to the row before dragging.
+  await segment0.actions.toggleLock();
+  await expectRowLocked(segment0);
+
+  // Drag the path while locked.
+  await simulateNormalizedDragOnElement({
+    locator: svgPath,
+    start: { x: 0.8, y: 0.8 },
+    end: { x: 0.2, y: 0.2 },
+  });
+
+  const svgPathDAttributeAfterDragWhileLocked = await getSvgAttribute({
+    viewportPageObject,
+    svgInnerElement: 'path',
+    attributeName: 'd',
+  });
+
+  // The path should not have changed after the drag attempt while locked.
+  expect(
+    svgPathDAttributeAfterDragWhileLocked,
+    'Expected the contour path to remain unchanged after dragging while locked'
+  ).toBe(originalSvgPathDAttribute);
+
+  // Unlock the segment and confirm the lock indicator is gone before dragging again.
+  await segment0.actions.toggleLock();
+  await expectRowUnlocked(segment0);
+
+  // Drag with the same motion as while locked.
+  await simulateNormalizedDragOnElement({
+    locator: svgPath,
+    start: { x: 0.8, y: 0.8 },
+    end: { x: 0.2, y: 0.2 },
+  });
+
+  const svgPathDAfterDragWhileUnlocked = await getSvgAttribute({
+    viewportPageObject,
+    svgInnerElement: 'path',
+    attributeName: 'd',
+  });
+  // The path should change after dragging while unlocked.
+  expect(
+    svgPathDAfterDragWhileUnlocked,
+    'Expected the contour path to change after dragging while unlocked'
+  ).not.toBe(originalSvgPathDAttribute);
+});