dimsum-e2e-tests 1.0.0-rc.1

package/ds-controlled-form/ds-controlled-radio/DSControlledRadio.func.spec.js

@@ -0,0 +1,64 @@
+import { Key } from 'webdriverio';
+import DSControlledRadioCO from './DSControlledRadioCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-11697 - DSControlledRadio - Basic selection  -Func.', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.formLayoutBlockItem.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should not select first radio button by clicking outside clickable area', async () => {
+      const radioLabel = await DSControlledRadioCO.getRadioLabelByIndex(0);
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      await radioLabel.click({ x: 70 });
+      await expect(await DSControlledRadioCO.isChecked(radio)).toBe(false);
+    });
+    it('02: should select first radio button by clicking on clickable area', async () => {
+      const radioLabel = await DSControlledRadioCO.getRadioLabelByIndex(0);
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      await radioLabel.click();
+      await expect(await DSControlledRadioCO.isChecked(radio)).toBe(true);
+    });
+  });
+
+  describe('PUI-11976 - DSControlledRadio - Basic keyboard selection  -Func.', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.formLayoutBlockItem.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should have bottom radio selected by default', async () => {
+      const radioTop = await DSControlledRadioCO.getRadioByIndex(0);
+      const radioBottom = await DSControlledRadioCO.getRadioByIndex(1);
+      await browser.keys(Key.Tab);
+      await expect(await DSControlledRadioCO.isChecked(radioTop)).toBe(false);
+      await expect(await DSControlledRadioCO.isChecked(radioBottom)).toBe(true);
+    });
+    // Safari has specific behavior agains focus trap in this scenario
+    it('02: should move the pseudo focus and selection to upper radio using the focus trap', async () => {
+      const radioTop = await DSControlledRadioCO.getRadioByIndex(0);
+      const radioBottom = await DSControlledRadioCO.getRadioByIndex(1);
+      if (browser.capabilities.browserName !== 'Safari') {
+        await browser.keys(Key.ArrowDown);
+      } else {
+        await browser.keys(Key.ArrowUp);
+      }
+      await expect(await DSControlledRadioCO.isChecked(radioTop)).toBe(true);
+      await expect(await DSControlledRadioCO.isChecked(radioBottom)).toBe(false);
+    });
+
+    it('03: should use arrowDown to move pseudo focus and selection to bottom radio', async () => {
+      const radioTop = await DSControlledRadioCO.getRadioByIndex(0);
+      const radioBottom = await DSControlledRadioCO.getRadioByIndex(1);
+      await browser.keys(Key.ArrowDown);
+      await expect(await DSControlledRadioCO.isChecked(radioTop)).toBe(false);
+      await expect(await DSControlledRadioCO.isChecked(radioBottom)).toBe(true);
+    });
+    it('04: should use arrowUp to move pseudo focus and selection to top radio', async () => {
+      const radioTop = await DSControlledRadioCO.getRadioByIndex(0);
+      const radioBottom = await DSControlledRadioCO.getRadioByIndex(1);
+      await browser.keys(Key.ArrowUp);
+      await expect(await DSControlledRadioCO.isChecked(radioTop)).toBe(true);
+      await expect(await DSControlledRadioCO.isChecked(radioBottom)).toBe(false);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-radio/DSControlledRadio.visual.spec.js

@@ -0,0 +1,96 @@
+import { Key } from 'webdriverio';
+import DSControlledRadioCO from './DSControlledRadioCO';
+import { mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8837 - DSControlledRadio - Visual Test - Basic styles', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.basic.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display basic radio styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(2);
+      const radio2 = await DSControlledRadioCO.getRadioByIndex(1);
+      await radio.click();
+      await mouseOver(radio2);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-basic'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should use ArrowDown to go back to the first radio after the last one, no focus', async () => {
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Tab);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-basic-firstchecked'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-8838 - DSControlledRadio - Visual Test - disabled', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.disabled.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display disabled radio styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      await radio.click();
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-disabled'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-8840 - DSControlledRadio - Visual Test - ReadOnly', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.readOnly.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display readonly radio styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      const radio2 = await DSControlledRadioCO.getRadioByIndex(1);
+      await radio.click();
+      await mouseOver(radio2);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-readonly'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display readonly radio different styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      const radio2 = await DSControlledRadioCO.getRadioByIndex(1);
+      await radio2.click();
+      await mouseOver(radio);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-readonly-bis'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-8839 - DSControlledRadio - Visual Test - HasError', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.hasError.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display hasError radio styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      const radio2 = await DSControlledRadioCO.getRadioByIndex(1);
+      await radio.click();
+      await mouseOver(radio2);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-haserror'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display hasError radio different styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      const radio2 = await DSControlledRadioCO.getRadioByIndex(1);
+      await radio2.click();
+      await mouseOver(radio);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-haserror-bis'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-8841 - DSControlledRadio - Visual Test - Form Layout Block', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSControlledRadioCO.formLayoutBlockItem.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display radio within formLayoutBlockItem styles correctly', async () => {
+      const radio = await DSControlledRadioCO.getRadioByIndex(0);
+      const radio2 = await DSControlledRadioCO.getRadioByIndex(1);
+      await radio.click();
+      await mouseOver(radio2);
+      const snapshot = await browser.checkSnapshot(DSControlledRadioCO.snapshotPath('radio-formlayoutblock'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-controlled-form/ds-controlled-radio/DSControlledRadioCO.js

@@ -0,0 +1,42 @@
+import { PATH_E2E_RADIO } from '../../../environments/storybook/paths';
+import { PageObject, Urlbuilder, getElementByIndex } from '../../helpers';
+
+export default class DSControlledRadioCO extends PageObject {
+  static basic = new Urlbuilder(PATH_E2E_RADIO, 'basic-test');
+
+  static formLayoutBlockItem = new Urlbuilder(PATH_E2E_RADIO, 'with-form-layout-block-item-test');
+
+  static hasError = new Urlbuilder(PATH_E2E_RADIO, 'has-error-test');
+
+  static disabled = new Urlbuilder(PATH_E2E_RADIO, 'disable-test');
+
+  static readOnly = new Urlbuilder(PATH_E2E_RADIO, 'read-only-test');
+
+  static async getRadio() {
+    return $('[data-testid="ds-radio"]');
+  }
+
+  static async getRadios() {
+    return $$('[data-testid="ds-radio"]');
+  }
+
+  static getRadioByIndex = async (index) => getElementByIndex(this.getRadios, index);
+
+  static async getRadioLabel() {
+    return $('[data-testid="ds-radio-label"]');
+  }
+
+  static async getRadioLabels() {
+    return $$('[data-testid="ds-radio-label"]');
+  }
+
+  static getRadioLabelByIndex = async (index) => getElementByIndex(this.getRadioLabels, index);
+
+  static async isChecked(checkBox) {
+    return checkBox.getProperty('checked');
+  }
+
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('DSControlledCheckbox', example, 'ds-controlled-radio');
+  }
+}

package/ds-controlled-form/ds-input-text/DSInputText.axe-core.func.spec.js

@@ -0,0 +1,86 @@
+/* eslint-disable max-lines */
+import { type, axeCoreCheck } from '../../helpers';
+import DSInputTextCO from './DSInputTextCO';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-11016 - DSControlledInputText: Basic Styles -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.stylesURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display all styles for input text and pass axecore scan', async () => {
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      await input1.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11017 - DSControlledInputText: Clearable -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.clearable.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should have clearable input without clearable btn and pass axecore scan', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should have clearable input with clearable btn and pass axecore scan', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.waitForDisplayed();
+      await input.click();
+      await type('Hola');
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11018 - DSControlledInputText: Autocomplete -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.autocompleteURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should have input with autocomplete menu and pass axecore scan', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await type('44');
+      const autocompleteOption = await DSInputTextCO.getAutocompleteOptionByIndex(1);
+      await autocompleteOption.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11019 - DSControlledInputText: FormLayoutBlockItem -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.formLayoutBlockURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display input text with formLayoutBlockItem and pass axecore scan', async () => {
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      await input1.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-11019 - DSControlledInputText: Disabled -AxeCore', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.disabledURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should display input text disabled and pass axecore scan', async () => {
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      await input1.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-controlled-form/ds-input-text/DSInputText.clearable.keyboard.func.spec.js

@@ -0,0 +1,45 @@
+/* eslint-disable max-len */
+import { Key } from 'webdriverio';
+import DSInputTextCO from './DSInputTextCO';
+import { type } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-8855 - DSControlledInputText - clearable - keyboard func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.clearable.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: input text should be focused', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await browser.keys(Key.Tab);
+      await expect(input).toBeFocused();
+    });
+    it('02: should display clear button when start typing', async () => {
+      await type('p');
+      const clearBtn = await DSInputTextCO.getClearBtn();
+      await expect(clearBtn).toBeDisplayed();
+    });
+    it('03: should not display clear button when input is empty', async () => {
+      const clearBtn = await DSInputTextCO.getClearBtn();
+      await browser.keys(Key.Backspace);
+      await expect(clearBtn).not.toBeDisplayed();
+    });
+    it('04: should type the input correctly', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await type('1t2e3s5t');
+      await expect(input).toHaveValueContaining('1t2e3s5t');
+    });
+    it('05: should focus the clear btn correctly', async () => {
+      const clearBtn = await DSInputTextCO.getClearBtn();
+      await browser.keys(Key.Tab);
+      await expect(clearBtn).toBeFocused();
+    });
+    it('06: should clear the content after hit Enter key', async () => {
+      await browser.keys(Key.Enter);
+      const clearBtn = await DSInputTextCO.getClearBtn();
+      const input = await DSInputTextCO.getInputText();
+      await expect(clearBtn).not.toBeDisplayed();
+      await expect(input).toHaveValueContaining('');
+    });
+  });
+}

package/ds-controlled-form/ds-input-text/DSInputText.func.spec.js

@@ -0,0 +1,127 @@
+/* eslint-disable max-lines */
+import { Key } from 'webdriverio';
+import { type } from '../../helpers';
+import DSInputTextCO from './DSInputTextCO';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-9251 - DSControlledInputText - Basic func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.clearable.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should write some text on the input and change the input value', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await type('Hola');
+      const inputValue = await input.getAttribute('value');
+      await expect(inputValue).toEqual('Hola');
+    });
+    it('should erase the content from within the input and have an empty value for the input', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await browser.keys(Key.Backspace);
+      await browser.keys(Key.Backspace);
+      await browser.keys(Key.Backspace);
+      await browser.keys(Key.Backspace);
+      const inputValue = await input.getValue();
+      await expect(inputValue).toEqual('');
+    });
+  });
+
+  describe('PUI-9252 - DSControlledInputText - Autocomplete func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.autocompleteURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should not open the autocomplete list if there are no characters even with focus', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).not.toBeDisplayedInViewport();
+    });
+    it('should display autocomplete list after getting one character in the input', async () => {
+      await type('4');
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).toBeDisplayedInViewport();
+    });
+    it('should not close the autocomplete list after getting more characters', async () => {
+      await type('4');
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).toBeDisplayedInViewport();
+    });
+    it('should close the autocomplete list after getting more characters which dont match any option', async () => {
+      await type('Z');
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).not.toBeDisplayedInViewport();
+    });
+    it('should display autocomplete options after erasing the character which caused a mismatch', async () => {
+      await browser.keys(Key.Backspace);
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).toBeDisplayedInViewport();
+    });
+    it('should not close the autocomplete list after deleting a character if there are characters left', async () => {
+      await browser.keys(Key.Backspace);
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).toBeDisplayedInViewport();
+    });
+    it('should close the autocomplete list after deleting a character if there are no characters left', async () => {
+      await browser.keys(Key.Backspace);
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      await expect(autocompleteList).not.toBeDisplayedInViewport();
+    });
+    it('should select the first autocomplete list item and change the value of the input', async () => {
+      await type('4');
+      await browser.keys(Key.Enter);
+      const input = await DSInputTextCO.getInputText();
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      const inputValue = await input.getAttribute('value');
+      await expect(inputValue).toEqual('44444-4444');
+      await expect(autocompleteList).not.toBeDisplayedInViewport();
+    });
+  });
+
+  describe('PUI-9253 - DSControlledInputText - Autocomplete mouse selection', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.autocompleteURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should click an autocomplete option and the input should have that value', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await type('44');
+      const autocompleteOption = await DSInputTextCO.getAutocompleteOptionByIndex(1);
+      await autocompleteOption.click();
+      const autocompleteList = await DSInputTextCO.getAutocompleteMenuList();
+      const inputValue = await input.getAttribute('value');
+      await expect(inputValue).toEqual('44444-5555');
+      await expect(autocompleteList).not.toBeDisplayed();
+    });
+  });
+
+  describe('PUI-9255 - DSControlledInputText - Copy/paste', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.clearable.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should click an autocomplete option and the input should have that value', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await type('Hola');
+      if (browser.capabilities.browserName === 'Safari') {
+        await browser.keys([Key.Command, 'A']);
+        await browser.keys([Key.Command, 'C']);
+        await browser.keys([Key.Command, 'V']);
+        await browser.keys([Key.Command, 'V']);
+        await browser.keys([Key.Command, 'V']);
+      } else {
+        await browser.keys([Key.Control, 'A']);
+        await browser.keys([Key.Control, 'C']);
+        await browser.keys([Key.Control, 'V']);
+        await browser.keys([Key.Control, 'V']);
+        await browser.keys([Key.Control, 'V']);
+      }
+      const inputValue = await input.getAttribute('value');
+      await expect(inputValue).toEqual('HolaHolaHola');
+    });
+  });
+}

package/ds-controlled-form/ds-input-text/DSInputText.smoke.spec.js

@@ -0,0 +1,29 @@
+import { Key } from 'webdriverio';
+import DSInputTextCO from './DSInputTextCO';
+import { type } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-9251 - DSControlledInputText - Basic func', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.clearable.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should write some text on the input and change the input value', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await type('Hola');
+      const inputValue = await input.getAttribute('value');
+      await expect(inputValue).toEqual('Hola');
+    });
+    it('should erase the content from within the input and have an empty value for the input', async () => {
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await browser.keys(Key.Backspace);
+      await browser.keys(Key.Backspace);
+      await browser.keys(Key.Backspace);
+      await browser.keys(Key.Backspace);
+      const inputValue = await input.getValue();
+      await expect(inputValue).toEqual('');
+    });
+  });
+}

package/ds-controlled-form/ds-input-text/DSInputText.visual.spec.js

@@ -0,0 +1,148 @@
+/* eslint-disable max-lines */
+/* eslint-disable prettier/prettier */
+import { Key } from 'webdriverio';
+import DSInputTextCO from './DSInputTextCO';
+import { type, mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-9256 - DSControlledInputText - Sizes, default, focus and hover styling', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.sizesURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display Small and Medium sized input texts', async () => {
+      await browser.eyesOpen();
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-sizes-default'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display Small(hover) and Medium(focus) sized input texts', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      const input2 = await DSInputTextCO.getInputTextByIndex(1);
+      await input1.click();
+      await mouseOver(input2);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-sizes-focushover'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display Small(focus) and Medium(hover) sized input texts', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      const input2 = await DSInputTextCO.getInputTextByIndex(1);
+      await input2.click();
+      await mouseOver(input1);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-sizes-hoverfocus'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display the first input text focused and hovered (focus style)', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      await input1.click();
+      await mouseOver(input1);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-sizes-focusoverride'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-9257 - DSControlledInputText - Styles', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.stylesURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    // eslint-disable-next-line max-len
+    it('should display read-only, disabled and errored visual styles for input text. Try to interact disabled ones', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      const input2 = await DSInputTextCO.getInputTextByIndex(1);
+      await input2.click();
+      await mouseOver(input1);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-styles-a'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display read-only, disabled and errored visual styles for input text, errored interacted', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(2);
+      const input2 = await DSInputTextCO.getInputTextByIndex(3);
+      await input2.click();
+      await mouseOver(input1);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-styles-b'));
+      await expect(snapshot).toEqual(0);
+    });
+    // eslint-disable-next-line max-len
+    it('should display read-only, disabled and errored visual styles for input text, read-only interacted', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(4);
+      const input2 = await DSInputTextCO.getInputTextByIndex(5);
+      await input2.click();
+      await mouseOver(input1);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-styles-c'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-9258 - DSControlledInputText - Form Layout Block', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.formLayoutBlockURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('shuld display the input-text with different FormLayoutBlock combinations', async () => {
+      await browser.eyesOpen();
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-formlayoutblock'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+
+  describe('PUI-9259 - DSControlledInputText - Clearable ', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.clearable.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('shuld not display the clearable X button at the right of the input', async () => {
+      await browser.eyesOpen();
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-clearable-no-x'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('shuld display the clearable X button at the right of the input after writting some text', async () => {
+      await browser.eyesOpen();
+      const input = await DSInputTextCO.getInputText();
+      await input.click();
+      await type('Hello There');
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-clearable-has-x'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('shuld have the X button focused', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Tab);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-text-clearable-focused-X'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('shuld not display the clearable X button at the right of the input after removing the text', async () => {
+      await browser.eyesOpen();
+      await browser.keys(Key.Enter);
+      const snapshot = await browser.eyesCheckSnapshot(
+        DSInputTextCO.snapshotPath('input-text-clearable-after-removing'),
+      );
+      await expect(snapshot).toEqual(0);
+    });
+  });
+
+  describe('PUI-11984 - DSControlledInputText - HasError -Visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSInputTextCO.hasError.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display errored input uninteracted and with hover (no hover style)', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      await mouseOver(input1);
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-haserror-default'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display errored input focused (style overriden)', async () => {
+      await browser.eyesOpen();
+      const input1 = await DSInputTextCO.getInputTextByIndex(0);
+      await input1.click();
+      const snapshot = await browser.eyesCheckSnapshot(DSInputTextCO.snapshotPath('input-haserror-focused'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}