dimsum-e2e-tests 1.0.0-rc.1

package/ds-controlled-form/ds-controlled-date-time-picker/date-input/DateInput.keyboard-nav.func.spec.js

@@ -0,0 +1,154 @@
+/* eslint-disable max-lines */
+import { Key } from 'webdriverio';
+import { type } from '../../../helpers';
+import DateTimePickerCO from '../DSControlledDateTimePickerCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-9613 - DSControlledDateTimePicker:: DateInput: keyboard navigation', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.dateShowcase.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should advance using "/"', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-input-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-input-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-input-clearable');
+      const clearBtn = await DateTimePickerCO.getClearBtn('date-input-clearable');
+
+      await month.click();
+      await type('1');
+      await type('/');
+      await type('2');
+      await type('/');
+      await type('0732');
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('0732');
+      await expect(clearBtn).toBeFocused();
+    });
+    it('02: should advance using "-"', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-input-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-input-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-input-clearable');
+      const clearBtn = await DateTimePickerCO.getClearBtn('date-input-clearable');
+
+      await month.click();
+      await type('1');
+      await type('-');
+      await type('2');
+      await type('-');
+      await type('732');
+      await browser.keys(Key.Tab);
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('7320');
+      await expect(clearBtn).toBeFocused();
+    });
+    it('03: should advance using "\\"', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-input-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-input-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-input-clearable');
+      const clearBtn = await DateTimePickerCO.getClearBtn('date-input-clearable');
+
+      await month.click();
+      await type('1');
+      await type('\\');
+      await type('2');
+      await type('\\');
+      await type('0732');
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('0732');
+      await expect(clearBtn).toBeFocused();
+    });
+    it('04: should advance using "Tab"', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-full-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-full-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-full-clearable');
+      const pickerBtn = await DateTimePickerCO.getCalendarPickerBtn('date-full-clearable');
+
+      await month.click();
+      await type('1');
+      await browser.keys(Key.Tab);
+      await type('2');
+      await browser.keys(Key.Tab);
+      await type('0732');
+      await browser.keys(Key.Tab);
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('0732');
+      await expect(pickerBtn).toBeFocused();
+    });
+    it('05: should complete with current date - Ctrl + ;', async () => {
+      const currentDate = new Date();
+      const currentMonth = String(currentDate.getMonth() + 1).padStart(2, '0');
+      const currentDay = String(currentDate.getDate()).padStart(2, '0');
+      const currentYear = String(currentDate.getFullYear());
+      const month = await DateTimePickerCO.getMonthInput('date-full-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-full-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-full-clearable');
+      const pickerBtn = await DateTimePickerCO.getCalendarPickerBtn('date-full-clearable');
+
+      await month.click();
+      await browser.keys([Key.Control, ';']);
+      await expect(month).toHaveValueContaining(currentMonth);
+      await expect(day).toHaveValueContaining(currentDay);
+      await expect(year).toHaveValueContaining(currentYear);
+      await expect(pickerBtn).toBeFocused();
+    });
+    it('06: should clear all using - Ctrl + Backspace', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-full');
+      const day = await DateTimePickerCO.getDayInput('date-full');
+      const year = await DateTimePickerCO.getYearInput('date-full');
+
+      await month.click();
+      await type('01020732');
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('0732');
+      await browser.keys([Key.Control, Key.Backspace]);
+      await expect(month).toHaveValueContaining('');
+      await expect(day).toHaveValueContaining('');
+      await expect(year).toHaveValueContaining('');
+      await expect(month).toBeFocused();
+    });
+    it('07: should clear all using "X" button', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-full-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-full-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-full-clearable');
+
+      await month.click();
+      await type('01020732');
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('0732');
+      await browser.keys(Key.Return);
+      await expect(month).toHaveValueContaining('');
+      await expect(day).toHaveValueContaining('');
+      await expect(year).toHaveValueContaining('');
+      await expect(month).toBeFocused();
+    });
+  });
+  describe('PUI-9614 - DSControlledDateTimePicker:: DateInput: keyboard nav - Regressive Backspace', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.dateShowcase.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should clear using Backspace - date-full-clearable', async () => {
+      const month = await DateTimePickerCO.getMonthInput('date-full-clearable');
+      const day = await DateTimePickerCO.getDayInput('date-full-clearable');
+      const year = await DateTimePickerCO.getYearInput('date-full-clearable');
+
+      await month.click();
+      await type('01020732');
+      await expect(month).toHaveValueContaining('01');
+      await expect(day).toHaveValueContaining('02');
+      await expect(year).toHaveValueContaining('0732');
+      await DateTimePickerCO.pressBackspace(8);
+      await expect(month).toHaveValueContaining('');
+      await expect(day).toHaveValueContaining('');
+      await expect(year).toHaveValueContaining('');
+      await expect(month).toBeFocused();
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-date-time-picker/date-time-picker/DateTimePicker.custom.attributes.spec.js

@@ -0,0 +1,94 @@
+/* eslint-disable max-statements */
+/* eslint-disable max-lines */
+import DateTimePickerCO from '../DSControlledDateTimePickerCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-10026 - DSControlledDateTimePicker:: Custom aria and data attributes', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.customAriaAndDataAttributes.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should have all aria and data custom attributes - Date inputs', async () => {
+      const monthInput = await DateTimePickerCO.getMonthInput();
+      const dayInput = await DateTimePickerCO.getDayInput();
+      const yearInput = await DateTimePickerCO.getYearInput();
+      await expect(monthInput).toHaveAttribute('data-foo', 'foo-month-input');
+      await expect(monthInput).toHaveAttribute('aria-label', 'custom label for month-input');
+      await expect(dayInput).toHaveAttribute('data-foo', 'foo-day-input');
+      await expect(dayInput).toHaveAttribute('aria-label', 'custom label for day-input');
+      await expect(yearInput).toHaveAttribute('data-foo', 'foo-year-input');
+      await expect(yearInput).toHaveAttribute('aria-label', 'custom label for year-input');
+    });
+    it('02: should have all aria and data custom attributes - Time inputs', async () => {
+      const hourInput = await DateTimePickerCO.getHourInput();
+      const minuteInput = await DateTimePickerCO.getMinutesInput();
+      const meridiemInput = await DateTimePickerCO.getMeridiemInput();
+      await expect(hourInput).toHaveAttribute('data-foo', 'foo-hour-input');
+      await expect(hourInput).toHaveAttribute('aria-label', 'custom label for hour-input');
+      await expect(minuteInput).toHaveAttribute('data-foo', 'foo-minute-input');
+      await expect(minuteInput).toHaveAttribute('aria-label', 'custom label for minute-input');
+      await expect(meridiemInput).toHaveAttribute('data-foo', 'foo-meridiem-input');
+      await expect(meridiemInput).toHaveAttribute('aria-label', 'custom label for meridiem-input');
+    });
+    it('03: should have all aria and data custom attributes - Container and buttons', async () => {
+      const container = await DateTimePickerCO.getContainer();
+      const calendarBtn = await DateTimePickerCO.getCalendarTimeWheelPickerBtn();
+      await expect(container).toHaveAttribute('data-foo', 'foo-picker-container');
+      await expect(container).toHaveAttribute('aria-label', 'custom label for picker-container');
+      await expect(calendarBtn).toHaveAttribute('data-foo', 'foo-calendar-timewheel-icon');
+      await expect(calendarBtn).toHaveAttribute('aria-label', 'custom label for calendar-timewheel-icon');
+    });
+    it('04: should have all aria and data custom attributes - Calendar Header', async () => {
+      const calendarBtn = await DateTimePickerCO.getCalendarTimeWheelPickerBtn();
+      await calendarBtn.click();
+      const calendarHeaderLabel = await DateTimePickerCO.getCalendarHeaderLabel();
+      const calendarPrevYear = await DateTimePickerCO.getCalendarPrevYearBtn();
+      const calendarPrevMonth = await DateTimePickerCO.getCalendarPrevMonthBtn();
+      const calendarNextYear = await DateTimePickerCO.getCalendarNextYearBtn();
+      const calendarNextMonth = await DateTimePickerCO.getCalendarNextMonthBtn();
+      await expect(calendarHeaderLabel).toHaveAttribute('data-foo', 'foo-calendar-header-label');
+      await expect(calendarHeaderLabel).toHaveAttribute('aria-label', 'custom label for calendar-header-label');
+      await expect(calendarPrevYear).toHaveAttribute('data-foo', 'foo-calendar-prev-year');
+      await expect(calendarPrevYear).toHaveAttribute('aria-label', 'custom label for calendar-prev-year');
+      await expect(calendarPrevMonth).toHaveAttribute('data-foo', 'foo-calendar-prev-month');
+      await expect(calendarPrevMonth).toHaveAttribute('aria-label', 'custom label for calendar-prev-month');
+      await expect(calendarNextYear).toHaveAttribute('data-foo', 'foo-calendar-next-year');
+      await expect(calendarNextYear).toHaveAttribute('aria-label', 'custom label for calendar-next-year');
+      await expect(calendarNextMonth).toHaveAttribute('data-foo', 'foo-calendar-next-month');
+      await expect(calendarNextMonth).toHaveAttribute('aria-label', 'custom label for calendar-next-month');
+    });
+    it('05: should have all aria and data custom attributes - Time Wheel', async () => {
+      const timeWheelHeaderLabel = await DateTimePickerCO.getTimeWheelHeaderLabel();
+      const timeWheelHour = await DateTimePickerCO.getTimeWheelHour();
+      const timeWheelPrevHour = await DateTimePickerCO.getTimeWheelPrevHour();
+      const timeWheelNextHour = await DateTimePickerCO.getTimeWheelNextHour();
+      const timeWheelMinute = await DateTimePickerCO.getTimeWheelMinute('01');
+      const timeWheelPrevMinute = await DateTimePickerCO.getTimeWheelPrevMinute();
+      const timeWheelNextMinute = await DateTimePickerCO.getTimeWheelNextMinute();
+      const timeWheelMeridiem = await DateTimePickerCO.getTimeWheelMeridiem();
+      const timeWheelPrevMeridiem = await DateTimePickerCO.getTimeWheelPrevMeridiem();
+      const timeWheelNextMeridiem = await DateTimePickerCO.getTimeWheelNextMeridiem();
+
+      await expect(timeWheelHeaderLabel).toHaveAttribute('data-foo', 'foo-timewheel-header-label');
+      await expect(timeWheelHeaderLabel).toHaveAttribute('aria-label', 'custom label for timewheel-header-label');
+      await expect(timeWheelHour).toHaveAttribute('data-foo', 'foo-timewheel-hour');
+      await expect(timeWheelHour).toHaveAttribute('aria-label', 'custom label for timewheel-hour');
+      await expect(timeWheelPrevHour).toHaveAttribute('data-foo', 'foo-timewheel-prev-hour');
+      await expect(timeWheelPrevHour).toHaveAttribute('aria-label', 'custom label for timewheel-prev-hour');
+      await expect(timeWheelNextHour).toHaveAttribute('data-foo', 'foo-timewheel-next-hour');
+      await expect(timeWheelNextHour).toHaveAttribute('aria-label', 'custom label for timewheel-next-hour');
+      await expect(timeWheelMinute).toHaveAttribute('data-foo', 'foo-timewheel-minute');
+      await expect(timeWheelMinute).toHaveAttribute('aria-label', 'custom label for timewheel-minute');
+      await expect(timeWheelPrevMinute).toHaveAttribute('data-foo', 'foo-timewheel-prev-minute');
+      await expect(timeWheelPrevMinute).toHaveAttribute('aria-label', 'custom label for timewheel-prev-minute');
+      await expect(timeWheelNextMinute).toHaveAttribute('data-foo', 'foo-timewheel-next-minute');
+      await expect(timeWheelNextMinute).toHaveAttribute('aria-label', 'custom label for timewheel-next-minute');
+      await expect(timeWheelMeridiem).toHaveAttribute('data-foo', 'foo-timewheel-meridiem');
+      await expect(timeWheelMeridiem).toHaveAttribute('aria-label', 'custom label for timewheel-meridiem');
+      await expect(timeWheelPrevMeridiem).toHaveAttribute('data-foo', 'foo-timewheel-prev-meridiem');
+      await expect(timeWheelPrevMeridiem).toHaveAttribute('aria-label', 'custom label for timewheel-prev-meridiem');
+      await expect(timeWheelNextMeridiem).toHaveAttribute('data-foo', 'foo-timewheel-next-meridiem');
+      await expect(timeWheelNextMeridiem).toHaveAttribute('aria-label', 'custom label for timewheel-next-meridiem');
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-date-time-picker/date-time-picker/DateTimePicker.func.spec.js

@@ -0,0 +1,87 @@
+/* eslint-disable max-lines */
+import { Key } from 'webdriverio';
+import DateTimePickerCO from '../DSControlledDateTimePickerCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8225 - DSControlledDateTimePicker:: DateTimePicker manage focus on open', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.fullFeatures.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open datetimepicker and manage focus to be at december 27 2000', async () => {
+      const openPickerBtn = await DateTimePickerCO.getCalendarTimeWheelPickerBtn();
+      await openPickerBtn.click();
+      // eslint-disable-next-line wdio/no-pause
+      await browser.pause(500);
+      await browser.keys(Key.Space);
+      const day = await DateTimePickerCO.getCalendarTimeWheelPickerBtn();
+      const dayText = await day.getAttribute('aria-label');
+      await expect(dayText).toBe(
+        // eslint-disable-next-line max-len
+        'date time picker context menu trigger, current values: December, twentie seventh, 2000, empty hours, empty minutes, empty meriediem',
+      );
+    });
+  });
+
+  describe('PUI-8286 - DSControlledDateTimePicker:: DateTimePicker: Populate input when picking', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.fullFeatures.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should change the text input to the picked date', async () => {
+      const openPickerBtn = await DateTimePickerCO.getCalendarTimeWheelPickerBtn();
+      await openPickerBtn.click();
+      const exampleDate = await DateTimePickerCO.getCalendarDay(8);
+      await exampleDate.click();
+      const month = await DateTimePickerCO.getMonthInput();
+      const day = await DateTimePickerCO.getDayInput();
+      const year = await DateTimePickerCO.getYearInput();
+      await expect(month).toHaveValueContaining('12');
+      await expect(day).toHaveValueContaining('08');
+      await expect(year).toHaveValueContaining('2000');
+    });
+    it('02: should change the text input minutes section to the picked minutes', async () => {
+      const exampleMinutes = await DateTimePickerCO.getTimeWheelMinute(31);
+      await exampleMinutes.click();
+      const minutes = await DateTimePickerCO.getMinutesInput();
+      await expect(minutes).toHaveValueContaining('31');
+    });
+  });
+
+  describe('PUI-8132 - DSControlledDateTimePicker:: DateTimePicker: - Fixed on open values', () => {
+    before(async () => {
+      const errorOnGo = await DateTimePickerCO.fullFeatures.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open day time picker and have the date setted 27 12 2000', async () => {
+      const openPickerBtn = await DateTimePickerCO.getCalendarTimeWheelPickerBtn();
+      await openPickerBtn.click();
+      const hours = await DateTimePickerCO.getTimeWheelCurrentHour();
+      const minutes = await DateTimePickerCO.getTimeWheelCurrentMinute();
+      const currentHours = await hours.getAttribute('aria-label');
+      const currentMinutes = await minutes.getAttribute('aria-label');
+      await expect(currentHours).toBe('10 hours');
+      await expect(currentMinutes).toBe('30 minutes');
+    });
+  });
+
+  describe('PUI-11237 - DSControlledDateTimePicker:: NOT scroll to top on trigger -Visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DateTimePickerCO.scrollTest.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display page scrolled to the bottom, datepicker closed', async () => {
+      const dateTrigger = await DateTimePickerCO.getTrigger();
+      await dateTrigger.scrollIntoView();
+      const firstInput = await $('[id="testid"]');
+      await expect(firstInput).not.toBeDisplayedInViewport();
+    });
+    it('02: should display page scrolled to the bottom, datepicker open', async () => {
+      const dateTrigger = await DateTimePickerCO.getTrigger();
+      await dateTrigger.click();
+      const firstInput = await $('[id="testid"]');
+      await expect(dateTrigger).toBeDisplayedInViewport();
+      await expect(firstInput).not.toBeDisplayedInViewport();
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-inputgroup/DSControlledInputGroupCO.js

@@ -0,0 +1,74 @@
+import { PATH_E2E_CONTROLLED_FORM_INPUT_GROUP } from '../../../environments/storybook/paths';
+import { PageObject, Urlbuilder, getElementByIndex } from '../../helpers';
+
+export default class DSControlledInputGroupCO extends PageObject {
+  static basicURL = new Urlbuilder(PATH_E2E_CONTROLLED_FORM_INPUT_GROUP, 'basic');
+
+  static protectedURL = new Urlbuilder(PATH_E2E_CONTROLLED_FORM_INPUT_GROUP, 'protected-input');
+
+  static autocompleteURL = new Urlbuilder(PATH_E2E_CONTROLLED_FORM_INPUT_GROUP, 'with-auto-complete');
+
+  static comboboxURL = new Urlbuilder(PATH_E2E_CONTROLLED_FORM_INPUT_GROUP, 'with-combobox');
+
+  static formitemURL = new Urlbuilder(PATH_E2E_CONTROLLED_FORM_INPUT_GROUP, 'with-form-item-layout');
+
+  static async getButton() {
+    return $('[data-testid="ds-button"]');
+  }
+
+  static async getButtons() {
+    return $$('[data-testid="ds-button"]');
+  }
+
+  static getButtonByIndex = async (index) => getElementByIndex(this.getButtons, index);
+
+  static async getInput() {
+    return $('[data-testid="ds-input-text-input"]');
+  }
+
+  static async getInputValue(value) {
+    return $(`[data-testid="ds-input-text-input"][value="${value}"]`);
+  }
+
+  static async getInputs() {
+    return $$('[data-testid="ds-input-text-input"]');
+  }
+
+  static getInputByIndex = async (index) => getElementByIndex(this.getInputs, index);
+
+  static getRightAddons() {
+    return $$('[data-testid="ds-button-right-addon"]');
+  }
+
+  static getRightAddOnByIndex = async (index) => getElementByIndex(this.getRightAddons, index);
+
+  static getLeftAddons() {
+    return $$('[data-testid="ds-button-left-addon"]');
+  }
+
+  static getLeftAddOnByIndex = async (index) => getElementByIndex(this.getLeftAddons, index);
+
+  static getAutocompleteMenuList() {
+    return $('[data-testid="autocomplete-menu-list"]');
+  }
+
+  static getMenuList() {
+    return $('[data-testid="combobox-menu-list"]');
+  }
+
+  static async getPillByLabel(label) {
+    return $(`[data-testid="ds-pill-wrapper"][data-label="${label}"]`);
+  }
+
+  static async getComboboxInput() {
+    return $('[data-testid="combobox-input"]');
+  }
+
+  static async getOptionByIndex(index) {
+    return $$('[data-testid="combobox-option"]')[index];
+  }
+
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('DSControlledInputGroup', example, 'ds-controlled-inputgroup');
+  }
+}

package/ds-controlled-form/ds-controlled-inputgroup/autocomplete/DSControlledInputGroup.autocomplete.axe-core.func.spec.js

@@ -0,0 +1,51 @@
+/* eslint-disable max-len */
+import { Key } from 'webdriverio';
+import DSControlledInputGroupCO from '../DSControlledInputGroupCO';
+import { axeCoreCheck, type } from '../../../helpers';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'Chrome') ||
+  browser.capabilities.browserName === 'chrome'
+) {
+  describe('PUI-10763 - InputGroup:: Autocomplete: Axe-Core Accessibility Test', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DSControlledInputGroupCO.autocompleteURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axe-core scan without violations', async () => {
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      await input.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should pass axe-core scan without violations after type', async () => {
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      await input.waitForDisplayed();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await type('a');
+      const menuList = await DSControlledInputGroupCO.getAutocompleteMenuList();
+      await menuList.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('03: should pass axe-core scan without violations after select an option', async () => {
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      await input.waitForDisplayed();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await type('a');
+      const menuList = await DSControlledInputGroupCO.getAutocompleteMenuList();
+      await menuList.waitForDisplayed();
+      await browser.keys(Key.Enter);
+      const inputValue = await DSControlledInputGroupCO.getInputValue(
+        'Luke Skywalker too long this text is super long',
+      );
+      await inputValue.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-inputgroup/basic/DSControlledInputGroup.basic.axe-core.func.spec.js

@@ -0,0 +1,29 @@
+/* eslint-disable max-len */
+import DSControlledInputGroupCO from '../DSControlledInputGroupCO';
+import { axeCoreCheck } from '../../../helpers';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'Chrome') ||
+  browser.capabilities.browserName === 'chrome'
+) {
+  describe('PUI-10762 - InputGroup:: Basic: Axe-Core Accessibility Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledInputGroupCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axe-core scan without violations', async () => {
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      await input.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should pass axe-core scan without violations after type', async () => {
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      await input.setValue('Test');
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-inputgroup/basic/DSControlledInputGroup.basic.visual.spec.js

@@ -0,0 +1,33 @@
+import DSControlledInputGroupCO from '../DSControlledInputGroupCO';
+import { mouseOver } from '../../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8334 - DSControlledInputGroupCO - Basic Layout - Visual Test ', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledInputGroupCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display the basic group inputs correctly - hover addon', async () => {
+      await browser.eyesOpen();
+      const input = await DSControlledInputGroupCO.getInputByIndex(1);
+      const addon = await DSControlledInputGroupCO.getButtonByIndex(2);
+      await input.click();
+      await mouseOver(addon);
+      const snapshot = await browser.eyesCheckSnapshot(
+        DSControlledInputGroupCO.snapshotPath('controlled-input-hover-addon'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display the basic group inputs correctly - hover input', async () => {
+      await browser.eyesOpen();
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      const addon = await DSControlledInputGroupCO.getButtonByIndex(1);
+      await addon.click();
+      await mouseOver(input);
+      const snapshot = await browser.eyesCheckSnapshot(
+        DSControlledInputGroupCO.snapshotPath('controlled-input-hover-input'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-inputgroup/combobox/DSControlledInputGroup.combobox.axe-core.func.spec.js

@@ -0,0 +1,51 @@
+/* eslint-disable max-len */
+import { Key } from 'webdriverio';
+import DSControlledInputGroupCO from '../DSControlledInputGroupCO';
+import { axeCoreCheck, type } from '../../../helpers';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'Chrome') ||
+  browser.capabilities.browserName === 'chrome'
+) {
+  describe('PUI-10766 - InputGroup:: Combobox: Axe-Core Accessibility Test', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DSControlledInputGroupCO.comboboxURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axe-core scan without violations', async () => {
+      const input = await DSControlledInputGroupCO.getComboboxInput();
+      await input.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it.skip('02: should pass axe-core scan without violations after type', async () => {
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await type('a');
+      const menuList = await DSControlledInputGroupCO.getMenuList();
+      await menuList.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    // Defect PUI-10783
+    it.skip('03: should pass axe-core scan without violations after select an option', async () => {
+      const input = await DSControlledInputGroupCO.getComboboxInput();
+      await input.waitForDisplayed();
+      await input.click();
+      const menuList = await DSControlledInputGroupCO.getMenuList();
+      await menuList.waitForDisplayed();
+      const firstOption = await DSControlledInputGroupCO.getOptionByIndex(0);
+      await firstOption.click();
+      const selectedOption = await DSControlledInputGroupCO.getPillByLabel(
+        'Luke Skywalker too long this text is super long',
+      );
+      await selectedOption.waitForDisplayed();
+      const innerHTML = await input.getHTML();
+      await console.log('03 #### INPUT #####: ', innerHTML);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-inputgroup/form-item-layout/DSControlledInputGroup.form-item-layout.axe-core.func.spec.js

@@ -0,0 +1,23 @@
+/* eslint-disable max-len */
+import DSControlledInputGroupCO from '../DSControlledInputGroupCO';
+import { axeCoreCheck } from '../../../helpers';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'Chrome') ||
+  browser.capabilities.browserName === 'chrome'
+) {
+  describe('PUI-10765 - InputGroup:: Form Item Layout: Axe-Core Accessibility Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledInputGroupCO.formitemURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axe-core scan without violations', async () => {
+      const input = await DSControlledInputGroupCO.getInputByIndex(0);
+      await input.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-inputgroup/form-item-layout/DSControlledInputGroup.form-item-layout.func.spec.js

@@ -0,0 +1,20 @@
+import DSControlledInputGroupCO from '../DSControlledInputGroupCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8336 - DSControlledInputGroupCO - Disable input addon -func ', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledInputGroupCO.formitemURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display the input default', async () => {
+      const input = await DSControlledInputGroupCO.getInput();
+      await expect(input).toBeClickable();
+    });
+    it('should display the input disabled after clicking the disable addon', async () => {
+      const disableAddon = await DSControlledInputGroupCO.getLeftAddOnByIndex(0);
+      await disableAddon.click();
+      const input = await DSControlledInputGroupCO.getInput();
+      await expect(input).toBeDisabled();
+    });
+  });
+}