dimsum-e2e-tests 3.22.0-next.36

package/ds-apppicker/DSAppPickerCO.js

@@ -0,0 +1,51 @@
+/* eslint-disable import/no-relative-packages */
+import { PATH_E2E_APP_PICKER } from '../../environments/storybook/paths';
+import { PageObject, Urlbuilder, getElementByIndex } from '../helpers';
+
+export default class DSAppPickerCO extends PageObject {
+  // Desktop
+  static basicURL = new Urlbuilder(`${PATH_E2E_APP_PICKER}`, 'basic-test');
+
+  static closeAfterURL = new Urlbuilder(`${PATH_E2E_APP_PICKER}`, 'close-after-selection-test');
+
+  static maxHeightURL = new Urlbuilder(`${PATH_E2E_APP_PICKER}`, 'max-height-test');
+
+  static minHeightURL = new Urlbuilder(`${PATH_E2E_APP_PICKER}`, 'min-height-test');
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('AppPicker', example);
+  }
+
+  // selectors
+  static async getOpenAppPicker() {
+    return $(`#app-picker__button`);
+  }
+
+  static getChips = async () => $$('[data-testid="app-picker__chip"]');
+
+  static getChipByIndex = async (index) => getElementByIndex(this.getChips, index);
+
+  static getTruncTexts = async () => $$('[data-testid="DS-SimpleTruncateText"]');
+
+  static getTruncTextByIndex = async (index) => getElementByIndex(this.getTruncTexts, index);
+
+  static getChipByLabel = async (label) =>
+    $(`//button[@data-testid="app-picker__chip"]/div/span[contains(text(),"${label}")]//ancestor::button`);
+
+  static async getAppPickerGrid() {
+    return $('[data-testid="app-picker__main-grid"]');
+  }
+
+  static async getAppPickerWrapper() {
+    return $('[data-testid="app-picker__wrapper"]');
+  }
+
+  static async getChipLabelByIndex(index) {
+    return $$('[data-testid="ds-chip-label"]')[index];
+  }
+
+  static async isSelected(element) {
+    return (await element.getAttribute('aria-selected')).includes('true');
+  }
+}

package/ds-apppicker/basic/DSAppPicker.basic.axe-core.spec.js

@@ -0,0 +1,38 @@
+import { Key } from 'webdriverio';
+import DSAppPickerCO from '../DSAppPickerCO';
+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-10996 - AppPicker:: basic -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should have closed appPicker and pass axecore scan ', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should have open appPicker (with disabled chip also) and pass axecore scan', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await appPicker.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('03: should focus a truncated item and pass axecore scan', async () => {
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await appPicker.waitForDisplayed();
+      await browser.keys(Key.Tab);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-apppicker/basic/DSAppPicker.basic.func.spec.js

@@ -0,0 +1,43 @@
+import DSAppPickerCO from '../DSAppPickerCO';
+
+if (
+  !browser.capabilities['ice:options'].isPhone &&
+  !browser.capabilities['ice:options'].isTablet &&
+  browser.capabilities.browserName !== 'Safari'
+) {
+  describe('PUI-7775 - AppPicker:: basic - func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open appPicker', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await expect(appPicker).toBeDisplayedInViewport();
+    });
+    it('02: should focus the fifth element when clicking it', async () => {
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(4);
+      await appPickerChip.click();
+      await expect(appPickerChip).toBeFocused();
+    });
+    it('03: should close appPicker clicking outside the menu', async () => {
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      // clicking outside the menu
+      await openAppPickerBtn.click({ x: 100 });
+      await expect(appPicker).not.toBeDisplayedInViewport();
+    });
+    it('04: should reopen appPicker', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await expect(appPicker).toBeDisplayedInViewport();
+    });
+    it('05: should focus the sixth element when clicking it', async () => {
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(5);
+      await appPickerChip.click();
+      await expect(appPickerChip).toBeFocused();
+    });
+  });
+}

package/ds-apppicker/basic/DSAppPicker.basic.keyboard-nav.func.spec.js

@@ -0,0 +1,50 @@
+import { Key } from 'webdriverio';
+import DSAppPickerCO from '../DSAppPickerCO';
+
+if (
+  !browser.capabilities['ice:options'].isPhone &&
+  !browser.capabilities['ice:options'].isTablet &&
+  browser.capabilities.browserName !== 'Safari'
+) {
+  describe('PUI-8030 - AppPicker:: Basic - keyboard nav func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open meny and focus the first enabled chip - Enter', async () => {
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Enter);
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(1);
+      await expect(appPicker).toBeDisplayedInViewport();
+      await expect(appPickerChip).toBeFocused();
+    });
+    it('02: should navigate to the last enabled chip - Shift+Tab', async () => {
+      await browser.keys([Key.Shift, Key.Tab]);
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(10);
+      await expect(appPickerChip).toBeFocused();
+    });
+    it('03: should ignore the disabled chip - Tab', async () => {
+      await browser.keys(Key.Tab);
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(1);
+      await expect(appPickerChip).toBeFocused();
+    });
+    it('04: should select an app - Enter', async () => {
+      await browser.keys(Key.Enter);
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(1);
+      await expect(appPickerChip).toBeFocused();
+    });
+    it('05: should close the menu - Escape', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await browser.keys(Key.Escape);
+      await expect(openAppPickerBtn).toBeFocused();
+    });
+    it('06: should reopen the menu and focus the first enabled chip - Space', async () => {
+      await browser.keys(Key.Space);
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      const appPickerChip = await DSAppPickerCO.getChipByIndex(1);
+      await expect(appPicker).toBeDisplayedInViewport();
+      await expect(appPickerChip).toBeFocused();
+    });
+  });
+}

package/ds-apppicker/basic/DSAppPicker.basic.visual.spec.js

@@ -0,0 +1,32 @@
+/* eslint-disable wdio/no-pause */
+import DSAppPickerCO from '../DSAppPickerCO';
+import { mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-7777 - AppPicker:: interaction states -visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+    });
+    it('01: should have the appPicker closed', async () => {
+      await (await DSAppPickerCO.getOpenAppPicker()).waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-closed'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('02: should open appPicker', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-open'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('03: should interact appPicker chips', async () => {
+      const thirdChip = await DSAppPickerCO.getChipByIndex(2);
+      await thirdChip.click();
+      const sixthChipLabel = await DSAppPickerCO.getChipLabelByIndex(5);
+      await mouseOver(sixthChipLabel);
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-interacted'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-apppicker/closeAfterSelection/DSAppPicker.closeAfterSelection.axe-core.spec.js

@@ -0,0 +1,32 @@
+import DSAppPickerCO from '../DSAppPickerCO';
+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-10997 - AppPicker:: close after selection / controlled -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.closeAfterURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open appPicker close-after-selection and pass axecore scan', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await appPicker.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should close appPicker when selecting a item and pass axe-core scan', async () => {
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await appPicker.waitForDisplayed();
+      const reportChip = await DSAppPickerCO.getChipByIndex(6);
+      await reportChip.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-apppicker/closeAfterSelection/DSAppPicker.closeAfterSelection.func.spec.js

@@ -0,0 +1,31 @@
+import DSAppPickerCO from '../DSAppPickerCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-7776 - AppPicker:: close after selection -func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.closeAfterURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open appPicker', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      await expect(appPicker).toBeDisplayedInViewport();
+    });
+    it('02: should close appPicker when selecting a item and trigger button should be focused', async () => {
+      const appPicker = await DSAppPickerCO.getAppPickerWrapper();
+      const reportChip = await DSAppPickerCO.getChipByIndex(6);
+      await reportChip.click();
+      const triggerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await expect(appPicker).not.toBeDisplayedInViewport();
+      await expect(triggerBtn).toBeFocused();
+    });
+    it('03: should open appPicker and have the third chip still focused', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const reportChip = await DSAppPickerCO.getChipByIndex(6);
+      const reportChipIsSelected = await DSAppPickerCO.isSelected(reportChip);
+      await expect(reportChipIsSelected).toBe(true);
+    });
+  });
+}

package/ds-apppicker/maxHeight/DSAppPicker.max-height.visual.spec.js

@@ -0,0 +1,60 @@
+/* eslint-disable wdio/no-pause */
+import { Key } from 'webdriverio';
+import DSAppPickerCO from '../DSAppPickerCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-11316 - AppPicker:: maxHeight -visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.maxHeightURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+    });
+    it('01: should display the appPicker opened', async () => {
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Enter);
+      const appPickerWrapper = await DSAppPickerCO.getAppPickerWrapper();
+      await appPickerWrapper.waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-maxHeigth-opened'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('02: should display last chip - scroll Down (ArrowDown)', async () => {
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      const lastChip = await DSAppPickerCO.getChipByIndex(21);
+      await lastChip.waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-scroll-down'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('03: should display first chip - scroll Up (ArrowUp)', async () => {
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      const firstChip = await DSAppPickerCO.getChipByIndex(21);
+      await firstChip.waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-scroll-up'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('04: should select last chip', async () => {
+      await browser.keys([Key.Shift, Key.Tab]);
+      await browser.keys(Key.Enter);
+      await browser.keys(Key.Enter);
+      const appPickerWrapper = await DSAppPickerCO.getAppPickerWrapper();
+      await appPickerWrapper.waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-last-chip-selected'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-apppicker/minHeight/DSAppPicker.minHeight.visual.spec.js

@@ -0,0 +1,28 @@
+/* eslint-disable wdio/no-pause */
+import DSAppPickerCO from '../DSAppPickerCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-11300 - AppPicker:: min height -visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.minHeightURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+    });
+    it('01: should display appPicker with minHeight opened', async () => {
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const appPickerWrapper = await DSAppPickerCO.getAppPickerWrapper();
+      await appPickerWrapper.waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-minHeight-opened'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('02: should display an app selected', async () => {
+      const secondChip = await DSAppPickerCO.getChipByIndex(1);
+      await secondChip.click();
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const snapshot = await browser.checkSnapshot(DSAppPickerCO.snapshotPath('appPicker-minHeight-app-selected'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-apppicker/truncation/DSAppPicker.truncation.visual.spec.js

@@ -0,0 +1,46 @@
+/* eslint-disable wdio/no-pause */
+import { Key } from 'webdriverio';
+import DSAppPickerCO from '../DSAppPickerCO';
+import { mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8031 - AppPicker:: truncation rule -visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAppPickerCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+      await browser.maximizeWindow();
+    });
+    it('01: should show the full label on hover', async () => {
+      // applitools is losing the hover when taking the snapshot
+      await browser.eyesOpen();
+      await (await DSAppPickerCO.getOpenAppPicker()).waitForDisplayed();
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      const secondChip = await DSAppPickerCO.getChipByLabel('Pipeline but with a really long label that will truncate');
+      await mouseOver(secondChip);
+      await browser.pause(500);
+      const snapshot = await browser.eyesCheckSnapshot(DSAppPickerCO.snapshotPath('appPicker-truncation-hover'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('02: should show the full label on hover - disabled Chip', async () => {
+      await browser.eyesOpen();
+      const DisabledChip = await DSAppPickerCO.getChipByLabel(
+        'Dashboard but with a really long label that will truncate',
+      );
+      await mouseOver(DisabledChip);
+      await browser.pause(500);
+      const snapshot = await browser.eyesCheckSnapshot(DSAppPickerCO.snapshotPath('appPicker-truncation-disabled'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('03: should show the full label on focus', async () => {
+      await browser.eyesOpen();
+      const openAppPickerBtn = await DSAppPickerCO.getOpenAppPicker();
+      await openAppPickerBtn.click();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Enter);
+      await browser.pause(500);
+      const snapshot = await browser.eyesCheckSnapshot(DSAppPickerCO.snapshotPath('appPicker-truncation-focus'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-autocomplete/DSAutocomplete.axe-core.func.spec.js

@@ -0,0 +1,45 @@
+import { Key } from 'webdriverio';
+import { axeCoreCheck, type } from '../helpers';
+import DSAutocompleteCO from './DSAutocompleteCO';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-10296 - [Autocomplete] Accessibility Test using Axe-core Validation', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAutocompleteCO.basic.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: Evaluate menu list accessibility with axe-core when opened', async () => {
+      await browser.keys(Key.Tab);
+      await type('4');
+      const menulist = await DSAutocompleteCO.getAutocompleteMenuList();
+      await menulist.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: Evaluate accessibility when focusing on the second option in the menu list with axe-core', async () => {
+      await browser.keys(Key.ArrowDown);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('03: Evaluate accessibility when selecting the second option in the menu list with axe-core', async () => {
+      await browser.keys(Key.Enter);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('04: Evaluate accessibility when focusing on the clear button with axe-core', async () => {
+      await browser.keys(Key.Tab);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('05: Evaluate accessibility when clearing the input with axe-core', async () => {
+      await browser.keys(Key.Enter);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-autocomplete/DSAutocomplete.func.spec.js

@@ -0,0 +1,63 @@
+import { Key } from 'webdriverio';
+import DSAutocompleteCO from './DSAutocompleteCO';
+import { type } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-10008 - Autocomplete:: Async suggestions', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSAutocompleteCO.asyncSuggestionsAutocomplete.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should not display suggestions after 2 seconds', async () => {
+      await browser.keys(Key.Tab);
+      await type('Lu');
+      const menulist = await DSAutocompleteCO.getAutocompleteMenuList();
+      await menulist.waitForDisplayed({ timeout: 2000, reverse: true });
+      // after 2 sec
+      await expect(menulist).not.toBeDisplayedInViewport();
+    });
+    it('02: should not display suggestions after 2 seconds', async () => {
+      await type('k');
+      const menulist = await DSAutocompleteCO.getAutocompleteMenuList();
+      await menulist.waitForDisplayed({ timeout: 2000, reverse: true });
+      // after 2 sec
+      await menulist.waitForDisplayed();
+      const options = await DSAutocompleteCO.getAutocompleteOptions();
+      const suggestedOption = await DSAutocompleteCO.getAutocompleteOptionLabel();
+      await expect(menulist).toBeDisplayedInViewport();
+      await expect(options).toHaveLength(1);
+      await expect(suggestedOption).toHaveTextContaining('Luke Skywalker too long this text is super long');
+    });
+    it('03: should complete input correctly', async () => {
+      const input = await DSAutocompleteCO.getAutocompleteInput();
+      const suggestedOption = await DSAutocompleteCO.getAutocompleteOptionLabel();
+      await suggestedOption.click();
+      await expect(input).toHaveValueContaining('Luke Skywalker too long this text is super long');
+    });
+    it('04: should clear input correctly', async () => {
+      const input = await DSAutocompleteCO.getAutocompleteInput();
+      const clearBtn = await DSAutocompleteCO.getClearBtn();
+      await clearBtn.click();
+      await expect(input).toHaveValueContaining('');
+    });
+    it('05: should suggest another option correctly', async () => {
+      const input = await DSAutocompleteCO.getAutocompleteInput();
+      await input.click();
+      await type('Obi');
+      const menulist = await DSAutocompleteCO.getAutocompleteMenuList();
+      await menulist.waitForDisplayed({ timeout: 2000, reverse: true });
+      // after 2 sec
+      await menulist.waitForDisplayed();
+      await browser.keys(Key.Backspace);
+      await menulist.waitForDisplayed({ timeout: 500, reverse: true });
+      await type('i');
+      await menulist.waitForDisplayed({ timeout: 2000, reverse: true });
+      await menulist.waitForDisplayed();
+      const options = await DSAutocompleteCO.getAutocompleteOptions();
+      const suggestedOption = await DSAutocompleteCO.getAutocompleteOptionLabel();
+      await expect(menulist).toBeDisplayedInViewport();
+      await expect(options).toHaveLength(1);
+      await expect(suggestedOption).toHaveTextContaining('Obi-Wan Kenobi');
+    });
+  });
+}

package/ds-autocomplete/DSAutocompleteCO.js

@@ -0,0 +1,36 @@
+/* eslint-disable import/no-relative-packages */
+import { PATH_E2E_AUTOCOMPLETE, PATH_AUTOCOMPLETE_EXAMPLES } from '../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../helpers';
+
+export default class DSAutocompleteCO extends PageObject {
+  // Desktop
+  static asyncSuggestionsAutocomplete = new Urlbuilder(PATH_E2E_AUTOCOMPLETE, 'async-suggestions-autocomplete');
+
+  static basic = new Urlbuilder(PATH_AUTOCOMPLETE_EXAMPLES, 'basic');
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('Autocomplete', example);
+  }
+
+  // selectors
+  static async getAutocompleteInput() {
+    return $('[data-testid="ds-input-text-input"]');
+  }
+
+  static async getClearBtn() {
+    return $('[data-testid="ds-input-text-clear-button"]');
+  }
+
+  static async getAutocompleteMenuList() {
+    return $('[data-testid="autocomplete-menu-list"]');
+  }
+
+  static async getAutocompleteOptionLabel() {
+    return $('[data-testid="ds-menu-item-menu-item-label"]');
+  }
+
+  static async getAutocompleteOptions() {
+    return $$('[data-testid="autocomplete-option"]');
+  }
+}

package/ds-banner/DSBanner.axe-core.func.spec.js

@@ -0,0 +1,79 @@
+import { axeCoreCheck } from '../helpers';
+import DSBannerCO from './DSBannerCO';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-10998 - DSBanner - Info - AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSBannerCO.infoURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display info banner properly and pass axecore test', async () => {
+      await DSBannerCO.openBanner();
+      const banner = await DSBannerCO.getBanner();
+      await banner.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11001 - DSBanner - Success - AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSBannerCO.successURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display success banner properly and pass axecore test', async () => {
+      await DSBannerCO.openBanner();
+      const banner = await DSBannerCO.getBanner();
+      await banner.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10999 - DSBanner - Error - AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSBannerCO.errorURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display error banner properly and pass axecore test', async () => {
+      await DSBannerCO.openBanner();
+      const banner = await DSBannerCO.getBanner();
+      await banner.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11100 - DSBanner - Warning - AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSBannerCO.warningURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display warning banner properly and pass axecore test', async () => {
+      await DSBannerCO.openBanner();
+      const banner = await DSBannerCO.getBanner();
+      await banner.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11002 - DSBanner, No action link rendered - AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSBannerCO.noActionLinkURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display the layout properly with no action link and pass axecore test', async () => {
+      await DSBannerCO.openBanner();
+      const banner = await DSBannerCO.getBanner();
+      await banner.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}