dimsum-e2e-tests 1.0.0-rc.1

package/ds-datagrids/DSDatagrids-infinite-scrolling.func.spec.js

@@ -0,0 +1,24 @@
+/* eslint-disable wdio/no-pause */
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-3341 - DataGrid verify infinite scroll', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.infiniteScrollURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display dg with 30 items', async () => {
+      const rows = await DG.getRows();
+      await expect(rows).toHaveLength(30);
+    });
+    it('after scrolling should be more items', async () => {
+      const row30 = await DG.getRowIndex(29);
+      await row30.scrollIntoView();
+      browser.pause(500);
+      const rowDisplayed = await DG.getRowIndex(31);
+      const rows = await DG.getRows();
+      await expect(rowDisplayed).toBeDisplayed();
+      await expect(rows).not.toHaveLength(30);
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-pagination.func.spec.js

@@ -0,0 +1,85 @@
+import Pagination from './page-objects/Pagination.componentObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-2851 - Pagination, combobox behaviour', () => {
+    before('loading page', async () => {
+      await Pagination.open();
+    });
+    it('01: should display default rows on screen', async () => {
+      const rows = await Pagination.getRows();
+      await expect(rows).toEqual(10);
+    });
+    it('02: should display default num row values on combobox', async () => {
+      const comboBoxValue = await Pagination.getComboBoxValue();
+      await expect(comboBoxValue).toContain('10');
+    });
+    it('03: should show dropmenu when combobox is clicked', async () => {
+      await (await Pagination.getComboBoxButton()).click();
+      const comboBoxMenu = await Pagination.getComboBoxMenu();
+      await expect(comboBoxMenu).toBeDisplayed();
+    });
+    it('04: should scroll to the end of dropmenu list and click last option', async () => {
+      const comboBoxOpt = await Pagination.getComboBoxOption(20);
+      await comboBoxOpt.waitForDisplayed();
+      const option20 = await Pagination.getComboBoxOption(20);
+      // const option30 = await Pagination.getComboBoxOption(30);
+      const option40 = await Pagination.getComboBoxOption(40);
+      const option50 = await Pagination.getComboBoxOption(50);
+      await option20.waitForDisplayed();
+      await option20.scrollIntoView();
+      await option40.waitForDisplayed();
+      await option40.scrollIntoView();
+      await option50.waitForDisplayed();
+      await option50.scrollIntoView();
+      await (await Pagination.getComboBoxOption(50)).waitForClickable();
+      await Pagination.clickComboBoxItem(50);
+      const comboBoxValue = await Pagination.getComboBoxValue();
+      await expect(comboBoxValue).toContain('50');
+    });
+    it('05: should change the number of items showned on screen', async () => {
+      const rows = await Pagination.getRows();
+      await expect(rows).toEqual(50);
+    });
+  });
+
+  describe('PUI-2852 - Pagination, page number buttons behaviour', () => {
+    before('loading page', async () => {
+      await Pagination.open();
+    });
+    it('should be disabled Prev button and Next button enabled', async () => {
+      const prevBtn = await Pagination.getPrevButton();
+      const nextBtn = await Pagination.getNextButton();
+      await expect(prevBtn).not.toBeClickable();
+      await expect(nextBtn).toBeClickable();
+    });
+    it('should be correctly move to next page', async () => {
+      const actualPage = await Pagination.getPageSelected();
+      await (await Pagination.getNextButton()).click();
+      const pageSelected = await Pagination.getPageSelected();
+      await expect(pageSelected).toEqual((+actualPage + +'1').toString());
+    });
+    it('should be enabled Prev button and Next button enabled', async () => {
+      const prevBtn = await Pagination.getPrevButton();
+      const nextBtn = await Pagination.getNextButton();
+      await expect(prevBtn).toBeClickable();
+      await expect(nextBtn).toBeClickable();
+    });
+    it('should be correctly move to prev page', async () => {
+      const actualPage = await Pagination.getPageSelected();
+      await (await Pagination.getPrevButton()).click();
+      const pageSelected = await Pagination.getPageSelected();
+      await expect(pageSelected).toEqual((+actualPage - +'1').toString());
+    });
+    it('should be correctly move to last page', async () => {
+      await Pagination.goToPage(10);
+      const pageSelected = await Pagination.getPageSelected(10);
+      await expect(pageSelected).toContain('10');
+    });
+    it('should be disabled Next button and Prev button enabled', async () => {
+      const prevBtn = await Pagination.getPrevButton();
+      const nextBtn = await Pagination.getNextButton();
+      await expect(prevBtn).toBeClickable();
+      await expect(nextBtn).not.toBeClickable();
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-pagination.visual.spec.js

@@ -0,0 +1,30 @@
+import Pagination from './page-objects/Pagination.componentObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-2853 - Pagination, visual tests', () => {
+    beforeEach('loading page', async () => {
+      await Pagination.open();
+    });
+    it('should display default Pagination view', async () => {
+      await browser.eyesOpen();
+      const snapshot = await browser.eyesCheckSnapshot(Pagination.snapshotPath('datagrid--pagination-default'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display combobox correctly', async () => {
+      await browser.eyesOpen();
+      await Pagination.opeComboBox();
+      await (await Pagination.getComboBoxOption(20)).scrollIntoView();
+      await Pagination.clickComboBoxItem(20);
+      await Pagination.opeComboBox();
+      await (await Pagination.getComboBoxMenu()).waitForDisplayed();
+      const snapshot = await browser.eyesCheckSnapshot(Pagination.snapshotPath('datagrid--pagination-combobox'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display lastpage correctly', async () => {
+      await browser.eyesOpen();
+      await Pagination.goToPage(10);
+      const snapshot = await browser.eyesCheckSnapshot(Pagination.snapshotPath('datagrid--pagination-lastpage'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-performance.func.spec.js

@@ -0,0 +1,23 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-6161 - DataGrid, Performance scrolling', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.performanceURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('after scrolling you should see more items', async () => {
+      await (await DG.getRowVirtulizedIndex(1)).moveTo();
+      const spanDev14 = await $('span*=Developer 14');
+      await spanDev14.scrollIntoView();
+      const spanDev25 = await $('span*=Developer 25');
+      await spanDev25.scrollIntoView();
+      const spanDev35 = await $('span*=Developer 35');
+      await spanDev35.scrollIntoView();
+      const spanDev50 = await $('span*=Developer 50');
+      await spanDev50.scrollIntoView();
+      const spanDev60 = await $('span*=Developer 60');
+      await expect(spanDev60).toBeDisplayed();
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-selectable-multi.func.spec.js

@@ -0,0 +1,21 @@
+import DG from './DatagridObject';
+import { shifKeyDown, shiftKeyUp } from '../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-4724 - DataGrid Multiselect using shift + click', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.selectableMulti.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should select more than one row', async () => {
+      await browser.releaseActions();
+      await (await DG.getCheckbox(1)).click();
+      await shifKeyDown();
+      await (await DG.getCheckbox(6)).click();
+      await shiftKeyUp();
+      await browser.releaseActions();
+      const checkedCheckBoxes = (await DG.getCheckboxesChecked()).length;
+      await expect(checkedCheckBoxes).toBe(6);
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-toolbar.visual.spec.js

@@ -0,0 +1,17 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-6228 - DataGrid, on scrolling toolbar should be sticky', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DG.performanceURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('toolbar should be sticky', async () => {
+      const target = await DG.getSortCell('empty', 0);
+      await target.scrollIntoView();
+      await target.waitForDisplayed();
+      const snapshot = await browser.checkSnapshot(DG.snapshotPath('datagrid-toolbar-sticky'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-virtualization-dynamic-rows.func.spec.js

@@ -0,0 +1,18 @@
+/* eslint-disable wdio/no-pause */
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-3855 - DataGrid, virtualization:: dynamic rows', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DG.virtualizationReRender.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('should add new rows dynamically', async () => {
+      await DG.addNewRows(20);
+      await (await DG.getRowIndex(19)).waitForDisplayed();
+      const newRows = await DG.getRowIndex(19);
+      await expect(newRows).toBeDisplayed();
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-virtualization.func.spec.js

@@ -0,0 +1,15 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-3811 - DataGrid virtualization autoscroll', () => {
+    beforeEach('loading page', async () => {
+      const errorOnGo = await DG.virtualization.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+
+    it('should display dg with 20 items scrolled to the bottom', async () => {
+      const rows = await DG.getRowIndex(19);
+      await expect(rows).toBeDisplayed();
+    });
+  });
+}

package/ds-datagrids/DSDatagrids-wrapping.visual.spec.js

@@ -0,0 +1,28 @@
+import DG from './DatagridObject';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-6162 - DataGrid, Toolbar with wrapping rules - Visual Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.wrappingRulesURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('checks toolbar button is vertically aligned', async () => {
+      await browser.eyesOpen();
+      await (await DG.getToolbarTrigger()).waitForDisplayed();
+      await (await DG.getToolbarTrigger()).click();
+      const snapshot = await browser.eyesCheckSnapshot(DG.snapshotPath('datagrid--wrapping-rules-toolbar-align'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-6217 - DataGrid, Wrapped text without pagination - Visual Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DG.pui6128.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display the datagrid properly with no pagination', async () => {
+      await browser.eyesOpen();
+      const snapshot = await browser.eyesCheckSnapshot(DG.snapshotPath('datagrids--wrapping-rules-no-pagination'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-datagrids/DatagridObject.js

@@ -0,0 +1,397 @@
+/* eslint-disable max-lines */
+/* eslint-disable import/no-relative-packages */
+import { Key } from 'webdriverio';
+import { PATH_END_OF_LIFE_DATA_GRID, PATH_E2E_DATA_GRID } from '../../environments/storybook/paths';
+import { DimsumConfig, PageObject, Urlbuilder, getElementByIndex } from '../helpers';
+
+const classPrefix = DimsumConfig.classNamePrefix;
+
+export default class DataGridObject extends PageObject {
+  static filterableForDatesURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'filterable-for-dates');
+
+  static wrappingRulesURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'wrapping-rules');
+
+  static performanceURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'performance');
+
+  static infiniteScrollURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'infinite-scrolling');
+
+  static customCellEditDatePickerURL = new Urlbuilder(PATH_E2E_DATA_GRID, 'custom-cell-edit-date-picker');
+
+  static basic = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'basic');
+
+  static headerURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'header');
+
+  static filterableURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'filterable');
+
+  static filterableDefaultFiltersURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'filterable-default-filters');
+
+  static editableURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'single-range');
+
+  static emptyStateURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'empty-state');
+
+  static expandableRowURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'expandable-row');
+
+  static selectableMultiURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'selectable-multi');
+
+  static selectableMultiFirstRowSelectedURL = new Urlbuilder(
+    PATH_END_OF_LIFE_DATA_GRID,
+    'selectable-multi-first-row-selected',
+  );
+
+  static selectableFirstRowSelectedURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'selectable-first-row-selected');
+
+  static virtualizationReRender = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-3452-new-rows');
+
+  static sortableEmpty = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'sortable-empty-last');
+
+  static sortableURL = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'sortable');
+
+  static virtualization = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'virtualized');
+
+  static sortablePUI4017 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-4017');
+
+  static cellRenders = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'cell-renderers');
+
+  static allFeatures = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'all-features');
+
+  static pui3865 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-3865');
+
+  static pui4416 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-4416');
+
+  static pui4552 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-4552');
+
+  static pui5276 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-5276');
+
+  static pui5604 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-5604');
+
+  static pui6128 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-6128-wrap-text-not-paginated');
+
+  static selectableMulti = new Urlbuilder(PATH_END_OF_LIFE_DATA_GRID, 'selectable-multi');
+
+  static pui2553 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-2553-editable-tabs');
+
+  static pui5098 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-5098-a');
+
+  static pui5550 = new Urlbuilder(PATH_E2E_DATA_GRID, 'pui-5550');
+
+  // Snapshots
+  static snapshotPath(example = 'editable') {
+    return PageObject.getSnapshotPathBuilder('DSDataGrid', example, 'ds-datagrids');
+  }
+
+  static async getGrid() {
+    return $('.em-ds-data-grid');
+  }
+
+  static async getFilterHeader(text) {
+    return $(`//div[contains(@data-testid,"data-grid-header__cell")]//span[contains(text(),"${text}")]`);
+  }
+
+  static async getPickerButton(index) {
+    return $$('[data-testid="data-grid-filter-header__button"]')[index];
+  }
+
+  static async getFilterMultiSelectMenu() {
+    return $('[data-testid="em-ds-menu"]');
+  }
+
+  static async getMenuOption(text) {
+    return $(`//li[contains(@role,"menuitemcheckbox")]//span[contains(text(),"${text}")]`);
+  }
+
+  static async getDateSingleRangeWrapper() {
+    return $('[data-testid="date-single-range__wrapper"]');
+  }
+
+  static async getDateSingleWrapper() {
+    return $('[data-testid="date-single__wrapper"]');
+  }
+
+  static async getDateRangeWrapper() {
+    return $('[data-testid="date-range__wrapper"]');
+  }
+
+  static async getPillTitle() {
+    return $('[data-testid="pill-title"]');
+  }
+
+  static async getPillTitles(index) {
+    return $$('[data-testid="pill-title"]')[index];
+  }
+
+  static async getRemovablePill() {
+    return $('[data-testid="removable-pill"]');
+  }
+  // eslint-disable-next-line max-lines
+
+  static async getRemovablePills(index) {
+    return $$('[data-testid="removable-pill"]')[index];
+  }
+
+  static async getRemovablePillButton(index) {
+    return $$('[data-testid="remove-pill-button"]')[index];
+  }
+
+  static async getCalendarDay(day) {
+    return $$(`//div[text()="${day}"]`)[1];
+  }
+
+  static async getCalendarDayV2(day) {
+    return $(`//button[@data-testid="ds-controlled-date-time-picker-calendar-day" ][contains(text(), "${day}")]`);
+  }
+
+  static async getCalendarBG(day) {
+    const background = await (await $$(`[data-testid="datepicker-day-${day}"]`)[1]).getCSSProperty('background-color');
+    return background.parsed.hex;
+  }
+
+  static async getCalendarBGsV2() {
+    const backgroundStart = await (await (await $('.startRangeDay')).$('button')).getCSSProperty('background-color');
+    const backgroundEnd = await (await (await $('.endRangeDay')).$('button')).getCSSProperty('background-color');
+    return [backgroundStart.parsed.hex, backgroundEnd.parsed.hex];
+  }
+
+  static async getStartDate(date) {
+    return (await $('[data-testid="start-date"]')).$(`[data-testid="${date}"]`);
+  }
+
+  static async getEndDate(date) {
+    return (await $('[data-testid="end-date"]')).$(`[data-testid="${date}"]`);
+  }
+
+  static async getStartDateV2(date) {
+    const elems = await $$(`[data-testid="ds-controlled-date-time-picker-${date}-input"]`);
+    return elems[0];
+  }
+
+  static async getEndDateV2(date) {
+    const elems = await $$(`[data-testid="ds-controlled-date-time-picker-${date}-input"]`);
+    return elems[1];
+  }
+
+  static async getDateSwitchHeader() {
+    return $('[data-testid="date-switch-header"]');
+  }
+
+  static async getRangeButton() {
+    return $('[data-testid="ds-checkbox-label"]');
+  }
+
+  static async setStartDate(date) {
+    await (await DataGridObject.getStartDate('month')).setValue(date.slice(0, 2));
+    await (await DataGridObject.getStartDate('day')).setValue(date.slice(2, 4));
+    await (await DataGridObject.getStartDate('year')).setValue(date.slice(4, 8));
+  }
+
+  static async setEndDate(date) {
+    await (await DataGridObject.getEndDate('month')).setValue(date.slice(0, 2));
+    await (await DataGridObject.getEndDate('day')).setValue(date.slice(2, 4));
+    await (await DataGridObject.getEndDate('year')).setValue(date.slice(4, 8));
+  }
+
+  static async setStartDateV2(date) {
+    await (await DataGridObject.getStartDateV2('month')).setValue(date.slice(0, 2));
+    await (await DataGridObject.getStartDateV2('day')).setValue(date.slice(2, 4));
+    await (await DataGridObject.getStartDateV2('year')).setValue(date.slice(4, 8));
+  }
+
+  static async setEndDateV2(date) {
+    await (await DataGridObject.getEndDateV2('month')).setValue(date.slice(0, 2));
+    await (await DataGridObject.getEndDateV2('day')).setValue(date.slice(2, 4));
+    await (await DataGridObject.getEndDateV2('year')).setValue(date.slice(4, 8));
+  }
+
+  static async getDateSeted(param) {
+    if (param === 'start') {
+      const day = await (await DataGridObject.getStartDate('day')).getValue();
+      const month = await (await DataGridObject.getStartDate('month')).getValue();
+      const year = await (await DataGridObject.getStartDate('year')).getValue();
+      return `${month}/${day}/${year}`;
+    }
+    if (param === 'end') {
+      const day = await (await DataGridObject.getEndDate('day')).getValue();
+      const month = await (await DataGridObject.getEndDate('month')).getValue();
+      const year = await (await DataGridObject.getEndDate('year')).getValue();
+      return `${month}/${day}/${year}`;
+    }
+    return false;
+  }
+
+  static async getDateSetedV2(param) {
+    if (param === 'start') {
+      const day = await (await DataGridObject.getStartDateV2('day')).getValue();
+      const month = await (await DataGridObject.getStartDateV2('month')).getValue();
+      const year = await (await DataGridObject.getStartDateV2('year')).getValue();
+      return `${month}/${day}/${year}`;
+    }
+    if (param === 'end') {
+      const day = await (await DataGridObject.getEndDateV2('day')).getValue();
+      const month = await (await DataGridObject.getEndDateV2('month')).getValue();
+      const year = await (await DataGridObject.getEndDateV2('year')).getValue();
+      return `${month}/${day}/${year}`;
+    }
+    return false;
+  }
+
+  static getPillClear = async (index) => {
+    const csP = classPrefix;
+    return $$(`.${csP}-filter-bar .${csP}-pill-group .${csP}-pill--value .${csP}-pill__addon`)[index];
+  };
+
+  static getHeaderCell = async (index) => $(`.${classPrefix}-data-grid-header__cell:nth-child(${index})`);
+
+  static getRows = async () => $$('[data-testid="datagrid-row"]');
+
+  static getRowIndex = async (index) => getElementByIndex(this.getRows, index);
+
+  static getRowVirtulizedIndex = async (index) => $(`[rowindex="${index}"]`);
+
+  static async getCellIndexInRow(rowIndex, cellIndex) {
+    const $row = await DataGridObject.getRowIndex(rowIndex);
+    await $row.waitForDisplayed();
+    return $row.$(`.${classPrefix}-data-grid-body__cell:nth-child(${cellIndex})`);
+  }
+
+  static async getDatePickerBtn(buttonnIndex) {
+    return browser.waitUntil(
+      async () => {
+        const pickerButton = await $$('[data-testid="btn-date-picker"]');
+        return pickerButton.length > buttonnIndex ? pickerButton[buttonnIndex] : false;
+      },
+      {
+        timeout: 5000,
+        timeoutMsg: 'picker button not shown adter 3 seconds',
+      },
+    );
+  }
+
+  static async getAddRowBtn() {
+    return $('[data-testid="btn-new-row"]');
+  }
+
+  static async addNewRows(rows) {
+    const btn = await this.getAddRowBtn();
+    for (let i = 0; i < rows; i += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await btn.click();
+    }
+  }
+
+  static async getSearchBtn() {
+    return $('[data-testid="ds-searchbox-button"]');
+  }
+
+  static async getFilterBtn() {
+    return $('[data-testid="button-wrapper"]');
+  }
+
+  static async getFilterBtns(index) {
+    return $$('[data-testid="button-wrapper"]')[index];
+  }
+
+  static async getListMenu() {
+    return $('[data-testid="em-ds-menu"]');
+  }
+
+  static async getComboboxTextInput() {
+    return $('[data-testid="combobox"] input');
+  }
+
+  static async getComboBoxOption(index) {
+    return $$('[data-testid="combobox-option"]')[index];
+  }
+
+  static async getFilterBar() {
+    return $('[data-testid="em-ds-filter-bar"]');
+  }
+
+  static async getComboBoxOptionsCount() {
+    return (await $$('[role="menuitemcheckbox"]')).length;
+  }
+
+  static async getMenuCheckBox(index) {
+    return $$('[data-testid="ds-checkbox"]')[index];
+  }
+
+  static async getExpandableBtn(index) {
+    return $$('[data-testid="button-wrapper"]')[index];
+  }
+
+  static async getToolbarTrigger() {
+    return $('[data-testid="toolbar-trigger"]');
+  }
+
+  static async getDataGridHeader(index) {
+    return $$('[data-testid="data-grid-header__cell"]')[index];
+  }
+
+  static async getColumnDate(index) {
+    return $$('[data-testid="column-date"]')[index];
+  }
+
+  static async getInputField(index) {
+    if (index) return $$('[data-testid="ds-input_main-component"]')[index];
+
+    return $('[data-testid="ds-input_main-component"]');
+  }
+
+  static async getColumnName(index) {
+    return $$('[data-testid="column-name"]')[index];
+  }
+
+  static async getColumnLength() {
+    return $$('[data-testid="column-name"]').length;
+  }
+
+  static async getCheckbox(index) {
+    return $$('[data-testid="column-selectable-component"]')[index];
+  }
+
+  static async getRadioButton(index) {
+    return $$('[data-testid="column-selectable-component"] + span')[index];
+  }
+
+  static async getCheckboxesChecked() {
+    return $$('//span[@data-testid="column-selectable-component"][@aria-checked="true"]');
+  }
+
+  static async getCells(column) {
+    return $$(`//div[@data-testid="column-${column}"]`);
+  }
+
+  static async getCell(column, index) {
+    return $$(`//div[@data-testid="column-${column}"]/div`)[index];
+  }
+
+  static async getSortCell(column, index) {
+    return $$(`//div[@data-testid="column-${column}"]/span`)[index];
+  }
+
+  static async getClickMeBtn() {
+    return $('//button[@aria-label="Click Me"]');
+  }
+
+  static async clearField(column, index) {
+    const cell = await this.getCell(column, index);
+    const len = (await cell.getText()).length;
+    await cell.click();
+    for (let i = 0; i <= len; i += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await browser.keys(Key.Backspace);
+    }
+  }
+
+  static async sendVal(data) {
+    for (let i = 0; i <= data.length; i += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await browser.keys(data.charAt(i));
+    }
+  }
+
+  static async openFilterMenu(header) {
+    await (await this.getFilterHeader(header)).moveTo();
+    await (await this.getFilterHeader(header)).click();
+    await (await this.getPickerButton(0)).waitForDisplayed();
+    await (await this.getPickerButton(0)).click();
+  }
+}