dimsum-e2e-tests 3.70.0-next.6 → 3.70.0-next.60

package/ds-data-table-async/basic/DSDataTable.basic.visual.spec.js

@@ -20,7 +20,7 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
   });
   describe('PUI-6988 - DataTable, Custom cell and row header -visual.', async () => {
     before('loading page', async () => {
-      const errorOnGo = await DSDataTableCO.customCellRowHeader.go();
+      const errorOnGo = await DSDataTableCO.customCellRowAndHeaderTest.go();
       if (errorOnGo) throw errorOnGo;
       await DSDataTableCO.waitForDataTable();
     });

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

@@ -70,6 +70,13 @@ export default class FilterBarCO extends PageObject {
 
   static getPillCloseButtonByIndex = async (index) => getElementByIndex(this.getAllPillCloseButtons, index);
 
+  // Label pill wrapper exposes role="group" + aria-label = the pill label text (pillLabel || Header).
+  static getLabelPillByName = async (name) => $(`[role="group"][aria-label="${name}"]`);
+
+  // SVG icon inside a label pill (found by its accessible name) — asserts a custom pill renderer drew
+  // its own icon. The label pill wrapper is the role="group" element; its descendant <svg> is the icon.
+  static getPillIconByName = async (name) => $(`[role="group"][aria-label="${name}"] svg`);
+
   static async getFilterBarDropDownOption(label) {
     return $(`[role=option][label="${label}"]`);
   }

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

@@ -145,7 +145,7 @@ export default class FiltersCO extends PageObject {
 
   static getFilterMenuContentSlot = async () => $('[data-dimsum-slot="dsDatatableFilterPopoverContent"]');
 
-  static getFilterPopoverSlot = async () => $('[data-dimsum-slot="dsDatatableFilterPopover"]');
+  static getFilterPopoverSlot = async () => $('[data-dimsum-parent-slot="dsDatatableFilterPopover"]');
 
   static getFreeTextSearchWrapperSlot = async () => $('[data-dimsum-slot="dsDatatableFreeTextSearchWrapper"]');
 

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

@@ -51,7 +51,18 @@ export default class HeaderCO extends PageObject {
 
   static getHeadersWrapper = async () => $('[data-testid="ds-datatable-head-wrapper"]');
 
-  static getResizeHandler = async (index) => $$('[data-testid="column"],[aria-label="Resize column"]')[index];
+  // PUI-17784: resize handle changed from <input type="range" aria-label="Resize column"> to a
+  // <button role="application" aria-labelledby> with dynamic "Resize {column} column" naming; the old
+  // selector never matched data-testid="column" (unverified in d2) and stopped matching aria-label after
+  // 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];
 
@@ -60,6 +71,39 @@ 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];
+
+  /**
+   * Text of the node the resizer's aria-labelledby points at. This is a WIRING check only — it
+   * proves the reference resolves to the intended span, NOT that the browser computes a name from
+   * it. Use getResizerComputedName for that. (The two can disagree: the name span is display:none,
+   * and whether a hidden aria-labelledby target contributes to the computed name is exactly the
+   * thing this must not assume.)
+   */
+  static getResizerLabelledByText = async (resizer) => {
+    const labelledById = await resizer.getAttribute('aria-labelledby');
+    if (!labelledById) return null;
+    return (await $(`#${labelledById}`)).getProperty('textContent');
+  };
+
+  /**
+   * The accessible name the BROWSER computes for the resizer, via the W3C WebDriver
+   * "Get Computed Label" endpoint — the accname algorithm's real output, not a re-implementation.
+   * Only meaningful while the handle is exposed: at rest it is aria-hidden, so it is outside the
+   * accessibility tree and has no computed name by design.
+   */
+  static getResizerComputedName = async (resizer) => resizer.getComputedLabel();
+
   // Snapshots
   static snapshotPath(example = 'basic') {
     return PageObject.getSnapshotPathBuilder('DataTable', example, 'ds-data-table');

package/ds-data-table-async/dnd/DSDataTable.dnd-keyboard-scroll.func.spec.js

@@ -0,0 +1,51 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO } from '../components';
+
+// Tests for the fix introduced in PUI-8826. Holding ArrowDown during a keyboard row drag fired
+// dnd-kit's default smooth scroll on every key-repeat keydown, re-targeting the in-flight scroll
+// animation before it settled — this read as the dragged row "flickering". The fix pins the
+// KeyboardSensor to scrollBehavior: 'auto', so repeated keydowns produce instant jumps instead.
+const REPEATED_PRESSES = 15;
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-18883 - DSDataTable:: keyboard row drag scroll on held ArrowDown - Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.keyboardDragScroll.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+      await DSDataTableCO.installScrollSpy();
+    });
+    it('01: the drag survives a burst of ArrowDown presses', async () => {
+      const dragHandle = await RowCO.getRowDragHlandlerByIndex(0);
+      await dragHandle.click();
+      await browser.keys(Key.Space);
+      await expect(dragHandle).toHaveAttribute('aria-pressed', 'true');
+
+      await DSDataTableCO.pressArrow('down', REPEATED_PRESSES);
+      // Still picked up and still holding focus — the repeat burst neither dropped the row nor
+      // stole focus mid-scroll.
+      await expect(dragHandle).toHaveAttribute('aria-pressed', 'true');
+      await expect(dragHandle).toBeFocused();
+    });
+    it('02: the burst scrolled the viewport and never used behavior "smooth"', async () => {
+      // Sanity first: a 200px viewport over 40 rows means the drag must have scrolled. Without
+      // this the behavior assertion below could pass without exercising the fix at all.
+      const scrollTop = await DSDataTableCO.getScrollableContainerScrollTop();
+      await expect(scrollTop).toBeGreaterThan(0);
+
+      const scrollCalls = await DSDataTableCO.getScrollSpyCalls();
+      await expect(scrollCalls.length).toBeGreaterThan(0);
+      await expect(scrollCalls.every((call) => call.behavior === 'auto')).toBe(true);
+    });
+    it('03: dropping with Space reorders the list and keeps the dragged row focused', async () => {
+      await browser.keys(Key.Space);
+      await expect(await DSDataTableCO.getFocusedRowIdCellText()).toBe('1');
+    });
+  });
+}

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

@@ -0,0 +1,77 @@
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO, FiltersCO } from '../components';
+
+// Tests for the fix introduced in PUI-18785 (an open per-column filter menu did not close when the
+// user clicked that column's header cell, grabbed its drag-and-drop handle, or grabbed its resize
+// handle — the filter popover's floating reference is the whole header cell, so the click-outside
+// detection never saw any of those interactions as "outside", and the menu could be dragged around
+// the table while open).
+//
+// The SortByColumn story is the repro combination named in the defect: per-column filters +
+// dragAndDropColumns + isResizeable on the same table.
+//
+// The target is the Country column: it is filterable but canSort is false, so a header click has
+// only the filter to close and never also triggers a sort — the assertions stay about the menu and
+// nothing else. That also makes FiltersCO.openFilterPopperByColumnName safe to use here even though
+// it clicks the header cell to reveal the affordance; hovering instead is not portable, because in
+// Safari the filter button stays aria-hidden/tabindex="-1" and never becomes interactable.
+//
+// Deviation from the ticket, asserted deliberately: PUI-18785's Expected Results asked that a
+// column "should not be draggable while its filter menu is open". The shipped fix instead closes
+// the menu and lets the same single gesture continue into the drag/resize, so these tests assert
+// that shipped behavior — the menu closes, and the interaction is not swallowed just to close it.
+const COUNTRY_COLUMN = 'country';
+const COUNTRY_COLUMN_INDEX = 3;
+
+const openCountryFilterMenu = async () => {
+  await FiltersCO.openFilterPopperByColumnName(COUNTRY_COLUMN);
+  await expect(await FiltersCO.getFilterMenuContent()).toBeDisplayed();
+};
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18887 - DSDataTable:: filter menu closes on header, drag and resize - Func', () => {
+    beforeEach(async () => {
+      const errorOnGo = await DSDataTableCO.sortByColumn.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: clicking the column header closes an open filter menu and keeps the trigger', async () => {
+      await openCountryFilterMenu();
+
+      const countryHeader = await HeaderCO.getHeaderCellByText(COUNTRY_COLUMN);
+      await countryHeader.click();
+
+      await expect(await FiltersCO.getFilterMenuContent()).not.toBeDisplayed();
+      // Closing the menu must not take its own trigger with it. An over-broad fix that removed the
+      // whole filter affordance would still satisfy the assertion above, so the trigger is checked
+      // explicitly. Existence rather than visibility: the filter button is toggled with display:none
+      // by the header's own affordance logic, so a visibility assertion would be testing that
+      // unrelated hover/active state instead of the fix.
+      const filterBtn = await FiltersCO.getHeaderCellFilterButtonByHeaderCell(countryHeader, 0);
+      await expect(filterBtn).toBeExisting();
+    });
+
+    it('02: activating the column drag handle closes an open filter menu', async () => {
+      await openCountryFilterMenu();
+
+      const countryHeader = await HeaderCO.getHeaderCellByText(COUNTRY_COLUMN);
+      const dragHandle = await HeaderCO.getHeaderCellDragHandler(countryHeader);
+      await dragHandle.click();
+
+      await expect(await FiltersCO.getFilterMenuContent()).not.toBeDisplayed();
+    });
+
+    it('03: grabbing the column resize handle closes an open filter menu', async () => {
+      await openCountryFilterMenu();
+
+      // A real press-move-release on the 4px handle, which is what fires onResizeStart. Asserting
+      // the resize itself is out of scope here — that is PUI-18764's job; this test only proves the
+      // press reaches the resizer and closes the menu.
+      const resizer = await HeaderCO.getResizeHandler(COUNTRY_COLUMN_INDEX);
+      await resizer.dragAndDrop({ x: 30, y: 0 });
+
+      await expect(await FiltersCO.getFilterMenuContent()).not.toBeDisplayed();
+    });
+  });
+}

package/ds-data-table-async/filter-popover-boundary/DSDataTable.filter-popover-boundary.func.spec.js

@@ -0,0 +1,98 @@
+import DSDataTableCO from '../DSDataTableCO';
+import { FiltersCO } from '../components';
+
+// Tests for the fix introduced in PUI-17187 (the filter trigger lives inside DataTable's own
+// horizontally-scrollable container, but the popover only clipped against the browser viewport, so
+// once its column scrolled near the table's edge the popover kept tracking the trigger's raw screen
+// position and spilled out over the rest of the page). The fix passes the scroll container as
+// ds-floating-context's boundaryElement, which clamps the popover to the table and hides it — without
+// closing it — once the trigger is fully scrolled away.
+//
+// The Pui17136FilterWidthCollapse story is the repro named in the defect: a 400px-wide table with
+// colsLayoutStyle="fixed" and nine filterable columns, so there is real horizontal overflow.
+//
+// The Name column is targeted rather than the ticket's Number range column: it sits near the left
+// edge, so scrolling right drives it against the table's OWN left edge, which is the geometry the
+// fix is about, and it is reachable without scrolling first. Both columns exercise the same
+// boundaryElement math.
+const TARGET_COLUMN = 'name';
+
+// The popover repositions on a debounce, so every geometry assertion polls rather than sampling once.
+const SETTLE_TIMEOUT = 5000;
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18888 - DSDataTable:: filter popover clamped to the table on horizontal scroll - Func', () => {
+    beforeEach(async () => {
+      const errorOnGo = await DSDataTableCO.filterWidthCollapse.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+      await FiltersCO.openFilterPopperByColumnName(TARGET_COLUMN);
+      await expect(await FiltersCO.getFilterMenuContent()).toBeDisplayed();
+    });
+
+    it('01: should keep the popover inside the table bounds while its column is clipped', async () => {
+      const geometry = await DSDataTableCO.getColumnScrollGeometry(TARGET_COLUMN);
+      expect(geometry).not.toBe(null);
+
+      // Leave a 20px sliver of the column visible at the scrollport's left edge: the trigger is
+      // partially clipped by the table itself, which is exactly the PUI-17187 repro state.
+      const partiallyClipped = Math.min(geometry.colRight - 20, geometry.maxScrollLeft);
+      expect(partiallyClipped).toBeGreaterThan(0);
+      await DSDataTableCO.setScrollableContainerScrollLeft(partiallyClipped);
+
+      await browser.waitUntil(
+        async () => {
+          const rects = await DSDataTableCO.getFilterPopoverBoundaryRects();
+          if (!rects) return false;
+          // 1px of tolerance for sub-pixel layout rounding.
+          return rects.popoverLeft >= rects.containerLeft - 1 && rects.popoverRight <= rects.containerRight + 1;
+        },
+        {
+          timeout: SETTLE_TIMEOUT,
+          timeoutMsg: 'filter popover was not clamped inside the table scrollport after horizontal scroll',
+        },
+      );
+    });
+
+    it('02: should hide the popover without closing it once its column scrolls out of view', async () => {
+      const geometry = await DSDataTableCO.getColumnScrollGeometry(TARGET_COLUMN);
+      expect(geometry).not.toBe(null);
+
+      // Precondition, asserted rather than assumed: the table must be able to scroll far enough to
+      // push the column past its left edge. If it cannot, clamping to maxScrollLeft would leave the
+      // column visible and the hide assertion below would fail with a misleading message.
+      expect(geometry.maxScrollLeft).toBeGreaterThan(geometry.colRight);
+      await DSDataTableCO.setScrollableContainerScrollLeft(geometry.colRight + 1);
+
+      await browser.waitUntil(
+        async () => {
+          const rects = await DSDataTableCO.getFilterPopoverBoundaryRects();
+          return Boolean(rects) && rects.opacity === '0' && rects.pointerEvents === 'none';
+        },
+        {
+          timeout: SETTLE_TIMEOUT,
+          timeoutMsg: 'filter popover was not hidden after its column scrolled out of view',
+        },
+      );
+
+      // Hidden, not closed: the popover is still mounted, so scrolling back restores it instead of
+      // the user having to reopen the filter. getFilterPopoverBoundaryRects returning a value at all
+      // already proves the node is in the DOM; assert it explicitly so the intent is not implicit.
+      await expect(await FiltersCO.getFilterMenuContent()).toBeExisting();
+
+      await DSDataTableCO.setScrollableContainerScrollLeft(0);
+
+      await browser.waitUntil(
+        async () => {
+          const rects = await DSDataTableCO.getFilterPopoverBoundaryRects();
+          return Boolean(rects) && rects.opacity === '1' && rects.pointerEvents === 'auto';
+        },
+        {
+          timeout: SETTLE_TIMEOUT,
+          timeoutMsg: 'filter popover did not reappear after scrolling its column back into view',
+        },
+      );
+      await expect(await FiltersCO.getFilterMenuContent()).toBeDisplayed();
+    });
+  });
+}

package/ds-data-table-async/filters/DSDataTable.filters-creatable-active-descendant.func.spec.js

@@ -0,0 +1,51 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { FiltersCO } from '../components';
+import { type } from '../../helpers';
+
+// Tests for the fix introduced in PUI-15735. The Name column derives its filter options from the
+// *filtered* data, so a value created in the filter is dropped from the options on the next render;
+// getFirstOption() used to focus it anyway, leaving aria-activedescendant pointing at a dead id.
+const describeActiveDescendant = ({ activeDescendant, optionIds }) => {
+  if (activeDescendant === null) return 'input-missing';
+  if (activeDescendant === '') return 'none';
+  return optionIds.includes(activeDescendant) ? 'rendered-option' : `orphan:${activeDescendant}`;
+};
+
+const VALID_ACTIVE_DESCENDANT = /^(none|rendered-option)$/;
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-18882 - DSDataTable:: creatable filter aria-activedescendant validity - Func', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.filteredCreatable.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: reopening the filter after an Enter-created option keeps the id valid', async () => {
+      await FiltersCO.openFilterPopperByColumnName('name');
+      await type('Juan');
+      await browser.keys(Key.Enter);
+      // Reopening is the regression path for the getFirstOption() half: it runs when the menu
+      // mounts, and by then the created value is gone from the Name column's derived options.
+      await FiltersCO.openFilterPopperByColumnName('name');
+      const state = await DSDataTableCO.getFilterActiveDescendantState();
+      await expect(describeActiveDescendant(state)).toMatch(VALID_ACTIVE_DESCENDANT);
+    });
+    it('02: creating an option by mouse click clears the stale focus target', async () => {
+      // The multi-select creatable column, not the single-select one: selecting in a single-select
+      // filter closes the popper, leaving no input to read, and reopening would let the
+      // getFirstOption() guard mask this half of the fix. Multi-select keeps the menu open, so the
+      // assertion lands on the state handleOnCreateClick's setFocusOptionIdx('') is responsible for.
+      await FiltersCO.openFilterPopperByColumnName('position');
+      await type('Zulu dev');
+      await (await FiltersCO.getFilterMultiSelectMenuItem(0)).click();
+      const state = await DSDataTableCO.getFilterActiveDescendantState();
+      await expect(describeActiveDescendant(state)).toMatch(VALID_ACTIVE_DESCENDANT);
+    });
+  });
+}

package/ds-data-table-async/filters/DSDataTable.filters-creatable.func.spec.js

@@ -4,8 +4,13 @@ import { Key } from 'webdriverio';
 import DSDataTableCO from '../DSDataTableCO';
 import { FilterBarCO, FiltersCO, RowCO } from '../components';
 import { type } from '../../helpers';
+import { getInputSelection } from '../helpers';
 import DSComboboxCO from '../../ds-controlled-form/ds-combobox/DSComboboxCO';
 
+// A value the Name column's data never contains, so only the creatable affordance is listed and
+// the input keeps the full string for the caret/selection assertions.
+const TYPED_FILTER_TEXT = 'aloha';
+
 if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
   describe('PUI-9203 - DataTable, Filter, Creatable single select filter', () => {
     before('loading page', async () => {
@@ -114,4 +119,38 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
       await expect(newOption).toEqual('New option');
     });
   });
+  // Tests for the fix introduced in PUI-15851 (a wrapper-level mousedown preventDefault() in the
+  // combobox's `inline` mode suppressed the browser's native caret placement and word selection,
+  // and a second click on the focused input blurred it, clearing the value and closing the menu).
+  describe('PUI-18881 - DSDataTable:: filter search input mouse caret and selection - Func', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.filteredCreatable.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+      await FiltersCO.openFilterPopperByColumnName('name');
+      await type(TYPED_FILTER_TEXT);
+    });
+    it('01: clicking near the left edge moves the caret off the end of the text', async () => {
+      const input = await FiltersCO.getFilterSingleSelectInput();
+      // WDIO click offsets are relative to the element centre, so walk back to ~2px from the left
+      // edge instead of hardcoding a pixel — stays correct if padding or width changes.
+      const { width } = await input.getSize();
+      await input.click({ x: -Math.floor(width / 2) + 2, y: 0 });
+      const { start } = await getInputSelection(input);
+      await expect(start).toBeLessThan(TYPED_FILTER_TEXT.length);
+    });
+    it('02: double-clicking selects the word under the cursor', async () => {
+      const input = await FiltersCO.getFilterSingleSelectInput();
+      await input.doubleClick();
+      const { start, end } = await getInputSelection(input);
+      await expect(end - start).toBeGreaterThan(0);
+    });
+    it('03: a second click on the focused input keeps the value, focus and open menu', async () => {
+      const input = await FiltersCO.getFilterSingleSelectInput();
+      await input.click();
+      await expect(input).toHaveValue(TYPED_FILTER_TEXT);
+      await expect(input).toBeFocused();
+      await expect(await FiltersCO.getFilterSingleSelectPopper()).toBeDisplayed();
+    });
+  });
 }

package/ds-data-table-async/filters/DSDataTable.filters.axe-core.func.spec.js

@@ -76,22 +76,24 @@ if (
       await expect(result.length).toBe(0);
     });
   });
-  // unskip this test after PUI-15735 is fixed
-  describe.skip('PUI-11443 - DataTable, Creatable single select filter - focus after clear input - AxeCore', () => {
-    before('loading page', async () => {
+  // Tests for the fix introduced in PUI-15735 (aria-activedescendant pointed at an id no longer
+  // present in the rendered options after creating and selecting a filter option, tripping axe's
+  // aria-valid-attr-value). Repaired and unskipped under its own pre-existing ticket, PUI-11443.
+  // Only the Enter path is scanned: both create paths converge on the same DOM, and axe asserts a
+  // DOM state. Per-path precision lives in DSDataTable.filters-creatable-active-descendant.
+  describe('PUI-11443 - DSDataTable:: aria validity when creating a filter option - AxeCore', () => {
+    beforeEach('loading page', async () => {
       const errorOnGo = await DSDataTableCO.filteredCreatable.go();
       if (errorOnGo) throw errorOnGo;
       await DSDataTableCO.waitForDataTable();
-    });
-    it('01: should open the popup and generate a creatable option and pass axe-core scan', async () => {
-      await FiltersCO.openFilterPopperByColumnName('name', 0);
+      await FiltersCO.openFilterPopperByColumnName('name');
       await type('Juan');
+    });
+    it('01: the creatable affordance shown while typing passes an axe-core scan', async () => {
       const result = await axeCoreCheck();
       await expect(result.length).toBe(0);
     });
-    it('02: should open generate and accept creatable option and pass axe-core scan', async () => {
-      await FiltersCO.openFilterPopperByColumnName('name', 0);
-      await type('Juan');
+    it('02: creating and selecting the option with Enter passes an axe-core scan', async () => {
       await browser.keys(Key.Enter);
       const result = await axeCoreCheck();
       await expect(result.length).toBe(0);

package/ds-data-table-async/filtersV2/DSDataTable.filtersV2-creatablemultiselect.keyboard.func.spec.js

@@ -5,7 +5,7 @@ import { FiltersCO } from '../components';
 
 if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
   // Forward keyboard navigation
-  describe('PUI-XXXXX - DataTable:: Filters V2 - Creatable Multi Select, forward keyboard navigation', () => {
+  describe('PUI-18203 - DataTable:: Filters V2 - Creatable Multi Select, forward keyboard navigation', () => {
     before('loading page', async () => {
       const errorOnGo = await DSDataTableCO.creatableMultiSelectFilterV2.go();
       if (errorOnGo) throw errorOnGo;
@@ -38,7 +38,7 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
   });
 
   // Backward keyboard navigation
-  describe('PUI-XXXXX - DataTable:: Filters V2 - Creatable Multi Select, backward keyboard navigation', () => {
+  describe('PUI-18204 - DataTable:: Filters V2 - Creatable Multi Select, backward keyboard navigation', () => {
     before('loading page', async () => {
       const errorOnGo = await DSDataTableCO.creatableMultiSelectFilterV2.go();
       if (errorOnGo) throw errorOnGo;

package/ds-data-table-async/filtersV2/DSDataTable.filtersV2-creatableselect.keyboard.func.spec.js

@@ -5,7 +5,7 @@ import { FiltersCO } from '../components';
 
 if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
   // Forward keyboard navigation
-  describe('PUI-XXXXX - DataTable:: Filters V2 - Creatable Select, forward keyboard navigation', () => {
+  describe('PUI-18201 - DataTable:: Filters V2 - Creatable Select, forward keyboard navigation', () => {
     before('loading page', async () => {
       const errorOnGo = await DSDataTableCO.creatableSelectFilterV2.go();
       if (errorOnGo) throw errorOnGo;
@@ -38,7 +38,7 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
   });
 
   // Backward keyboard navigation
-  describe('PUI-XXXXX - DataTable:: Filters V2 - Creatable Select, backward keyboard navigation', () => {
+  describe('PUI-18202 - DataTable:: Filters V2 - Creatable Select, backward keyboard navigation', () => {
     before('loading page', async () => {
       const errorOnGo = await DSDataTableCO.creatableSelectFilterV2.go();
       if (errorOnGo) throw errorOnGo;

package/ds-data-table-async/filtersV2/DSDataTable.filtersV2.axe-core.func.spec.js

@@ -1,37 +1,53 @@
 import DSDataTableCO from '../DSDataTableCO';
-import { FiltersCO } from '../components';
+import { FilterBarCO, FiltersCO } from '../components';
 import { axeCoreCheck } from '../../helpers';
 
-if (browser.capabilities.browserName === 'chrome') {
-  if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
-    describe('PUI-18108 - DataTable:: Filters V2 - All Filter Types - Axe-Core', () => {
-      before(async () => {
-        const errorOnGo = await DSDataTableCO.allFiltersV2.go();
-        if (errorOnGo) throw errorOnGo;
-        await DSDataTableCO.waitForDataTable();
-      });
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-18108 - DataTable:: Filters V2 - All Filter Types - Axe-Core', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.allFiltersV2.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
 
-      it('01: should have no accessibility violations in default state', async () => {
-        const result = await axeCoreCheck();
-        expect(result.length).toBe(0);
-      });
+    it('01: should have no accessibility violations in default state', async () => {
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
 
-      it('02: should have no accessibility violations with filter popper open', async () => {
-        await FiltersCO.openFilterPopperByColumnName('id');
-        const footer = await FiltersCO.getFilterFooter();
-        await footer.waitForDisplayed();
-        const result = await axeCoreCheck();
-        expect(result.length).toBe(0);
-      });
+    it('02: should have no accessibility violations with filter popper open', async () => {
+      await FiltersCO.openFilterPopperByColumnName('id');
+      const footer = await FiltersCO.getFilterFooter();
+      await footer.waitForDisplayed();
+      // `scrollable-region-focusable` is a documented axe-core false positive for the filter
+      // popper option list: it reuses the DS combobox listbox (TanStack Virtual + container
+      // tabindex=-1 Firefox scroll workaround), leaving a residual scrollHeight. The options are
+      // fully keyboard-operable through the combobox widget model, so WCAG 2.1.1 is satisfied.
+      // Same disposition as the ds-combobox axe specs; dev team confirmed no real a11y issue.
+      const result = await axeCoreCheck({ extraDisabledRules: ['scrollable-region-focusable'] });
+      expect(result.length).toBe(0);
+    });
 
-      it('03: should have no accessibility violations with applied filter and pills', async () => {
-        const menuItem = await FiltersCO.getFilterSingleSelectMenuItem(0);
-        await menuItem.click();
-        const applyBtn = await FiltersCO.getFilterApplyButton();
-        await applyBtn.click();
-        const result = await axeCoreCheck();
-        expect(result.length).toBe(0);
-      });
+    it('03: should have no accessibility violations with applied filter and pills', async () => {
+      // Self-contained: re-open the single-select ('id') popper (openFilterPopperByColumnName
+      // clicks the header cell first, resetting any leftover popper state), pick an option and
+      // apply so a pill renders, then scan.
+      await FiltersCO.openFilterPopperByColumnName('id');
+      const footer = await FiltersCO.getFilterFooter();
+      await footer.waitForDisplayed();
+      const menuItem = await FiltersCO.getFilterSingleSelectMenuItem(0);
+      await menuItem.click();
+      const applyBtn = await FiltersCO.getFilterApplyButton();
+      await applyBtn.click();
+      const pills = await FilterBarCO.getAllPills();
+      await expect(pills.length).toBeGreaterThan(0);
+      const result = await axeCoreCheck({ extraDisabledRules: ['scrollable-region-focusable'] });
+      expect(result.length).toBe(0);
     });
-  }
+  });
 }

package/ds-data-table-async/filtersV2/pill-label/DSDataTable.pillLabel.axe-core.func.spec.js

@@ -0,0 +1,23 @@
+import DSDataTableCO from '../../DSDataTableCO';
+import { axeCoreCheck } from '../../../helpers';
+
+// Tests for column.pillLabel added in PUI-8318 (custom pill labels must not introduce a11y violations)
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-18727 - DSDataTable:: custom filter pill label - Axe-Core', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.pillLabelCustomization.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: should have no accessibility violations with custom and default pill labels', async () => {
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}