dimsum-e2e-tests 3.70.0-next.48 → 3.70.0-next.50

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 3.70.0-next.50 (2026-07-24)
+
+**Note:** Version bump only for package dimsum-e2e-tests
+
+## 3.70.0-next.49 (2026-07-21)
+
+### Bug Fixes
+
+- ds-form-checkbox:: update to latest spec [PUI-18112](https://jira.elliemae.io/browse/PUI-18112) ([#8201](https://git.elliemae.io/platform-ui/dimsum/issues/8201)) ([ed9660f](https://git.elliemae.io/platform-ui/dimsum/commit/ed9660fa98038dd1a9fc9c591b6c0980cfba102f))
+
 ## 3.70.0-next.48 (2026-07-20)
 
 ### Bug Fixes

package/ds-controlled-form/ds-controlled-radio/aria-disabled/DSControlledRadio.aria-disabled.axe-core.func.spec.js

@@ -1,3 +1,4 @@
+import { Key } from 'webdriverio';
 import { axeCoreCheck } from '../../../helpers';
 import DSControlledRadioCO from '../DSControlledRadioCO';
 
@@ -13,10 +14,23 @@ if (
       if (errorOnGo) throw errorOnGo;
     });
     it('01: should display radio with aria-disabled and pass axe-core scann', async () => {
-      const radio = await DSControlledRadioCO.getRadioByIndex(1);
+      const result = await axeCoreCheck();
+      await expect(result).toHaveLength(0);
+    });
+    it('02: should focus and select first radio with aria-disabled and pass axe-core scann', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
       await radio.click();
+      await expect(radio).toBeFocused();
+      await expect(radio).toBeSelected();
+      const result = await axeCoreCheck();
+      await expect(result).toHaveLength(0);
+    });
+    it('03: should focus second radio with aria-disabled and pass axe-core scann', async () => {
+      await browser.keys(Key.ArrowDown);
+      const radio = await DSControlledRadioCO.getRadioByIndex(1);
+      await expect(radio).toBeFocused();
       const result = await axeCoreCheck();
-      expect(result.length).toBe(0);
+      await expect(result).toHaveLength(0);
     });
   });
 }

package/ds-controlled-form/ds-controlled-radio/aria-disabled/DSControlledRadio.aria-disabled.func.spec.js

@@ -0,0 +1,37 @@
+import { Key } from 'webdriverio';
+import DSControlledRadioCO from '../DSControlledRadioCO';
+
+if (
+  !browser.capabilities['ice:options'].isPhone &&
+  !browser.capabilities['ice:options'].isTablet &&
+  (browser.capabilities.browserName === 'Chrome' || browser.capabilities.browserName === 'chrome')
+) {
+  describe('PUI-18777 - DSControlledRadio:: aria-disabled group Tab navigation - Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.applyAriaDisabled.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('01: should focus the checked option when tabbing into the aria-disabled group', async () => {
+      const firstRadio = await DSControlledRadioCO.getRadioByIndex(0);
+      await browser.keys(Key.Tab);
+      await expect(firstRadio).toBeFocused();
+      await expect(firstRadio).toBeSelected();
+    });
+    it('02: should focus the second option when arrow down is pressed', async () => {
+      const secondRadio = await DSControlledRadioCO.getRadioByIndex(1);
+      await browser.keys(Key.ArrowDown);
+      await expect(secondRadio).toBeFocused();
+    });
+
+    it('03: should tab out of the group instead of moving to the next option', async () => {
+      const firstRadio = await DSControlledRadioCO.getRadioByIndex(0);
+      const secondRadio = await DSControlledRadioCO.getRadioByIndex(1);
+      const thirdRadio = await DSControlledRadioCO.getRadioByIndex(2);
+      await browser.keys(Key.Tab);
+      await expect(firstRadio).not.toBeFocused();
+      await expect(secondRadio).not.toBeFocused();
+      await expect(thirdRadio).not.toBeFocused();
+    });
+  });
+}

package/ds-data-table-async/DSDataTableCO.js

@@ -265,6 +265,8 @@ export default class DataTableCO extends PageObject {
 
   static customCellRowAndHeaderTest = new Urlbuilder(PATH_E2E_DATATABLE_CELL, 'custom-cell-row-and-header');
 
+  static toggleCellEnterFocus = new Urlbuilder(PATH_E2E_DATATABLE_CELL, 'toggle-cell-enter-focus-test');
+
   // Use Cases
 
   static integratedExampleWithFilters = new Urlbuilder(PATH_E2E_DATATABLE_USE_CASES, 'integrated-example-with-filters');

package/ds-data-table-async/components/HeaderCO.js

@@ -57,6 +57,13 @@ export default class HeaderCO extends PageObject {
   // that fix.
   static getResizeHandler = async (index) => $$('[data-testid="ds-datatable-resizer"]')[index];
 
+  static getResizeHandlers = async () => $$('[data-testid="ds-datatable-resizer"]');
+
+  static getLastResizeHandler = async () => {
+    const all = await this.getResizeHandlers();
+    return all[all.length - 1];
+  };
+
   static getFilterBtnByIndex = async (index) => $$('[data-testid="data-table-filter-menu-button"] button')[index];
 
   static getSortBtnByIndex = async (index) => {
@@ -64,6 +71,14 @@ export default class HeaderCO extends PageObject {
     return headerCell.$('[data-testid="data-table-sort-button"]');
   };
 
+  // Filter icon wrapper scoped to a single header cell. The wrapper span carries the
+  // display:none/opacity:0 "hide" styling driven by the header's hover/focus state (PUI-15154),
+  // so its isDisplayed() reflects filter-icon visibility for that specific column.
+  static getFilterButtonInHeader = async (index) => {
+    const headerCell = await this.getHeaderCellByIndex(index);
+    return headerCell.$('[data-testid="data-table-filter-menu-button"]');
+  };
+
   // PUI-17786: a11y accessors for the resize handle. Targets the same [data-testid="ds-datatable-resizer"]
   // as the getResizeHandler selector fix (separate PR); kept distinct so these a11y specs run standalone.
   static getResizer = async (index) => $$('[data-testid="ds-datatable-resizer"]')[index];

package/ds-data-table-async/filter-menu-close/DSDataTable.filter-menu-close.func.spec.js

@@ -0,0 +1,39 @@
+import { mouseOver } from '../../helpers';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO, FiltersCO } from '../components';
+
+// SKIPPED pending fix for defect PUI-18785: an open per-column filter menu does not close when the
+// user clicks the column header cell or its drag-and-drop handle — the column can even be dragged
+// with the menu open, and the menu drops alongside the column and stays open. These tests capture
+// the EXPECTED behavior (the menu must close on those interactions). Un-skip them once PUI-18785
+// lands, then create the Test ticket and replace PUI-XXXXX.
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe.skip('PUI-XXXXX - DSDataTable:: filter menu closes on column header or drag interaction - Func', () => {
+    beforeEach(async () => {
+      const errorOnGo = await DSDataTableCO.sortByColumn.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: clicking the column drag handle closes an open filter menu', async () => {
+      const idHeader = await HeaderCO.getHeaderCellByIndex(0);
+      await mouseOver(idHeader);
+      await (await HeaderCO.getFilterBtnByIndex(0)).click();
+      await expect(await FiltersCO.getFilterMenuContent()).toBeDisplayed();
+
+      const dragHandle = await HeaderCO.getHeaderCellDragHandler(idHeader);
+      await dragHandle.click();
+      await expect(await FiltersCO.getFilterMenuContent()).not.toBeDisplayed();
+    });
+
+    it('02: clicking the column header cell closes an open filter menu', async () => {
+      const idHeader = await HeaderCO.getHeaderCellByIndex(0);
+      await mouseOver(idHeader);
+      await (await HeaderCO.getFilterBtnByIndex(0)).click();
+      await expect(await FiltersCO.getFilterMenuContent()).toBeDisplayed();
+
+      await idHeader.click();
+      await expect(await FiltersCO.getFilterMenuContent()).not.toBeDisplayed();
+    });
+  });
+}

package/ds-data-table-async/header-affordances/DSDataTable.header-affordances.func.spec.js

@@ -0,0 +1,92 @@
+import { mouseOver } from '../../helpers';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO, RowCO } from '../components';
+
+// Coverage for PUI-15154 (fixed): the column-header affordances — DnD drag handle, neutral sort
+// caret and filter icon — stayed visibly stuck after focus/hover left the header (null-vs-null
+// false match in the onBlur guard; missing resetAllHeadersExcept between columns). They must only
+// show while the header has focus or hover. jsdom can't move real focus or hover, so this is
+// verified in a real browser here (the shipped unit test fakes it with synthetic relatedTarget).
+//
+// SortByColumn columns: id(0) name(1, actively sorted) position(2) country(3) salary(4) date(5).
+// position = drag handle + neutral sort caret + filter icon; date = the reported-bug column
+// (drag handle + neutral sort caret, no filter). All columns are draggable.
+const POSITION_COL = 2;
+const DATE_COL = 5;
+
+const expectAffordances = async (colIndex, shown, hasFilter) => {
+  const cell = await HeaderCO.getHeaderCellByIndex(colIndex);
+  const dragHandle = await HeaderCO.getHeaderCellDragHandler(cell);
+  const sortCaret = await HeaderCO.getSortBtnByIndex(colIndex);
+  if (shown) {
+    await expect(dragHandle).toBeExisting();
+    await expect(sortCaret).toBeDisplayed();
+    if (hasFilter) await expect(await HeaderCO.getFilterButtonInHeader(colIndex)).toBeDisplayed();
+  } else {
+    await expect(dragHandle).not.toBeExisting();
+    await expect(sortCaret).not.toBeDisplayed();
+    if (hasFilter) await expect(await HeaderCO.getFilterButtonInHeader(colIndex)).not.toBeDisplayed();
+  }
+};
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18778 - DSDataTable:: header affordance visibility on focus and hover - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.sortByColumn.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: focusing a column header shows its drag handle, sort caret and filter icon', async () => {
+      // Focus programmatically: the header cell has onClick=handleSort, so clicking it would also
+      // sort the column, and an actively-sorted column's caret then stays visible regardless of
+      // focus — masking the hide-on-blur behavior under test. Focusing fires onFocus without sorting.
+      await browser.execute((el) => el.focus(), await HeaderCO.getHeaderCellByIndex(POSITION_COL));
+      await expectAffordances(POSITION_COL, true, true);
+    });
+
+    it('02: clicking another column drag handle hides the first column drag handle', async () => {
+      // Marcos #2 (handle-to-handle): reveal + click column A's drag handle, then column B's.
+      // Focusing B's handle clears A via resetAllHeadersExcept, so A's handle no longer stays stuck.
+      const positionHeader = await HeaderCO.getHeaderCellByIndex(POSITION_COL);
+      await mouseOver(positionHeader);
+      const positionHandle = await HeaderCO.getHeaderCellDragHandler(positionHeader);
+      await positionHandle.waitForDisplayed({ timeout: 3000 });
+      await positionHandle.click();
+
+      const dateHeader = await HeaderCO.getHeaderCellByIndex(DATE_COL);
+      await mouseOver(dateHeader);
+      const dateHandle = await HeaderCO.getHeaderCellDragHandler(dateHeader);
+      await dateHandle.waitForDisplayed({ timeout: 3000 });
+      await dateHandle.click();
+
+      // Column A's (position) drag handle is gone; column B's (date) handle is present.
+      const positionCell = await HeaderCO.getHeaderCellByIndex(POSITION_COL);
+      await expect(await HeaderCO.getHeaderCellDragHandler(positionCell)).not.toBeExisting();
+      const dateCell = await HeaderCO.getHeaderCellByIndex(DATE_COL);
+      await expect(await HeaderCO.getHeaderCellDragHandler(dateCell)).toBeExisting();
+    });
+
+    it('03: blurring focus away entirely hides the affordances', async () => {
+      // Reported bug: focus leaves with nowhere to land. Ensure the pointer is off any header (so
+      // hover isn't keeping the column visible), then drop focus. onBlur fires with relatedTarget
+      // null and, since date has no filter, filterIconRef is null too: the null-vs-null false match
+      // that used to skip the reset (PUI-15154) must no longer keep the affordances stuck visible.
+      await mouseOver(await RowCO.getRowByIndex(3));
+      await browser.execute(() => {
+        if (document.activeElement instanceof HTMLElement) document.activeElement.blur();
+      });
+      await expectAffordances(DATE_COL, false, false);
+    });
+
+    it('04: hovering a column header shows its drag handle, sort caret and filter icon', async () => {
+      await mouseOver(await HeaderCO.getHeaderCellByIndex(POSITION_COL));
+      await expectAffordances(POSITION_COL, true, true);
+    });
+
+    it('05: moving the mouse away from the header hides the affordances', async () => {
+      await mouseOver(await RowCO.getRowByIndex(3));
+      await expectAffordances(POSITION_COL, false, true);
+    });
+  });
+}

package/ds-data-table-async/resizable/DSDataTable.resize-min-clamp.func.spec.js

@@ -0,0 +1,72 @@
+import { Key } from 'webdriverio';
+import { sendKeyRepeat } from '../../helpers';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO } from '../components';
+
+// Coverage for PUI-12696 (fixed): a keyboard double-delta commit in useHeaderResizer let the last
+// column resize below its declared minWidth, so the resize handle overlapped the header title.
+// The resizableWithConstrains story sets minWidth: 100 / maxWidth: 300 on all 7 columns, so the
+// last column (dateRange, index 6) must clamp at 100 no matter how hard it is shrunk.
+const LAST_COLUMN_INDEX = 6;
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18764 - DSDataTable:: last column resize clamps at minWidth - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.resizableWithConstrains.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: keyboard Shift+Alt+ArrowLeft should not shrink last column below minWidth', async () => {
+      // Focus the last column's resize handle: click its header, then Return focuses the handle
+      // directly (no drag/filter/sort child precedes it on this story) — same flow as PUI-11345.
+      const lastHeader = await HeaderCO.getHeaderCellByIndex(LAST_COLUMN_INDEX);
+      await lastHeader.click();
+      await browser.keys(Key.Return);
+      await expect(await HeaderCO.getLastResizeHandler()).toBeFocused();
+
+      // Each Shift+Alt+ArrowLeft is -50px; 6 presses drives well past the 100px floor.
+      await sendKeyRepeat([Key.Shift, Key.Alt, Key.ArrowLeft], 6);
+
+      await browser.waitUntil(
+        async () => {
+          const resizer = await HeaderCO.getLastResizeHandler();
+          const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+          const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+          return valueNow === valueMin;
+        },
+        { timeout: 5000, timeoutMsg: 'last column did not clamp at minWidth after keyboard shrink' },
+      );
+
+      const resizer = await HeaderCO.getLastResizeHandler();
+      const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+      const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+      // aria-valuenow mirrors the committed column width, so clamping at aria-valuemin (100) is the
+      // deterministic guard that the width was NOT reduced beyond its minimum limit (PUI-12696).
+      expect(valueNow).toBe(valueMin); // committed width clamped exactly at the floor
+      expect(valueNow).toBeGreaterThanOrEqual(100); // never below the declared minWidth
+    });
+
+    it('02: mouse drag should not shrink last column below minWidth', async () => {
+      // Widen first so the following shrink is a real reduction, then drag well past the floor.
+      await (await HeaderCO.getLastResizeHandler()).dragAndDrop({ x: 120, y: 0 });
+      await (await HeaderCO.getLastResizeHandler()).dragAndDrop({ x: -400, y: 0 });
+
+      await browser.waitUntil(
+        async () => {
+          const resizer = await HeaderCO.getLastResizeHandler();
+          const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+          const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+          return valueNow === valueMin;
+        },
+        { timeout: 5000, timeoutMsg: 'last column did not clamp at minWidth after mouse shrink' },
+      );
+
+      const resizer = await HeaderCO.getLastResizeHandler();
+      const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+      const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+      expect(valueNow).toBe(valueMin);
+      expect(valueNow).toBeGreaterThanOrEqual(100);
+    });
+  });
+}

package/ds-data-table-async/toggle-cell-focus/DSDataTable.toggle-cell-enter-focus.func.spec.js

@@ -0,0 +1,31 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO, CellCO } from '../components';
+import DSToggleCO from '../../ds-form-toggle/DSToggleCO';
+
+// Coverage for PUI-14730 (fixed): a toggle (DSControlledToggle) used as a custom cell did not
+// receive focus on the first Enter — it dropped its ref (containerProps only reached the wrapper
+// div; innerRef was discarded). Fixed in ds-form-toggle by forwarding innerRef to the underlying
+// <button role="switch">. The story renders the toggle as the FIRST focusable cell, so Enter on a
+// focused row must land focus on the toggle button (row.cells.find(c => c.ref.current).focus()).
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18783 - DSDataTable:: toggle custom cell focus on row Enter - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.toggleCellEnterFocus.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: pressing Enter on a focused row moves focus to the toggle custom cell', async () => {
+      // Focus the row by clicking its first cell (the focusable row-content, role="row", receives
+      // focus), then press Enter — matches the editable-cell Enter-to-first-cell pattern.
+      const row = await RowCO.getRowByIndex(0);
+      const firstCell = await CellCO.getRowCellByIndex(row, 0);
+      await firstCell.click();
+      await browser.keys(Key.Return);
+
+      const toggle = await DSToggleCO.getToggleFocuseableByIndex(0);
+      await expect(toggle).toBeFocused();
+    });
+  });
+}

package/ds-form-date-range-picker/DateRangePicker.axe-core.spec.js

@@ -17,6 +17,11 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     it('02: should have expanded calendar, empty input and pass axe-core scan', async () => {
       const calendarTrigger = await DateRangePickerCO.getPickerBtn();
       await calendarTrigger.click();
+      // PUI-15571: the calendar popover must be announced as a dialog (it used to expose
+      // role="region"), with an accessible name (WCAG 4.1.2 Name, Role, Value).
+      const dialog = await DateRangePickerCO.getCalendarDialog();
+      await expect(dialog).toHaveAttribute('role', 'dialog');
+      await expect(dialog).toHaveAttribute('aria-label', 'calendar header');
       const result = await axeCoreCheck();
       expect(result.length).toBe(0);
     });

package/ds-form-date-range-picker/DateRangePicker.functional.spec.js

@@ -34,8 +34,16 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
       await openPickerBtn.click();
       const startDate = await DateRangePickerCO.getRangeStartDay();
       const endDate = await DateRangePickerCO.getRangeEndDay();
-      await expect(startDate).toHaveAttribute('aria-label', 'February third 2020, Monday');
-      await expect(endDate).toHaveAttribute('aria-label', 'February eighth 2020, Saturday');
+      // PUI-18279 (a11y): days inside the selected range announce the whole range instead of a
+      // bare weekday label, so screen-reader users hear the full selection on every range day.
+      await expect(startDate).toHaveAttribute(
+        'aria-label',
+        'February third 2020, range from February third 2020 to February eighth 2020 selected.',
+      );
+      await expect(endDate).toHaveAttribute(
+        'aria-label',
+        'February eighth 2020, range from February third 2020 to February eighth 2020 selected.',
+      );
     });
     it('03: should change the text input to the picked date (mouse)', async () => {
       const exampleDate1 = await DateRangePickerCO.getDayOnCalendarByIndex(16);
@@ -55,24 +63,78 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
       await expect(endingDay).toHaveValue(expect.stringContaining('09'));
       await expect(endingYear).toHaveValue(expect.stringContaining('2020'));
     });
-    it('04: should change the text input to the picked date (KB)', async () => {
-      await browser.keys(Key.ArrowDown);
-      await browser.keys(Key.Return);
+    // Keyboard range selection previously lived here as a 4th step, but it re-picked over the range
+    // typed in test 01 (a stateful re-pick whose result is hard to reason about). It now has
+    // dedicated, deterministic, fresh-state coverage in the PUI-15572 describe below (mouse +
+    // keyboard + auto-ordering).
+  });
+
+  // PUI-15572 (WCAG 3.2.2 On Input): completing the range must close the calendar automatically and
+  // return focus to the trigger so the user knows the selection succeeded. beforeEach reloads a
+  // fresh empty picker so each scenario is independent (the stateful Basic flow above re-picks over
+  // an existing range and is intentionally not used to assert closure). The story fixes
+  // onCalendarOpenFocusedDay to 12/27/2000, so keyboard navigation lands on deterministic days.
+  describe('PUI-18775 - DSControlledDateRangePicker:: calendar closes on completed range -Func', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DateRangePickerCO.basic.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('01: should stay open on start pick, then close and refocus trigger on end pick (mouse)', async () => {
+      const openPickerBtn = await DateRangePickerCO.getPickerBtn();
+      await openPickerBtn.click();
+      const dialog = await DateRangePickerCO.getCalendarDialog();
+      await expect(dialog).toBeDisplayedInViewport();
+
+      // first pick = start date -> range incomplete, calendar must stay open
+      await (await DateRangePickerCO.getDayOnCalendarByIndex(16)).click();
+      await expect(dialog).toBeDisplayedInViewport();
+
+      // second pick = end date -> range complete, calendar must close and focus returns to trigger
+      await (await DateRangePickerCO.getDayOnCalendarByIndex(20)).click();
+      await expect(dialog).not.toBeDisplayedInViewport();
+      await expect(openPickerBtn).toBeFocused();
+    });
+
+    it('02: should complete the range via keyboard, closing the calendar and refocusing the trigger', async () => {
+      const openPickerBtn = await DateRangePickerCO.getPickerBtn();
+      await openPickerBtn.click();
+      const dialog = await DateRangePickerCO.getCalendarDialog();
+      await expect(dialog).toBeDisplayedInViewport();
+
+      // focus opens on Dec 27 2000; ArrowRight -> Dec 28, Enter picks the start (range incomplete)
       await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.Enter);
+      await expect(dialog).toBeDisplayedInViewport();
+
+      // ArrowRight x2 -> Dec 30, Enter completes the range -> calendar closes and focus returns
       await browser.keys(Key.ArrowRight);
-      await browser.keys(Key.Space);
-      const startingMonth = await DateRangePickerCO.getMonthInputByIndex(0);
-      const startingDay = await DateRangePickerCO.getDayInputByIndex(0);
-      const startingYear = await DateRangePickerCO.getYearInputByIndex(0);
-      const endingMonth = await DateRangePickerCO.getMonthInputByIndex(1);
-      const endingDay = await DateRangePickerCO.getDayInputByIndex(1);
-      const endingYear = await DateRangePickerCO.getYearInputByIndex(1);
-      await expect(startingMonth).toHaveValue(expect.stringContaining('02'));
-      await expect(startingDay).toHaveValue(expect.stringContaining('14'));
-      await expect(startingYear).toHaveValue(expect.stringContaining('2020'));
-      await expect(endingMonth).toHaveValue(expect.stringContaining('02'));
-      await expect(endingDay).toHaveValue(expect.stringContaining('16'));
-      await expect(endingYear).toHaveValue(expect.stringContaining('2020'));
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.Enter);
+      await expect(dialog).not.toBeDisplayedInViewport();
+      await expect(openPickerBtn).toBeFocused();
+
+      await expect(await DateRangePickerCO.getMonthInputByIndex(0)).toHaveValue(expect.stringContaining('12'));
+      await expect(await DateRangePickerCO.getDayInputByIndex(0)).toHaveValue(expect.stringContaining('28'));
+      await expect(await DateRangePickerCO.getMonthInputByIndex(1)).toHaveValue(expect.stringContaining('12'));
+      await expect(await DateRangePickerCO.getDayInputByIndex(1)).toHaveValue(expect.stringContaining('30'));
+    });
+
+    it('03: should auto-order the range when the completing pick precedes the start pick', async () => {
+      const openPickerBtn = await DateRangePickerCO.getPickerBtn();
+      await openPickerBtn.click();
+      const dialog = await DateRangePickerCO.getCalendarDialog();
+
+      // pick the start (Dec 28), then pick an earlier day (ArrowUp = -1 week -> Dec 21)
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.Enter);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.Enter);
+
+      // the earlier day becomes the start (from < to) and the range completes -> calendar closes
+      await expect(dialog).not.toBeDisplayedInViewport();
+      await expect(await DateRangePickerCO.getDayInputByIndex(0)).toHaveValue(expect.stringContaining('21'));
+      await expect(await DateRangePickerCO.getDayInputByIndex(1)).toHaveValue(expect.stringContaining('28'));
     });
   });
 

package/ds-form-date-range-picker/DateRangePickerCO.js

@@ -118,6 +118,12 @@ export default class DateRangePickerCO extends PageObject {
     return $(`[data-testid="ds-controlled-date-time-picker-calendar-context-content-wrapper"]`);
   }
 
+  // The open calendar popover is the modal dialog (role="dialog"); it is the same DOM node as
+  // the contextual-menu wrapper above, exposed here under an accessibility-semantic name.
+  static async getCalendarDialog() {
+    return $(`[data-testid="ds-controlled-date-time-picker-calendar-context-content-wrapper"]`);
+  }
+
   static async getCalendarHeaderLabel() {
     return $(`[data-testid="ds-controlled-date-time-picker-calendar-header-label"]`);
   }

package/ds-form-date-time-picker/partial-date-open-focus/DateTimePicker.partial-date-open-focus.func.spec.js

@@ -0,0 +1,45 @@
+import DateTimePickerCO from '../DSControlledDateTimePickerCO';
+import { type } from '../../helpers';
+
+// Tests for the fix introduced in PUI-15900 (focus lost when the input holds a partial date
+// while onCalendarOpenFocusedDay is set — the displayed month must follow the focused day so
+// the prop date is rendered and receives focus on open).
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18784 - DSControlledDateTimePicker:: focus on calendar open with partial date -Func', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.emptyDatePickerStartingMonth.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('01: empty input focuses the onCalendarOpenFocusedDay day (Dec 27) on open', async () => {
+      const trigger = await DateTimePickerCO.getTrigger();
+      await trigger.click();
+
+      const focusedDay = await DateTimePickerCO.getCalendarFocusedDay();
+      await expect(focusedDay).toHaveText('27');
+      await expect(focusedDay).toBeFocused();
+    });
+
+    it('02: partial month still focuses the onCalendarOpenFocusedDay day (Dec 27) on open', async () => {
+      const month = await DateTimePickerCO.getMonthInput();
+      await month.click();
+      await type('1'); // partial date — month typed, no day/year
+
+      const trigger = await DateTimePickerCO.getTrigger();
+      await trigger.click();
+
+      // grid follows the focused day's month (December) so the prop date is visible + focused
+      const focusedDay = await DateTimePickerCO.getCalendarFocusedDay();
+      await expect(focusedDay).toHaveText('27');
+      await expect(focusedDay).toBeFocused();
+
+      // the displayed month must be December 2000 (the prop's month), not the typed January
+      const headerLabel = await DateTimePickerCO.getCalendarHeaderLabel();
+      await expect(headerLabel).toHaveText('December 2000');
+
+      // focus must NOT have landed on the previous-month navigation button
+      const prevMonthBtn = await DateTimePickerCO.getCalendarPrevMonthBtn();
+      await expect(prevMonthBtn).not.toBeFocused();
+    });
+  });
+}

package/ds-form-toggle/DSToggle.func.spec.js

@@ -11,14 +11,16 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
       await (await DSToggleCO.getToggle()).waitForExist();
     });
     it('01: should change state to ON', async () => {
-      await (await DSToggleCO.getToggle()).click();
-      const toggleState = await DSToggleCO.getToggleState('ON');
-      await expect(toggleState).toBeDisplayed();
+      await (await DSToggleCO.getSwitch()).click();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'true');
+      // the visible (presentational) label should track the state
+      await expect(await DSToggleCO.getStateLabel()).toHaveText('ON');
     });
     it('02: should change state to OFF', async () => {
-      await (await DSToggleCO.getToggle()).click();
-      const toggleState = await DSToggleCO.getToggleState('OFF');
-      await expect(toggleState).toBeDisplayed();
+      await (await DSToggleCO.getSwitch()).click();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'false');
+      // the visible (presentational) label should track the state
+      await expect(await DSToggleCO.getStateLabel()).toHaveText('OFF');
     });
   });
   describe('PUI-6760 - DSControlledToggle:: states on/off - keyboard navigation', () => {
@@ -34,18 +36,15 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     });
     it('02: should change state to ON (Enter)', async () => {
       await browser.keys(Key.Enter);
-      const toggleState = await DSToggleCO.getToggleState('ON');
-      await expect(toggleState).toBeDisplayed();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'true');
     });
     it('03: should change state to OFF (Space)', async () => {
       await browser.keys(Key.Space);
-      const toggleState = await DSToggleCO.getToggleState('OFF');
-      await expect(toggleState).toBeDisplayed();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'false');
     });
     it('04: should change state to ON (Space)', async () => {
       await browser.keys(Key.Space);
-      const toggleState = await DSToggleCO.getToggleState('ON');
-      await expect(toggleState).toBeDisplayed();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'true');
     });
   });
 
@@ -56,10 +55,11 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
       await (await DSToggleCO.getToggle()).waitForExist();
     });
     it('01: should not change state in disabled toggle', async () => {
-      const disabledToggle = await DSToggleCO.getToggleByIndex(0);
-      await disabledToggle.click();
-      const toggleState = await disabledToggle.$('//div[@disabled]//div[2]').getText();
-      await expect(toggleState).toEqual('ON');
+      const disabledSwitch = await DSToggleCO.getSwitch(0);
+      const initialState = await disabledSwitch.getAttribute('aria-checked');
+      // click the container (the button itself is disabled and not interactable)
+      await (await DSToggleCO.getToggleByIndex(0)).click();
+      await expect(await DSToggleCO.getSwitch(0)).toHaveAttribute('aria-checked', initialState);
     });
   });
 
@@ -84,18 +84,15 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     });
     it('03: should not change state on [Enter] key press', async () => {
       await browser.keys(Key.Enter);
-      const toggleState = await DSToggleCO.getToggleState('OFF');
-      await expect(toggleState).toBeDisplayed();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'false');
     });
     it('04: should not change state on [Space] key press', async () => {
       await browser.keys(Key.Space);
-      const toggleState = await DSToggleCO.getToggleState('OFF');
-      await expect(toggleState).toBeDisplayed();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'false');
     });
     it('05: should not change state on click', async () => {
-      await (await DSToggleCO.getToggle()).click();
-      const toggleState = await DSToggleCO.getToggleState('OFF');
-      await expect(toggleState).toBeDisplayed();
+      await (await DSToggleCO.getSwitch()).click();
+      await expect(await DSToggleCO.getSwitch()).toHaveAttribute('aria-checked', 'false');
     });
   });
   describe('PUI-8814 - DSControlledToggle:: Tabbing', () => {