dimsum-e2e-tests 1.0.0-rc.1

package/ds-drag-and-drop/DSDragAndDrop.func.spec.js

@@ -0,0 +1,186 @@
+/* eslint-disable max-lines */
+import { Key } from 'webdriverio';
+import DSDragAndDropCO from './DSDragAndDropCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  // Unskip after PUI-11541 gets fixed
+  describe.skip('PUI-11536 - DSDragAndDrop: Basic, mouse  -Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDragAndDropCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should dnd an item to a position below', async () => {
+      const firstDNDHandler = await DSDragAndDropCO.getListItemSVGByIndex(0);
+      const thirdDNDHandler = await DSDragAndDropCO.getListItemSVGByIndex(3);
+      await firstDNDHandler.dragAndDrop(thirdDNDHandler);
+      const thirdItemText = await (await DSDragAndDropCO.getTypographyByIndex(2)).getText();
+      await expect(thirdItemText).toEqual('Test 1');
+    });
+    it('02: dnd an item to a position above', async () => {
+      const fifthDNDHandler = await DSDragAndDropCO.getListItemSVGByIndex(4);
+      const firstDNDHandler = await DSDragAndDropCO.getListItemSVGByIndex(0);
+      await fifthDNDHandler.dragAndDrop(firstDNDHandler);
+      const thirdItemText = await (await DSDragAndDropCO.getTypographyByIndex(0)).getText();
+      await expect(thirdItemText).toEqual('Test 5');
+    });
+  });
+
+  // Unskip after PUI-11541 gets fixed
+  describe.skip('PUI-11537 - DSDragAndDrop: Basic, keyboard  -Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDragAndDropCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should dnd an item to a position below', async () => {
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      const thirdItemText = await (await DSDragAndDropCO.getTypographyByIndex(3)).getText();
+      await expect(thirdItemText).toEqual('Test 1');
+    });
+    it('02: dnd an item to a position above', async () => {
+      await browser.keys([Key.Shift, Key.Tab]);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.ArrowUp);
+      await browser.keys(Key.Return);
+      const firstItemText = await (await DSDragAndDropCO.getTypographyByIndex(0)).getText();
+      await expect(firstItemText).toEqual('Test 4');
+    });
+  });
+
+  // Unskip after PUI-11541 gets fixed
+  describe.skip('PUI-11538 - DSDragAndDrop: Between containers  -Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDragAndDropCO.multiContainerURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should move an item from the upper-right list to the upper-left', async () => {
+      const upperRightList = await DSDragAndDropCO.getList(1);
+      const URLfirstItem = await DSDragAndDropCO.getSVGByListAndIndex(upperRightList, 0); // URL -> Upper Right List
+      const upperLeftList = await DSDragAndDropCO.getList(0);
+      const ULLfirstItem = await DSDragAndDropCO.getSVGByListAndIndex(upperLeftList, 0);
+      await URLfirstItem.dragAndDrop(ULLfirstItem);
+      const currentULLfirstItem = await DSDragAndDropCO.getListItemByListAndIndex(upperLeftList, 0);
+      const ULLfirstItemText = await (await DSDragAndDropCO.getTypographyByItem(currentULLfirstItem)).getText();
+      await expect(ULLfirstItemText).toEqual('Test 10000');
+    });
+    it('02: should move an item from de bottom-left list to the upper-right', async () => {
+      const bottomLeftList = await DSDragAndDropCO.getList(2);
+      const BLLItem = await DSDragAndDropCO.getSVGByListAndIndex(bottomLeftList, 2);
+      const upperRightList = await DSDragAndDropCO.getList(1);
+      const URLItem = await DSDragAndDropCO.getSVGByListAndIndex(upperRightList, 2);
+      await BLLItem.dragAndDrop(URLItem);
+      const movedItem = await DSDragAndDropCO.getListItemByListAndIndex(upperRightList, 2);
+      const movedItemText = await (await DSDragAndDropCO.getTypographyByItem(movedItem)).getText();
+      await expect(movedItemText).toEqual('Test 20002');
+    });
+    it('03: should leave the upper-left list empty', async () => {
+      const upperLeftList = await DSDragAndDropCO.getList(0);
+      const ULLsecondItem = await DSDragAndDropCO.getSVGByListAndIndex(upperLeftList, 1);
+      const ULLfirstItem = await DSDragAndDropCO.getSVGByListAndIndex(upperLeftList, 0);
+      const bottomRightList = await DSDragAndDropCO.getList(3);
+      const bottomLeftList = await DSDragAndDropCO.getList(2);
+      const BRLItem = await DSDragAndDropCO.getSVGByListAndIndex(bottomRightList, 2);
+      const BLLitem = await DSDragAndDropCO.getSVGByListAndIndex(bottomLeftList, 3);
+      await ULLsecondItem.dragAndDrop(BRLItem);
+      await ULLfirstItem.dragAndDrop(BLLitem);
+      const movedItemThirdList = await (await DSDragAndDropCO.getListItemByListAndIndex(bottomLeftList, 3)).getText();
+      const movedItemFourthList = await (await DSDragAndDropCO.getListItemByListAndIndex(bottomRightList, 2)).getText();
+      await expect(ULLfirstItem).not.toExist();
+      await expect(movedItemThirdList).toEqual('Test 10000');
+      await expect(movedItemFourthList).toEqual('Test 1');
+    });
+  });
+
+  // Unskip after PUI-11541 gets fixed
+  describe.skip('PUI-11540 - DSDragAndDrop: Treeview, mouse  -Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDragAndDropCO.withTreeURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should dnd one item within another of the same list', async () => {
+      const leftList = await DSDragAndDropCO.getList(0);
+      const rightList = await DSDragAndDropCO.getList(1);
+      const secondItemDNDHandler = await DSDragAndDropCO.getSVGByListAndIndex(leftList, 2);
+      const thirdItemDNDHandler = await DSDragAndDropCO.getSVGByListAndIndex(leftList, 3);
+      await secondItemDNDHandler.dragAndDrop(thirdItemDNDHandler);
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      const rightListItems = (await DSDragAndDropCO.getListItemsByList(rightList)).length;
+      await expect(leftListItems).toEqual(2);
+      await expect(rightListItems).toEqual(3);
+    });
+    it('02: should dnd one item within another of other list', async () => {
+      const leftList = await DSDragAndDropCO.getList(0);
+      const rightList = await DSDragAndDropCO.getList(1);
+      const itemLeftDNDHandler = await DSDragAndDropCO.getSVGByListAndIndex(leftList, 0);
+      const itemRightListDNDHandler = await DSDragAndDropCO.getSVGByListAndIndex(rightList, 2);
+      await itemLeftDNDHandler.dragAndDrop(itemRightListDNDHandler);
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      const rightListItems = (await DSDragAndDropCO.getListItemsByList(rightList)).length;
+      await expect(leftListItems).toEqual(1);
+      await expect(rightListItems).toEqual(3);
+    });
+    it('03: should expand chevron and find nested items', async () => {
+      const leftList = await DSDragAndDropCO.getList(0);
+      const rightList = await DSDragAndDropCO.getList(1);
+      const chevron = await DSDragAndDropCO.getSVGByListAndIndex(rightList, 3);
+      await chevron.click();
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      const rightListItems = (await DSDragAndDropCO.getListItemsByList(rightList)).length;
+      await expect(leftListItems).toEqual(1);
+      await expect(rightListItems).toEqual(4);
+    });
+    it('04: should expand nested chevron and find nested subitems', async () => {
+      const leftList = await DSDragAndDropCO.getList(0);
+      const rightList = await DSDragAndDropCO.getList(1);
+      const chevron = await DSDragAndDropCO.getSVGByListAndIndex(rightList, 5);
+      await chevron.click();
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      const rightListItems = (await DSDragAndDropCO.getListItemsByList(rightList)).length;
+      await expect(leftListItems).toEqual(1);
+      await expect(rightListItems).toEqual(5);
+    });
+  });
+
+  // Unskip after PUI-11541 gets fixed
+  describe.skip('PUI-11541 - DSDragAndDrop: Treeview, keyboard  -Func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDragAndDropCO.withTreeURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should dnd one item inside another of the same list, two remaining on list', async () => {
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
+      const leftList = await DSDragAndDropCO.getList(0);
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      await expect(leftListItems).toEqual(2);
+    });
+    it('02: should expand chevron and have threre items on list', async () => {
+      const leftList = await DSDragAndDropCO.getList(0);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      await expect(leftListItems).toEqual(3);
+    });
+    it('03: should expand nested chevron have four items on list', async () => {
+      const leftList = await DSDragAndDropCO.getList(0);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      const leftListItems = (await DSDragAndDropCO.getListItemsByList(leftList)).length;
+      await expect(leftListItems).toEqual(4);
+    });
+  });
+}

package/ds-drag-and-drop/DSDragAndDrop.visual.spec.js

@@ -0,0 +1,45 @@
+/* eslint-disable max-lines */
+import { Key } from 'webdriverio';
+import DSDragAndDropCO from './DSDragAndDropCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  // Unskip after PUI-11541 gets fixed
+  describe.skip('PUI-11545 - DSDragAndDrop: Treeview  -Visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDragAndDropCO.withTreeURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should dnd one item inside another of the same list, two remaining on list', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
+      const snapshot = await browser.eyesCheckSnapshot(DSDragAndDropCO.snapshotPath('DSDragAndDropCO-two-onlist'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('02: should expand chevron and have threre items on list', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      const snapshot = await browser.eyesCheckSnapshot(DSDragAndDropCO.snapshotPath('DSDragAndDropCO-three-onlist'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('03: should expand nested chevron have four items on list', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      const snapshot = await browser.eyesCheckSnapshot(DSDragAndDropCO.snapshotPath('DSDragAndDropCO-four-onlist'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('04: should display item being moved', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      const snapshot = await browser.eyesCheckSnapshot(DSDragAndDropCO.snapshotPath('DSDragAndDropCO-moving-item'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-drag-and-drop/DSDragAndDropCO.js

@@ -0,0 +1,54 @@
+/* eslint-disable import/no-relative-packages */
+import { PATH_E2E_DND } from '../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../helpers';
+
+export default class DSDragAndDropCO extends PageObject {
+  static basicURL = new Urlbuilder(PATH_E2E_DND, 'basic-test');
+
+  static multiContainerURL = new Urlbuilder(PATH_E2E_DND, 'multi-containers-test');
+
+  static withTreeURL = new Urlbuilder(PATH_E2E_DND, 'with-ds-tree-test');
+
+  // Selectors
+  static async getList(index = 0) {
+    return $$('[role="list"]')[index];
+  }
+
+  static async getListItem(index = 0) {
+    return $$('[role="listitem"]')[index];
+  }
+
+  static async getListItemsByList(list) {
+    return list.$$('[role="listitem"]');
+  }
+
+  static async getListItemByListAndIndex(list, index = 0) {
+    return list.$$('[role="listitem"]')[index];
+  }
+
+  static async getSVGByListAndIndex(list, index = 0) {
+    return list.$$('[role="listitem"] svg')[index];
+  }
+
+  static async getTypographyByIndex(index = 0) {
+    return $$('[role="listitem"] div div div div')[index * 2 + 1];
+  }
+
+  static async getTypographyByItem(item) {
+    return item.$$('div div div div')[1];
+  }
+
+  static async getSvgByItem(item) {
+    return item.$('[role="listitem"] svg');
+  }
+
+  // Used for chevrons and DND handlers
+  static async getListItemSVGByIndex(index = 0) {
+    return $$('[data-testid="ds-icon-svg"]')[index];
+  }
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('DSDnd', example, 'ds-drag-and-drop');
+  }
+}

package/ds-dropdownmenu/DSDropddownMenu-loading.visual.spec.js

@@ -0,0 +1,28 @@
+import DropdownMenuCO from './DropdownMenuCO';
+import { DimsumConfig } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('Dropdown Menu with select', () => {
+    beforeEach(async () => {
+      const errorOnGo = await DropdownMenuCO.loadingURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display menu with loading indicator when loading=true', async () => {
+      const button = await $(`.${DimsumConfig.classNamePrefix}-button`);
+      await button.click();
+      await browser.waitUntil(async () => (await $(`.${DimsumConfig.classNamePrefix}-menu`)).isExisting());
+      const snapshot = await browser.checkSnapshot(DropdownMenuCO.snapshotPath('dropdownmenu--loading-true'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('should display menu without loading indicator when loading=false', async () => {
+      const button = await $(`.${DimsumConfig.classNamePrefix}-button`);
+      await button.click();
+      await browser.waitUntil(async () =>
+        (await $(`.${DimsumConfig.classNamePrefix}-menu`).$('.menu-component-internal-wrapper')).isExisting(),
+      );
+      const snapshot = await browser.checkSnapshot(DropdownMenuCO.snapshotPath('dropdownmenu--loading-false'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-dropdownmenu/DSDropddownMenu.func.spec.js

@@ -0,0 +1,38 @@
+import DropdownMenuCO from './DropdownMenuCO';
+import { mouseOver } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-4514 - DropdownMenu - clear textField', () => {
+    before(async () => {
+      const errorOnGo = await DropdownMenuCO.withSelectURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should be able to type in textField', async () => {
+      await (await DropdownMenuCO.getTriggerBtn()).click();
+      await (await DropdownMenuCO.getTextField()).setValue('Test 1234');
+      const ddTextField = await DropdownMenuCO.getTextField();
+      await expect(ddTextField).toHaveValueContaining('Test 1234');
+    });
+    it('should be able to clear textField', async () => {
+      await DropdownMenuCO.clearField(9);
+      const ddTextField = await DropdownMenuCO.getTextField();
+      await expect(ddTextField).not.toHaveValueContaining();
+    });
+  });
+  describe('PUI-4713 - elipsis and chevron addon behavior', () => {
+    before(async () => {
+      const errorOnGo = await DropdownMenuCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should open submenu when hover over chevron addon', async () => {
+      await mouseOver(await DropdownMenuCO.getChevronAddOn());
+      const menuItem = await DropdownMenuCO.getMenuItemByText('SubMenu List Item-1');
+      await expect(menuItem).toBeDisplayed();
+    });
+    it('should open submenu when clicking on elipsis addon', async () => {
+      await (await DropdownMenuCO.getEllipsisAddOn()).click();
+      const menuItem = await DropdownMenuCO.getMenuItemByText('SubMenu List Item-1');
+      await expect(menuItem).toBeDisplayed();
+    });
+  });
+}

package/ds-dropdownmenu/DSDropdownMenu-basic.visual.spec.js

@@ -0,0 +1,30 @@
+import DropdownMenuCO from './DropdownMenuCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-5181 - DropDownMenu basic', () => {
+    before(async () => {
+      const errorOnGo = await DropdownMenuCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display basic dropdown', async () => {
+      await (await DropdownMenuCO.getEllipsisAddOn()).click();
+      await (
+        await DropdownMenuCO.getMenuItemByText('SubMenu List Item-1')
+      ).waitForDisplayed({
+        timeout: 5000,
+      });
+      const snapshot = await browser.checkSnapshot(DropdownMenuCO.snapshotPath('dropdownmenu--basic'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-8296 - DropDownMenu colored addon', () => {
+    before(async () => {
+      const errorOnGo = await DropdownMenuCO.coloredAddon.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display basic dropdown', async () => {
+      const snapshot = await browser.checkSnapshot(DropdownMenuCO.snapshotPath('colored-addon'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-dropdownmenu/DSDropdownMenu-withselect.visual.spec.js

@@ -0,0 +1,24 @@
+import DropdownMenuCO from './DropdownMenuCO';
+import { DimsumConfig } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('Dropdown Menu with select', () => {
+    beforeEach(async () => {
+      const errorOnGo = await DropdownMenuCO.withSelectURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('should display trigger button with menu closed', async () => {
+      const snapshot = await browser.checkSnapshot(DropdownMenuCO.snapshotPath('dropdownmenu--with-select-closed'));
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('should display menu with select when button clicked', async () => {
+      const button = await $(`.${DimsumConfig.classNamePrefix}-button`);
+      await button.click();
+      await (await $(`.${DimsumConfig.classNamePrefix}-menu`)).waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DropdownMenuCO.snapshotPath('dropdownmenu--with-select-open'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-dropdownmenu/DropdownMenuCO.js

@@ -0,0 +1,57 @@
+import { Key } from 'webdriverio';
+import { PATH_END_OF_LIFE_DROPDOWN_MENU } from '../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../helpers';
+
+export default class DSDropdownMenu extends PageObject {
+  static loadingURL = new Urlbuilder(PATH_END_OF_LIFE_DROPDOWN_MENU, 'loading');
+
+  static basicURL = new Urlbuilder(PATH_END_OF_LIFE_DROPDOWN_MENU, 'basic');
+
+  static withSelectURL = new Urlbuilder(PATH_END_OF_LIFE_DROPDOWN_MENU, 'with-select');
+
+  static coloredAddon = new Urlbuilder(PATH_END_OF_LIFE_DROPDOWN_MENU, 'color-addon');
+
+  // Selectors
+
+  static async getEllipsisAddOn() {
+    return $('[data-testid="vertical-elipsis"]');
+  }
+
+  static async getChevronAddOn() {
+    return $('[data-testid="chevron-right"]');
+  }
+
+  static async getTriggerBtn() {
+    return $('[data-testid="button-wrapper"]');
+  }
+
+  static async getMenuItem(index = 0) {
+    await (await $('.em-ds-menu-item')).waitForDisplayed({ timeout: 5000 });
+    return $$('.em-ds-menu-item')[index];
+  }
+
+  static async getMenuItemByText(text = '') {
+    return $(`.em-ds-menu-item*=${text}`);
+  }
+
+  static async getMenuItemAddon(index = 0) {
+    await (await $('.em-ds-menu-item__addon')).waitForDisplayed({ timeout: 5000 });
+    return $$('.em-ds-menu-item__addon')[index];
+  }
+
+  static async getTextField() {
+    return $('//div[@data-testid="combobox"]//input');
+  }
+
+  static async clearField(len) {
+    for (let i = 0; i <= len; i += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await browser.keys(Key.Backspace);
+    }
+  }
+
+  // Snapshots
+  static snapshotPath(example = 'loading') {
+    return PageObject.getSnapshotPathBuilder('DSDropdownMenu', example, 'ds-dropdownmenu');
+  }
+}

package/ds-dropdownmenu-v2/DSDDMenuV2.axe-core.func.spec.js

@@ -0,0 +1,124 @@
+/* eslint-disable max-lines */
+import { axeCoreCheck } from '../helpers';
+import DSDDMenuV2CO from './DSDDMenuV2CO';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-10939 - DropdownMenuV2, Loading -AxeCore.', () => {
+    before(async () => {
+      const errorOnGo = await DSDDMenuV2CO.loadingURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display a loading indicator when ddmenu is triggered', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10940 - DropdownMenuV2, Casscading Menu -AxeCore.', () => {
+    before(async () => {
+      const errorOnGo = await DSDDMenuV2CO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open dropdown and have 6 options', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should open also a submenu and have 5 more options', async () => {
+      const submenuIcon = await DSDDMenuV2CO.getSubmenuIconByIndex(3);
+      await submenuIcon.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('03: should open also a nested submenu and have 5 more options', async () => {
+      const submenuIcon = await DSDDMenuV2CO.getSubmenuIconByIndex(5);
+      await submenuIcon.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10941 - DropdownMenuV2, Empty state -AxeCore.', () => {
+    before(async () => {
+      const errorOnGo = await DSDDMenuV2CO.emptyStateURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display a empty state when ddmenu is triggered', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10942 - DropdownMenuV2, Single select -AxeCore.', () => {
+    before(async () => {
+      const errorOnGo = await DSDDMenuV2CO.mandatorySingleURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open ddmenu and have option 1 automatically checked', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10943 - DropdownMenuV2, Multi select (with mouse) -AxeCore.', () => {
+    before(async () => {
+      const errorOnGo = await DSDDMenuV2CO.customWidthURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should open ddmenu and have option no options selected', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should click options and have them selected', async () => {
+      const opt1 = await DSDDMenuV2CO.getOptionByIndex(0);
+      const opt2 = await DSDDMenuV2CO.getOptionByIndex(1);
+      const opt3 = await DSDDMenuV2CO.getOptionByIndex(2);
+      await opt1.click();
+      await opt2.click();
+      await opt3.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+  describe('PUI-10944 - DropdownMenuV2, Header -AxeCore.', () => {
+    before(async () => {
+      const errorOnGo = await DSDDMenuV2CO.headerURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display a dropdown menu with header', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11780, DropdownMenuV2, Skeleton Menu Item -AxeCore.', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDDMenuV2CO.skeletonItemURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display skeleton menu item and pass axe-core scan', async () => {
+      const ddMenuTrigger = await DSDDMenuV2CO.getDropDownTrigger();
+      await ddMenuTrigger.click();
+      const skeleton = await DSDDMenuV2CO.getSkeletons();
+      await skeleton.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}