dimsum-e2e-tests 1.0.0-rc.1

package/ds-treeview/TreeView-dnd.func.spec.js

@@ -0,0 +1,104 @@
+/* eslint-disable wdio/no-pause */
+import { Key } from 'webdriverio';
+import DSTreeViewCO from './DSTreeViewCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-3673 - TreeView DnD::', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.v2RectrictedDndURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should not drag and drop items/folders to different folder if restricDragAndDrop is enabled', async () => {
+      await (await DSTreeViewCO.getToggleBtn(0)).click();
+      await (await DSTreeViewCO.getToggleBtn(2)).click();
+      const target = await $('[data-id="6"]');
+      await (await DSTreeViewCO.getDragHandle(2)).dragAndDrop(target);
+      const row = await DSTreeViewCO.getRow(5);
+      await expect(row).not.toEqual(await $('[data-id="6"]'));
+    });
+  });
+  describe('PUI-6744 - TreeView, DnD dragged item in callback', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.v2DndURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should return the dragged item as the 3rd param of the onOrdeChange callback', async () => {
+      await (await DSTreeViewCO.getDragHandle(0)).dragAndDrop((await DSTreeViewCO.getRows())[3]);
+      await DSTreeViewCO.expandCollapseAll();
+      const draggedItem = await DSTreeViewCO.getRow(5);
+      await expect(draggedItem).toHaveTextContaining('1');
+    });
+  });
+  if (browser.capabilities.browserName !== 'Safari') {
+    describe('PUI-8198 - TreeView, DnD first position with keyboard', () => {
+      before(async () => {
+        const errorOnGo = await DSTreeViewCO.v2DndURL.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should correctly drag an item to the first position with keyboard', async () => {
+        const rowToDrag = await DSTreeViewCO.getRow(2);
+        await rowToDrag.click();
+        await browser.keys(Key.Tab);
+        await browser.keys(Key.Space);
+        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.Space);
+        const firstRow = await DSTreeViewCO.getRow(0);
+        await expect(firstRow).toHaveTextContaining('7');
+      });
+    });
+  }
+  describe('PUI-11320 - TreeView, Basic Drag and Drop Functionality', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.dragAndDrop.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: drag and drop in the same position - parent item', async () => {
+      const firstRow = await DSTreeViewCO.getRow(0);
+      const dragHandleFirstRow = await DSTreeViewCO.getDragHandle(0);
+      await dragHandleFirstRow.dragAndDrop(firstRow);
+      await expect(firstRow).toHaveTextContaining('Parent. id: 1');
+    });
+    it('02: drag and drop in the same position - child item', async () => {
+      const expandableBtnFirstRow = await DSTreeViewCO.getToggleBtn(0);
+      await expandableBtnFirstRow.click();
+      const firstChildRow = await DSTreeViewCO.getRow(1);
+      const dragHandleFirstChild = await DSTreeViewCO.getDragHandle(1);
+      await dragHandleFirstChild.dragAndDrop(firstChildRow);
+      await expect(firstChildRow).toHaveTextContaining('Child of 1. id: 2');
+    });
+    it('03: drag a parent and drop it in another parent', async () => {
+      const parentId4 = await DSTreeViewCO.getRow(3);
+      const dragHandleParentId1 = await DSTreeViewCO.getDragHandle(0);
+      await dragHandleParentId1.dragAndDrop(parentId4);
+      await DSTreeViewCO.expandCollapseAll();
+      const firstRow = await DSTreeViewCO.getRow(0);
+      await expect(firstRow).toHaveTextContaining('Parent. id: 4');
+    });
+    it('04: drag a child of a parent and drop it in another parent with no children', async () => {
+      const dragHandleChildOfParent1 = await DSTreeViewCO.getDragHandle(5);
+      const parentId7 = await DSTreeViewCO.getRow(8);
+      await dragHandleChildOfParent1.dragAndDrop(parentId7);
+      await browser.pause(300);
+      await DSTreeViewCO.expandCollapseAll();
+      const sixthRow = await DSTreeViewCO.getRow(6);
+      await sixthRow.waitForExist();
+      await expect(sixthRow).toHaveTextContaining('Child of 1. Also parent. id: 3');
+    });
+    it('05: drag a parent and drop it into last row', async () => {
+      const parentId8 = await DSTreeViewCO.getRow(9);
+      const dragHandleParentId4 = await DSTreeViewCO.getDragHandle(0);
+      await dragHandleParentId4.dragAndDrop(parentId8);
+      await browser.pause(500);
+      const expandableBtnLastRow = await DSTreeViewCO.getToggleBtn(1);
+      await expandableBtnLastRow.click();
+      await DSTreeViewCO.expandCollapseAll();
+      const parentId4 = await DSTreeViewCO.getRow(5);
+      await parentId4.waitForExist();
+      await expect(parentId4).toHaveTextContaining('Parent. id: 4');
+    });
+  });
+}

package/ds-treeview/TreeView-dnd.visual.spec.js

@@ -0,0 +1,41 @@
+/* eslint-disable wdio/no-pause */
+import { Key } from 'webdriverio';
+import DSTreeViewCO from './DSTreeViewCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-11324 - TreeView, Restrict Drag and Drop Functionality - visual', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.restrictDragAndDropTest.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display "in between" position allowed correctly', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Return);
+      await DSTreeViewCO.expandCollapseAll();
+      const snapshot = await browser.eyesCheckSnapshot(
+        DSTreeViewCO.snapshotPath('treeview-restict-dnd-in-between-allowed'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+    it('02: should display "inside" position restricted correctly', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.ArrowDown);
+      const snapshot = await browser.eyesCheckSnapshot(
+        DSTreeViewCO.snapshotPath('treeview-restict-dnd-inside-restricted'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+    it('03: drag a parent and drop it in another parent', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.ArrowDown);
+      const snapshot = await browser.eyesCheckSnapshot(
+        DSTreeViewCO.snapshotPath('treeview-restict-dnd-between-restricted'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-treeview/TreeView-expand-collapse.func.spec.js

@@ -0,0 +1,96 @@
+import DSTreeViewCO from './DSTreeViewCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-3605 - TreeView expand/collapse should not lose focus', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.pui3504URL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should not lose active state when scrolling using the expand/collapse all hotkey', async () => {
+      await DSTreeViewCO.expandCollapseAll();
+      const collapsedRow = await DSTreeViewCO.getRowByContent('Occaecat reprehenderit minim anim eiusmod tempor');
+      const collapsedRow2 = await DSTreeViewCO.getRowByContent('Nostrud amet ad eu duis ullamco');
+      const collapsedRow3 = await DSTreeViewCO.getRowByContent('Nulla ipsum est nulla labore enim');
+      await collapsedRow.waitForDisplayed();
+      await collapsedRow.scrollIntoView();
+      await collapsedRow2.waitForDisplayed();
+      await collapsedRow2.scrollIntoView();
+      await collapsedRow3.waitForDisplayed();
+      await collapsedRow3.scrollIntoView();
+      await DSTreeViewCO.expandCollapseAll();
+      const mySpan = await DSTreeViewCO.getRowByContent('Underwriting');
+      await expect(mySpan).toBeDisplayed();
+    });
+  });
+  describe('PUI-3438 - Treeview fluid keyboard', () => {
+    beforeEach(async () => {
+      const errorOnGo = await DSTreeViewCO.fluidHeightURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should expand/collapse all records with the keyboard', async () => {
+      await (await DSTreeViewCO.getRow(0)).click();
+      await DSTreeViewCO.expandCollapseAll();
+      const row = await DSTreeViewCO.getRowByContent('Test Item 1');
+      await expect(row).not.toBeDisplayedInViewport();
+      await DSTreeViewCO.expandCollapseAll();
+      await expect(row).toBeDisplayed();
+    });
+    it('should expand/collapse all records with the keyboard and not lose active state', async () => {
+      await (await DSTreeViewCO.getRowByContent('Test Folder Y')).click();
+      await DSTreeViewCO.expandCollapseAll();
+      const row = await DSTreeViewCO.getRowByContent('Test Item 1');
+      await expect(row).not.toBeDisplayedInViewport();
+      await DSTreeViewCO.expandCollapseAll();
+      const is5active = await DSTreeViewCO.isActive(5);
+      await expect(is5active).toEqual(true, 'The element was not active');
+    });
+  });
+  describe('PUI-3936 - TreeView expanding behavior', () => {
+    describe('unfrozen data', () => {
+      before(async () => {
+        const errorOnGo = await DSTreeViewCO.pui3504URL.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('01: should display nested item collapsed', async () => {
+        const toggleBtn = await DSTreeViewCO.getToggleBtn(1);
+        await toggleBtn.waitForDisplayed();
+        await toggleBtn.click();
+        const mySpan = await DSTreeViewCO.getRowByContent('A very large nested');
+        await mySpan.waitForDisplayed();
+        const is2expanded = await DSTreeViewCO.isExpanded(2);
+        await expect(is2expanded).toBe('false');
+      });
+    });
+    describe('frozen data', () => {
+      before(async () => {
+        const errorOnGo = await DSTreeViewCO.frozenData.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should display nested item collapsed', async () => {
+        await (await DSTreeViewCO.getRow(0)).waitForDisplayed();
+        let rowsLenght = (await DSTreeViewCO.getRows()).length;
+        await expect(rowsLenght).toBe(4);
+        await DSTreeViewCO.expandCollapseAll();
+        rowsLenght = (await DSTreeViewCO.getRows()).length;
+        await expect(rowsLenght).toBe(10);
+      });
+    });
+  });
+  describe('PUI-5156 - TreeView Collapse/expand all using buttons', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.controlled.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('All the items are expanded', async () => {
+      await (await DSTreeViewCO.getExpandBtn()).waitForDisplayed();
+      await (await DSTreeViewCO.getExpandBtn()).click();
+      const rowsLenght = (await DSTreeViewCO.getRows()).length;
+      await expect(rowsLenght).toBe(10);
+    });
+    it('All the items are collapsed', async () => {
+      await (await DSTreeViewCO.getCollapseBtn()).click();
+      const rowsLenght = (await DSTreeViewCO.getRows()).length;
+      await expect(rowsLenght).toBe(4);
+    });
+  });
+}

package/ds-treeview/TreeView-right-addon.func.spec.js

@@ -0,0 +1,80 @@
+import { Key } from 'webdriverio';
+import DSTreeViewCO from './DSTreeViewCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-10696 - TreeView: Right Addons As Component::', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.rightAddonsAsComponent.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: the counter value should initially be 0', async () => {
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      await expect(testCounter).toHaveTextContaining('0');
+    });
+    it('02: the counter value should increase by 1 - Click', async () => {
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      const rightAddon = await DSTreeViewCO.getRightAddonsByIndex(0);
+      await rightAddon.click();
+      await expect(testCounter).toHaveTextContaining('1');
+    });
+    it('03: the counter value should increase by 1 - Enter', async () => {
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Tab);
+      await browser.keys(Key.Enter);
+      await expect(testCounter).toHaveTextContaining('2');
+    });
+    it('04: The counter value should increase by 1 - Expanded (Click)', async () => {
+      await DSTreeViewCO.expandCollapseAll();
+      const fifthRightAddon = await DSTreeViewCO.getRightAddonsByIndex(5);
+      const sixthRightAddon = await DSTreeViewCO.getRightAddonsByIndex(6);
+      await sixthRightAddon.click();
+      await fifthRightAddon.click();
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      await expect(testCounter).toHaveTextContaining('4');
+    });
+    it('05: The counter value should increase by 1 - Expanded (Enter)', async () => {
+      if (browser.capabilities.browserName === 'Safari') {
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys(Key.Enter);
+      } else {
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys([Key.Shift, Key.Tab]);
+        await browser.keys(Key.Enter);
+      }
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      await expect(testCounter).toHaveTextContaining('5');
+    });
+    it('06: the counter value should not change when a tree item is clicked', async () => {
+      const firstCheckbox = await DSTreeViewCO.getCheckbox(0);
+      await firstCheckbox.click();
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      await expect(testCounter).toHaveTextContaining('5');
+    });
+    it('07: the counter value should not change when [Enter] is pressed on a tree item.', async () => {
+      if (browser.capabilities.browserName === 'Safari') {
+        await browser.keys(Key.Tab);
+        await browser.keys(Key.Tab);
+        await browser.keys(Key.Tab);
+        await browser.keys(Key.Enter);
+      } else {
+        await browser.keys(Key.Tab);
+        await browser.keys(Key.Tab);
+        await browser.keys(Key.Enter);
+      }
+      const testCounter = await DSTreeViewCO.getTestCounter();
+      await expect(testCounter).toHaveTextContaining('5');
+    });
+  });
+}

package/ds-treeview/TreeView-search.func.spec.js

@@ -0,0 +1,138 @@
+/* eslint-disable max-lines */
+import { type } from '../helpers';
+import DSTreeViewCO from './DSTreeViewCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-3820 - Treeview searchable', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.searchableV2.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should scroll to top when searching', async () => {
+      await DSTreeViewCO.expandCollapseAll();
+      const row = await DSTreeViewCO.getRowByContent('Exercitation ad pariatur');
+      await expect(row).toBeDisplayed();
+      await row.scrollIntoView();
+      await (await DSTreeViewCO.getSearchBox()).setValue('labore');
+      const rowByContent = await DSTreeViewCO.getRowByContent('30 Childrens');
+      await expect(rowByContent).toBeDisplayed();
+    });
+    it('02: should display empty state when no items found', async () => {
+      await (await DSTreeViewCO.getSearchBox()).click();
+      await type('s');
+      const noItems = await DSTreeViewCO.noItemsFound();
+      await expect(noItems).toBeDisplayed();
+    });
+    it('03: should display all after clear searchbox', async () => {
+      await DSTreeViewCO.clearField();
+      const row = await DSTreeViewCO.getRowByContent('Underwriting');
+      await expect(row).toBeDisplayed();
+    });
+  });
+  describe('PUI-4833 - Treeview searchable - nav bar', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.searchableWithNav.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display results at the top', async () => {
+      await (await DSTreeViewCO.getSearchBoxInput()).waitForDisplayed();
+      const searchBoxInput = await DSTreeViewCO.getSearchBoxInput();
+      await searchBoxInput.click();
+      await type('test');
+      await (await DSTreeViewCO.getRowByContent('A very large')).waitForDisplayed();
+      const rows = await DSTreeViewCO.getRows();
+      await expect(rows).toHaveLength(3);
+    });
+    it('02: should display selected result items', async () => {
+      const resultItems = await DSTreeViewCO.getResultItems(1, 3);
+      const textMarkLenght = (await DSTreeViewCO.getTextMarks('test')).length;
+      const isActive = await DSTreeViewCO.isActive(0);
+      await expect(resultItems).toBeDisplayed();
+      await expect(textMarkLenght).toBe(3);
+      await expect(isActive).toBe(true);
+    });
+    it('03: should navigate throw items - next', async () => {
+      await (await DSTreeViewCO.getNextBtn()).click();
+      const resultItems = await DSTreeViewCO.getResultItems(2, 3);
+      const textMarkLenght = (await DSTreeViewCO.getTextMarks('test')).length;
+      const isActive = await DSTreeViewCO.isActive(1);
+      await expect(resultItems).toBeDisplayed();
+      await expect(textMarkLenght).toBe(3);
+      await expect(isActive).toBe(true);
+    });
+    it('04: should navigate throw items - last', async () => {
+      await (await DSTreeViewCO.getNextBtn()).click();
+      const resultItems = await DSTreeViewCO.getResultItems(3, 3);
+      const textMarkLenght = (await DSTreeViewCO.getTextMarks('test')).length;
+      const isActive = await DSTreeViewCO.isActive(2);
+      await expect(resultItems).toBeDisplayed();
+      await expect(textMarkLenght).toBe(3);
+      await expect(isActive).toBe(true);
+    });
+    it('05: should return to first items', async () => {
+      await (await DSTreeViewCO.getPrevBtn()).click();
+      await (await DSTreeViewCO.getPrevBtn()).click();
+      const resultItems = await DSTreeViewCO.getResultItems(1, 3);
+      const textMarkLenght = (await DSTreeViewCO.getTextMarks('test')).length;
+      const isActive = await DSTreeViewCO.isActive(0);
+      await expect(resultItems).toBeDisplayed();
+      await expect(textMarkLenght).toBe(3);
+      await expect(isActive).toBe(true);
+    });
+    it('06: should clear all results', async () => {
+      await (await DSTreeViewCO.getClearBtn()).click();
+      const resultItems = await DSTreeViewCO.getResultItems(1, 3);
+      const textMark = await DSTreeViewCO.getTextMarks('test');
+      const isActive = await DSTreeViewCO.isActive(0);
+      await expect(resultItems).not.toBeDisplayed();
+      await expect(textMark).not.toBeDisplayed();
+      await expect(isActive).toBe(false);
+      const row = await DSTreeViewCO.getRowByContent('Underwriting');
+      await expect(row).toBeDisplayed();
+    });
+    it('07: should display no items found msg', async () => {
+      const searchBoxInput = await DSTreeViewCO.getSearchBoxInput();
+      await searchBoxInput.click();
+      await type('tests');
+      const resultItems = await DSTreeViewCO.getResultItems(1, 3);
+      const noItems = await DSTreeViewCO.noItemsFound();
+      await expect(resultItems).not.toBeDisplayed();
+      await expect(noItems).toBeDisplayed();
+      await (await DSTreeViewCO.getClearBtn()).click();
+    });
+    it('08: should clear all results [Backspace]', async () => {
+      const searchBoxInput = await DSTreeViewCO.getSearchBoxInput();
+      await searchBoxInput.click();
+      await type('test');
+      await (await DSTreeViewCO.getRowByContent('A very large')).waitForDisplayed();
+      const textMark = await DSTreeViewCO.getTextMark('test');
+      await expect(textMark).toBeDisplayed();
+      await DSTreeViewCO.triggerBackspace(4);
+      const resultItems = await DSTreeViewCO.getResultItems(1, 3);
+      await expect(resultItems).not.toBeDisplayed();
+      await expect(textMark).not.toBeDisplayed();
+      const isActive = await DSTreeViewCO.isActive(0);
+      const row = await DSTreeViewCO.getRowByContent('Underwriting');
+      await expect(isActive).toBe(false);
+      await expect(row).toBeDisplayed();
+    });
+  });
+  describe('PUI-5446 - Treeview highlight only search', () => {
+    before(async () => {
+      const errorOnGo = await DSTreeViewCO.searchableV2HighlightOnly.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display all result even with a query', async () => {
+      const searchBoxInput = await DSTreeViewCO.getSearchBoxInput();
+      await searchBoxInput.click();
+      await type('test');
+      const textMark = await DSTreeViewCO.getTextMark('test');
+      await expect(textMark).toBeDisplayed();
+      // eslint-disable-next-line max-len
+      const highlightedTexts = await DSTreeViewCO.getHighligthedTexts();
+      const rows = await DSTreeViewCO.getRows();
+      await expect(highlightedTexts).toHaveLength(3); // only 3 matches with "test" query are highlighted
+      await expect(rows).toHaveLength(23); // this is 24 because it's virtualized...
+    });
+  });
+}