dimsum-e2e-tests 1.0.0-rc.1

package/ds-data-table-async/toolbar/DSDataTable.Toolbar.func.spec.js

@@ -0,0 +1,184 @@
+/* eslint-disable max-lines */
+/* eslint-disable wdio/no-pause */
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO, HeaderCO, CellCO } from '../components';
+import { mouseOver, getTestData } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8263 - DataTable, toolbar - Functional Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.performance.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: should not display the overflow menu after hovering the trigger', async () => {
+      const otherElement = await RowCO.getRowRadioButtonByIndex(2);
+      await mouseOver(otherElement, 10, 10);
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      await expect(toolbarMenu).not.toBeDisplayedInViewport();
+    });
+    it('02: should display the overflow menu after clicking the trigger', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      await expect(toolbarMenu).toBeDisplayedInViewport();
+    });
+    it('03: should close the overflow menu after clicking the trigger', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      await expect(toolbarMenu).not.toBeDisplayedInViewport();
+    });
+  });
+  describe('PUI-6868 - DataTable, toolbar keyboard navigation - Functional Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.performance.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: should focus on the toolbar trigger after clicking on a row and pressing tab', async () => {
+      const row = await RowCO.getRowByIndex(4);
+      const rowCell = await CellCO.getRowCellByIndex(row, 3);
+      await rowCell.click();
+      await browser.keys(Key.Return);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      const toolbarTrigger = await RowCO.getRowToolbarTriggerByIndex(4);
+      await expect(toolbarTrigger).toBeFocused();
+    });
+    it('02: should open the toolbar menu using the keyboard', async () => {
+      await browser.keys(Key.Return);
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      const firstBt = await RowCO.getToolbarMenuBtsByIndex(0);
+      await expect(toolbarMenu).toBeDisplayedInViewport();
+      await expect(firstBt).toBeFocused();
+    });
+    it('03: should navigate through the items using the keyboard - ArrowRight', async () => {
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.pause(500);
+      const secondBt = await RowCO.getToolbarMenuBtsByIndex(1);
+      await expect(secondBt).toBeFocused();
+    });
+    it('04: should navigate through the items using the keyboard - ArrowLeft', async () => {
+      await browser.keys(Key.ArrowLeft);
+      await browser.keys(Key.ArrowLeft);
+      await browser.keys(Key.ArrowLeft);
+      await browser.pause(500);
+      const thirdBt = await RowCO.getToolbarMenuBtsByIndex(2);
+      await expect(thirdBt).toBeFocused();
+    });
+    it('05: should close the toolbar and focus return to the trigger btn - Escape', async () => {
+      await browser.keys(Key.Escape);
+      await browser.pause(500);
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      const toolbarTrigger = await RowCO.getRowToolbarTriggerByIndex(4);
+      await expect(toolbarMenu).not.toBeDisplayedInViewport();
+      await expect(toolbarTrigger).toBeFocused();
+    });
+    it('06: should close the toolbar and focus return to the trigger btn - Enter', async () => {
+      await browser.keys(Key.Enter);
+      await browser.pause(500);
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      await toolbarMenu.waitForDisplayed();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Enter);
+      const toolbarTrigger = await RowCO.getRowToolbarTriggerByIndex(4);
+      await expect(toolbarMenu).not.toBeDisplayedInViewport();
+      await expect(toolbarTrigger).toBeFocused();
+    });
+  });
+  // Focus is not displayed when a button is clicked in Safari
+  if (browser.capabilities.browserName !== 'Safari') {
+    describe('PUI-6869 - DataTable, toolbar mouse navigation - Functional Test', async () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSDataTableCO.toolbarIntegration.go();
+        if (errorOnGo) throw errorOnGo;
+        await DSDataTableCO.waitForDataTable();
+      });
+      it('01: should navigate the toolbar menu using the mouse', async () => {
+        const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+        await toolbar.click();
+        const toolbarMenu = await RowCO.getToolbarMenu();
+        await expect(toolbarMenu).toBeDisplayedInViewport();
+        const secondBt = await RowCO.getToolbarMenuBtsByIndex(1);
+        await secondBt.click();
+        await expect(secondBt).toBeFocused();
+      });
+      it('02: should navigate again the toolbar menu using the mouse', async () => {
+        const thirdBt = await RowCO.getToolbarMenuBtsByIndex(2);
+        const secondBt = await RowCO.getToolbarMenuBtsByIndex(1);
+        await thirdBt.click();
+        await expect(thirdBt).toBeFocused();
+        await expect(secondBt).not.toBeFocused();
+      });
+    });
+  }
+  describe('PUI-7084  - DataTable, toolbar sticky - Functional Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.toolbarIntegration.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: should have the toolbar displayed', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      await expect(toolbarMenu).toBeDisplayedInViewport();
+    });
+    it('02: should scroll and the toolbar menu should still be displayed afetr scrolling', async () => {
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight);
+      await browser.keys(Key.ArrowRight); // scrolling
+      await browser.pause(5000);
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      const salaryHeader = await HeaderCO.getHeaderCellByIndex(4);
+      await expect(toolbarMenu).toBeDisplayedInViewport();
+      await expect(salaryHeader).toBeDisplayedInViewport();
+    });
+  });
+
+  describe('PUI-9603  - DataTable, Toolbar items to be triggered - Functional Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.toolbarTriggers.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: should have the toolbar displayed and no item activated', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      const toolbarMenu = await RowCO.getToolbarMenu();
+      const testData = await (await getTestData('1')).getText();
+      await expect(toolbarMenu).toBeDisplayedInViewport();
+      await expect(testData).toEqual('Toolbar items trigger count: 0');
+    });
+    it('02: should press enter and toolbar items activations should equal to 1', async () => {
+      await browser.keys(Key.Enter);
+      const testData = await (await getTestData('1')).getText();
+      await expect(testData).toEqual('Toolbar items trigger count: 1');
+    });
+    it('03: should open toolbar again activate a toolbar item with click', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(2);
+      await toolbar.click();
+      const toolbarItem = await RowCO.getToolbarMenuBtsByIndex(1);
+      await toolbarItem.click();
+      const testData = await (await getTestData('1')).getText();
+      await expect(testData).toEqual('Toolbar items trigger count: 2');
+    });
+    it('04: should open toolbar again activate a toolbar item with spacebar', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      await browser.keys(Key.Space);
+      const testData = await (await getTestData('1')).getText();
+      await expect(testData).toEqual('Toolbar items trigger count: 3');
+    });
+  });
+}

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

@@ -0,0 +1,33 @@
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO } from '../components';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-7372 - DataTable, toolbar - Visual Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.performance.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('should display toolbar focused', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      const snapshot = await browser.checkSnapshot(DSDataTableCO.snapshotPath('toolbar-focused'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-6991 - DataTable, Expandable with toolbar -visual.', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.performance.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('should display the layout with a subbrow expanded and its child expanded', async () => {
+      const expandBtn = await RowCO.getRowExpandButtonByIndex(1);
+      await expandBtn.click();
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(1);
+      await toolbar.click();
+      const snapshot = await browser.checkSnapshot(DSDataTableCO.snapshotPath('datatable-expanded-with-toolbar'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

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

@@ -0,0 +1,27 @@
+/* eslint-disable wdio/no-pause */
+/* eslint-disable max-len */
+
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO } from '../components';
+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-11460 - DataTable, toolbar - AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.performance.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: should display toolbar focused and pass axe-core scan', async () => {
+      const toolbar = await RowCO.getRowToolbarTriggerByIndex(3);
+      await toolbar.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

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

@@ -0,0 +1,17 @@
+/* eslint-disable max-len */
+import DSDataTableCO from '../DSDataTableCO';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-8277 - DataTable, responsive - Visual Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.responsive.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('should display the datatable inside a 200px div correctly', async () => {
+      await browser.eyesOpen();
+      const checkSnap = await browser.eyesCheckSnapshot(await DSDataTableCO.snapshotPath('responsive'));
+      await expect(checkSnap).toEqual(0);
+    });
+  });
+}

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

@@ -0,0 +1,32 @@
+/* eslint-disable wdio/no-pause */
+/* eslint-disable max-len */
+
+import DSDataTableCO from '../DSDataTableCO';
+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-11461 - DataTable, Column vissibility - Visual Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.toggleColumnVisibility.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('01: should display hidden column', async () => {
+      const toggleBtn = await DSDataTableCO.getToggleBtn();
+      await toggleBtn.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should hide the column correctly', async () => {
+      const toggleBtn = await DSDataTableCO.getToggleBtn();
+      await toggleBtn.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

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

@@ -0,0 +1,81 @@
+/* eslint-disable max-len */
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO, FiltersCO } from '../components';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8264 - DataTable, Column vissibility - Visual Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.toggleColumnVisibility.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('should display hidden column', async () => {
+      await browser.eyesOpen();
+      const toggleBtn = await DSDataTableCO.getToggleBtn();
+      await toggleBtn.click();
+      const checkSnap = await browser.eyesCheckSnapshot(await DSDataTableCO.snapshotPath('column-displayed'));
+      await expect(checkSnap).toEqual(0);
+    });
+    it('should hide the column correctly', async () => {
+      await browser.eyesOpen();
+      const toggleBtn = await DSDataTableCO.getToggleBtn();
+      await toggleBtn.click();
+      const checkSnap = await browser.eyesCheckSnapshot(await DSDataTableCO.snapshotPath('column-hidden'));
+      await expect(checkSnap).toEqual(0);
+    });
+  });
+
+  describe('PUI-8615 - DataTable, Sticky empty state - Visual Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.emptyMaxWidth.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('should display unscrolled datatable with the empty state message', async () => {
+      await browser.eyesOpen();
+      const checkSnap = await browser.eyesCheckSnapshot(await DSDataTableCO.snapshotPath('empty-unscrolled'));
+      await expect(checkSnap).toEqual(0);
+    });
+    it('should display the horizontally scrolled datatable with the empty state message', async () => {
+      await browser.eyesOpen();
+      await (await HeaderCO.getHeaderCellByIndex(0)).click();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab); // moves through the headers to scroll horizontally
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      const checkSnap = await browser.eyesCheckSnapshot(await DSDataTableCO.snapshotPath('empty-scrolled'));
+      await expect(checkSnap).toEqual(0);
+    });
+  });
+
+  describe('PUI-8616 - DataTable, Double pill row  - Visual Test', async () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.paginatedWithFilters.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+    it('should display two row of pills and the pagination correctly rendered', async () => {
+      await browser.eyesOpen();
+      await FiltersCO.openFilterPopperByColumnName('id', 0);
+      await browser.keys(Key.Return);
+      await FiltersCO.openFilterPopperByColumnName('name', 0);
+      await browser.keys(Key.Return);
+      await FiltersCO.openFilterPopperByColumnName('position', 0);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
+      await FiltersCO.openFilterPopperByColumnName('name', 0);
+      await browser.keys(Key.Return);
+      await FiltersCO.openFilterPopperByColumnName('name', 0);
+      await browser.keys(Key.Return);
+      const checkSnap = await browser.eyesCheckSnapshot(await DSDataTableCO.snapshotPath('datatable-double-pill-row'));
+      await expect(checkSnap).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DSDataGrids-selectable-default.func.spec.js

@@ -0,0 +1,27 @@
+import DG from './DatagridObject';
+import { isChecked } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-6168 - DataGrid, Multi, First row selected by default', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.selectableMultiFirstRowSelectedURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display the first row selected by default', async () => {
+      const checkBox = await DG.getCheckbox(1);
+      const checkBoxChecked = await isChecked(checkBox);
+      await expect(checkBoxChecked).toBe(true);
+    });
+  });
+  describe('PUI-6169 - DataGrid, First row selected by default', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.selectableFirstRowSelectedURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display the first row selected by default', async () => {
+      const radioButton = await DG.getRadioButton(0);
+      const radioButtonChecked = await isChecked(radioButton);
+      await expect(radioButtonChecked).toBe(true);
+    });
+  });
+}

package/ds-datagrids/DSDatagrid-basic.visual.spec.js

@@ -0,0 +1,16 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-4032 - DataGrid - Visual test for sticky toolbar', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.allFeatures.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should not display extra scrollbar when toolbar is present', async () => {
+      await browser.eyesOpen();
+      await (await DG.getFilterHeader('Name')).waitForDisplayed({ timeout: 5000 });
+      const snapshot = await browser.eyesCheckSnapshot(DG.snapshotPath('datagrid--basic'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DSDatagrid-editable.func.spec.js

@@ -0,0 +1,62 @@
+/* eslint-env mocha */
+import Editable from './page-objects/Editable.componentObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-2900 - DataGrid Editable textbox', () => {
+    before('loading page', async () => {
+      const errorOnGo = await Editable.editableURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('should clear content of cell', async () => {
+      await Editable.clearField(2);
+      await Editable.clickCell(3);
+      const cellText = await (await Editable.getCell(2)).getText();
+      await expect(cellText).not.toEqual('artist');
+    });
+
+    it('should edit correctly textbox', async () => {
+      const cell = await Editable.getCell(2);
+      await cell.doubleClick();
+      await Editable.sendVal('Editable test');
+      await Editable.clickCell(3);
+      const cellText = await (await Editable.getCell(2)).getText();
+      await expect(cellText).toContain('Editable test');
+    });
+  });
+
+  describe('PUI-2901 - DataGrid Editable combobox', () => {
+    before('loading page', async () => {
+      const errorOnGo = await Editable.editableURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should open combobox', async () => {
+      const cell = await Editable.getCellCountry(1);
+      await cell.waitForDisplayed();
+      await cell.click(); // TODO : check why this explodes in BS but not in local
+      const combobox = await Editable.getComboBoxMenu();
+      await combobox.waitForDisplayed();
+      const comboMenu = await Editable.getComboBoxMenu();
+      await expect(comboMenu).toExist();
+    });
+
+    it('should set correctly an option of combobox', async () => {
+      await (await Editable.getComboBoxOption('Option 2')).click();
+      await Editable.clickCell(2);
+      const cellText = await (await Editable.getCellCountry(1)).getText();
+      await expect(cellText).toContain('Option 2');
+    });
+  });
+  describe('PUI-3741 - DataGrid Editable tooltip', () => {
+    before('loading page', async () => {
+      const errorOnGo = await Editable.editableURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should not render tooltip on cell without truncation', async () => {
+      const cell = await Editable.getCellName(6);
+      await cell.moveTo();
+      const dsPortal = await $('.em-ds-portal');
+      await expect(dsPortal).not.toBeDisplayed();
+    });
+  });
+}

package/ds-datagrids/DSDatagrid-empty-state.visual.spec.js

@@ -0,0 +1,16 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('pui-6156 - DataGrid, Emtpy State - Visual Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.emptyStateURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display datagrid with empty state', async () => {
+      await browser.eyesOpen();
+      await (await DG.getClickMeBtn()).waitForDisplayed({ timeout: 5000 });
+      const snapshot = await browser.eyesCheckSnapshot(DG.snapshotPath('datagrid--empty-state'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DSDatagrid-pui-5550.func.spec.js

@@ -0,0 +1,15 @@
+import { Key } from 'webdriverio';
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-5773 - DataGrid - Shift key down on input', () => {
+    it('should not lose current focus on shift keypress', async () => {
+      await (await DG.pui5550).go();
+      await (await DG.getHeaderCell(1)).waitForDisplayed({ timeout: 5000 });
+      const input = await DG.getInputField(0);
+      await input.click();
+      await browser.keys(Key.Shift);
+      await expect(input).toBeFocused();
+    });
+  });
+}

package/ds-datagrids/DSDatagrid-selectable-multi.visual.spec.js

@@ -0,0 +1,16 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-6155 - DataGrid, Selectable Multi - Visual Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.selectableMultiURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display basic DataGrid with selectable multi', async () => {
+      await (await DG.getFilterHeader('Name')).waitForDisplayed();
+      await browser.pause(500);
+      const snapshot = await browser.checkSnapshot(DG.snapshotPath('datagrid--selectable-multi'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DSDatagrid-sortable.func.spec.js

@@ -0,0 +1,43 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-4111 - DataGrid - Sorting dates', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.sortablePUI4017.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display dates in correct order', async () => {
+      await (await DG.getDataGridHeader(1)).click();
+      const columnText0 = await (await DG.getColumnDate(0)).getText();
+      const columnText3 = await (await DG.getColumnDate(3)).getText();
+      const columnText4 = await (await DG.getColumnDate(4)).getText();
+      await expect(columnText0).toContain('12:05 am');
+      await expect(columnText3).toContain('11:00 am');
+      await expect(columnText4).toContain('08:00 pm');
+      await (await DG.getDataGridHeader(1)).click();
+      const columnText0b = await (await DG.getColumnDate(0)).getText();
+      const columnText1 = await (await DG.getColumnDate(1)).getText();
+      const columnText4b = await (await DG.getColumnDate(4)).getText();
+      await expect(columnText0b).toContain('08:00 pm');
+      await expect(columnText1).toContain('11:00 am');
+      await expect(columnText4b).toContain('12:05 am');
+    });
+  });
+  describe('PUI-4799 - [DataGrid] - Sorting with empty columns', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.sortableEmpty.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display dates in correct order', async () => {
+      const sortCell = await DG.getSortCell('position', 0);
+      await expect(sortCell).toHaveTextContaining('Developer');
+      await (await DG.getDataGridHeader(1)).click();
+      const sortCell0 = await DG.getSortCell('position', 0);
+      const sortCell12 = await DG.getSortCell('position', 12);
+      const sortCell15 = await DG.getSortCell('position', 15);
+      await expect(sortCell0).toHaveTextContaining('Designer');
+      await expect(sortCell12).toHaveTextContaining('');
+      await expect(sortCell15).toHaveTextContaining('');
+    });
+  });
+}

package/ds-datagrids/DSDatagrid.func.spec.js

@@ -0,0 +1,56 @@
+/* eslint-env mocha */
+import { Key } from 'webdriverio';
+import DataGridObject from './DatagridObject';
+import DSTabsCO from '../ds-tabs/DSTabsCO';
+import { type, clearValue } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-4529 - DataGrid:: Filter on grouped DataGrid', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DataGridObject.pui4416.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('value is properly filtered', async () => {
+      await (await DataGridObject.getInputField()).moveTo();
+      await (await DataGridObject.getInputField()).setValue('Doe');
+      await (await DataGridObject.getSearchBtn()).click();
+      await (await DataGridObject.getPillTitle()).waitForDisplayed();
+      const pillTitle = await DataGridObject.getPillTitle();
+      const removablePill = await DataGridObject.getRemovablePill();
+      const columnLenght = await DataGridObject.getColumnLength();
+      const columnName = await DataGridObject.getColumnName(0);
+      await expect(pillTitle).toHaveTextContaining('Name');
+      await expect(removablePill).toHaveTextContaining('Doe');
+      await expect(columnLenght).toBeGreaterThan(0);
+      await expect(columnName).toHaveTextContaining('Doe');
+    });
+  });
+  describe('PUI-5201 - Tabs, Edit cell inside tab', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DataGridObject.pui2553.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should open correctly tab', async () => {
+      const tab = await DSTabsCO.getTab(1);
+      await expect(tab).toBeDisplayed();
+    });
+    it('should open 2nd tab correctly', async () => {
+      await (await DSTabsCO.getTab(2)).click();
+      const tabPanel = await DSTabsCO.getTabPanel(2);
+      await expect(tabPanel).toBeDisplayed();
+    });
+    it('should edit correctly textbox', async () => {
+      const cell = await DataGridObject.getCell('position', 2);
+      await cell.waitForDisplayed();
+      // eslint-disable-next-line wdio/no-pause
+      await browser.pause(500);
+      await cell.click();
+      await clearValue(await cell);
+      await type('Editable test');
+      await browser.keys(Key.Enter);
+      const tabPanel = await DSTabsCO.getTabPanel(2);
+      await expect(cell).toHaveTextContaining('Editable test');
+      await expect(tabPanel).toBeDisplayed();
+    });
+  });
+}