dimsum-e2e-tests 1.0.0-rc.1

package/ds-form/LargeInputText/DSLargeInputTextCO.js

@@ -0,0 +1,45 @@
+import { PATH_END_OF_LIFE_LARGE_INPUT_TEXT } from '../../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../../helpers';
+
+export const knobs = {
+  value: 'knob-value',
+  rows: 'knob-rows',
+  placeholder: 'knob-placeholder',
+  maxLength: 'knob-maxLength',
+  characterLimitCounter: 'knob-characterLimitCounter',
+  labelText: 'knob-labelText',
+  hasError: 'knob-hasError',
+  feedbackMessage: 'knob-feedbackMessage',
+  validationMessage: 'knob-validationMessage',
+};
+
+export default class DSLargeInputTextCO extends PageObject {
+  // Desktop
+  static basicURL = new Urlbuilder(PATH_END_OF_LIFE_LARGE_INPUT_TEXT, 'basic');
+
+  static getUrl(component = 'basic') {
+    return PageObject.getUrl(PATH_END_OF_LIFE_LARGE_INPUT_TEXT, component);
+  }
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('LargeInputText', example);
+  }
+
+  // selectors
+  static inputClick = async (idx = 0) => {
+    const input = await $$('[data-testid="ds-large-input_main-component"]');
+    await input[idx].click();
+  };
+
+  static async inputContainer() {
+    return $('//textarea[@data-testid="ds-large-input_main-component"]/ancestor::div[2]');
+  }
+
+  static async getLargeInput(index) {
+    return $$('[data-testid="ds-large-input_main-component"]')[index];
+  }
+
+  // actions
+  // utils
+}

package/ds-form/Radio/DSRadio.func.spec.js

@@ -0,0 +1,13 @@
+import DSRadioCO from './DSRadioCO';
+
+describe('PUI-5665 - Radio button, checked state', () => {
+  before('loading page', async () => {
+    const errorOnGo = await DSRadioCO.groupURL.go();
+    if (errorOnGo) throw errorOnGo;
+  });
+  it('should be checked when click on radio', async () => {
+    await (await DSRadioCO.getRadioBtn(1)).click();
+    const isRadioChecked = await DSRadioCO.isChecked(1);
+    await expect(isRadioChecked).toBe(true);
+  });
+});

package/ds-form/Radio/DSRadio.visual.spec.js

@@ -0,0 +1,39 @@
+import DSRadioCO from './DSRadioCO';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-3512 - Radio button, visual tests', () => {
+    describe('Radio button group', () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSRadioCO.groupURL.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should display radio button group correctly', async () => {
+        await (await DSRadioCO.getLabel('Label')).waitForDisplayed({ timeout: 5000 });
+        const snapshot = await browser.checkSnapshot(DSRadioCO.snapshotPath('basic-group'));
+        await expect(snapshot).toEqual(0);
+      });
+    });
+    describe('Radio button error state', () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSRadioCO.errorState.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should display radio button with error state', async () => {
+        await (await DSRadioCO.getLabel('Label')).waitForDisplayed({ timeout: 5000 });
+        const snapshot = await browser.checkSnapshot(DSRadioCO.snapshotPath('basic-error'));
+        await expect(snapshot).toEqual(0);
+      });
+    });
+    describe('Radio button read-only', () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSRadioCO.readOnly.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should display radio button with read-only state', async () => {
+        await (await DSRadioCO.getLabel('Label')).waitForDisplayed({ timeout: 5000 });
+        const snapshot = await browser.checkSnapshot(DSRadioCO.snapshotPath('basic-read-only'));
+        await expect(snapshot).toEqual(0);
+      });
+    });
+  });
+}

package/ds-form/Radio/DSRadioCO.js

@@ -0,0 +1,49 @@
+import { PATH_END_OF_LIFE_RADIO } from '../../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../../helpers';
+export default class DSRadioCO extends PageObject {
+  // Desktop
+  static basicURL = new Urlbuilder(PATH_END_OF_LIFE_RADIO, 'basic');
+
+  static groupURL = new Urlbuilder(PATH_END_OF_LIFE_RADIO, 'radio-group');
+
+  static errorState = new Urlbuilder(PATH_END_OF_LIFE_RADIO, 'error');
+
+  static readOnly = new Urlbuilder(PATH_END_OF_LIFE_RADIO, 'read-only');
+
+  static getUrl(component = 'basic') {
+    return PageObject.getUrl(PATH_END_OF_LIFE_RADIO, component);
+  }
+
+  static async getDisabledGroupePage() {
+    return $('p*=Disabled all group');
+  }
+
+  static async getLabel(label) {
+    return $(`span*=${label}`);
+  }
+
+  static async getRadioLabel(index) {
+    return $$('//span[contains(text(), "Radio label")]')[index];
+  }
+
+  static async getRadioBtn(index) {
+    return $$('//span[contains(text(), "Radio label")]/ancestor::label/span[1]')[index];
+  }
+
+  static async isChecked(index) {
+    const checkbox = await this.getRadioBtn(index);
+    if ((await checkbox.getAttribute('aria-checked')) === 'true') {
+      return true;
+    }
+    return false;
+  }
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('Radio', example);
+  }
+
+  // selectors
+  // actions
+  // utils
+}

package/ds-form/SearchBox/DSSearchBox.func.spec.js

@@ -0,0 +1,90 @@
+import { Key } from 'webdriverio';
+import DSSearchBoxCO from './DSSearchBoxCO';
+import { type } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-3144 - SearchBox - button disable to enable', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.disableButton.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('search button should be disable', async () => {
+      const searchBoxBtn = await DSSearchBoxCO.getSearchBoxButton();
+      await expect(searchBoxBtn).toBeDisabled();
+    });
+    it('search button should be enable when start typing', async () => {
+      await (await DSSearchBoxCO.getInputText()).setValue('Hello');
+      const searchBoxBtn = await DSSearchBoxCO.getSearchBoxButton();
+      await expect(searchBoxBtn).not.toBeDisabled();
+    });
+    it('search button should be disabled after textbox is cleared', async () => {
+      await DSSearchBoxCO.triggerBackspace(5);
+      const searchBoxBtn = await DSSearchBoxCO.getSearchBoxButton();
+      await expect(searchBoxBtn).toBeDisabled();
+    });
+  });
+  describe('PUI-5805 - SearchBox - clearable', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.clearableUrl.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('input clear works', async () => {
+      await (await DSSearchBoxCO.getInputText()).waitForDisplayed({ timeout: 10000 });
+      await (await DSSearchBoxCO.getInputText()).setValue('Hello');
+      let inputTextValue = await (await DSSearchBoxCO.getInputText()).getValue();
+      await expect(inputTextValue).toEqual('Hello');
+      await (await DSSearchBoxCO.getclearButton()).click();
+      inputTextValue = await (await DSSearchBoxCO.getInputText()).getValue();
+      await expect(inputTextValue).toEqual('');
+    });
+  });
+  describe('PUI-5857 - Searchbox - Clearable - Keyboard behavior', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.clearableUrl.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should focus clear button after pressing tab', async () => {
+      const inputText = await DSSearchBoxCO.getInputText();
+      await inputText.click();
+      await type('test data');
+      await browser.keys(Key.Tab);
+      const clearBtn = await DSSearchBoxCO.getclearButton();
+      await expect(clearBtn).toBeFocused();
+    });
+    it('should clear textbox value', async () => {
+      await browser.keys(Key.Enter);
+      const inputText = await DSSearchBoxCO.getInputText();
+      const inputTextValue = await inputText.getValue();
+      await expect(inputTextValue).toBe('');
+    });
+  });
+  describe('PUI-6133 - Searchbox - Nav, Scroll to Item', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.navScrollURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should scroll to the element', async () => {
+      await (await DSSearchBoxCO.getNavInput()).click();
+      await type('Onix');
+      await browser.keys(Key.Enter);
+      const highlightedResult = await DSSearchBoxCO.getHighlightedResultByText('Onix');
+      await expect(highlightedResult).toBeDisplayedInViewport();
+    });
+  });
+}
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-3141 - SearchBox - clear button', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.clearableUrl.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('input does not clear on search', async () => {
+      await (await DSSearchBoxCO.getInputText()).setValue('Hello');
+      const clearBtn = await DSSearchBoxCO.getclearButton();
+      await expect(clearBtn).toBeDisplayed();
+      await clearBtn.click();
+      const inputTextValue = await (await DSSearchBoxCO.getInputText()).getText();
+      await expect(inputTextValue).toEqual('');
+    });
+  });
+}

package/ds-form/SearchBox/DSSearchBox.visual.spec.js

@@ -0,0 +1,61 @@
+import DSSearchBoxCO from './DSSearchBoxCO';
+import { type } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-6132 - SearchBox, Nav - Visual Test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.navURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should not display the controls nor the item count', async () => {
+      await (await DSSearchBoxCO.getNavInput()).waitForDisplayed({ timeout: 5000 });
+      const snapshot = await browser.checkSnapshot(DSSearchBoxCO.snapshotPath('nav-no-counter'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display the nav controls and the item count', async () => {
+      await (await DSSearchBoxCO.getNavInput()).click();
+      await type('Agent');
+      const snapshot = await browser.checkSnapshot(DSSearchBoxCO.snapshotPath('nav-counter'));
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display the actual item count / total', async () => {
+      await (await DSSearchBoxCO.getNavNextButton()).click();
+      const snapshot = await browser.checkSnapshot(DSSearchBoxCO.snapshotPath('nav-actual-item-count'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+
+  describe('PUI-3142 - SearchBox disabled - visual test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.disabledUrl.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('input and search button are disabled', async () => {
+      await (await DSSearchBoxCO.getInput()).waitForDisplayed({ timeout: 5000 });
+      const snapshot = await browser.checkSnapshot(DSSearchBoxCO.snapshotPath('disabled'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-3143 - SearchBox disable button - visual test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.buttonDisabled.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('input is enabled and search button disabled', async () => {
+      await (await DSSearchBoxCO.getInput()).waitForDisplayed({ timeout: 5000 });
+      const snapshot = await browser.checkSnapshot(DSSearchBoxCO.snapshotPath('disabled-button'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+  describe('PUI-6000 - SearchBox long value', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSSearchBoxCO.longValue.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should not overlap the search icon', async () => {
+      await (await DSSearchBoxCO.getInput()).waitForDisplayed({ timeout: 5000 });
+      const snapshot = await browser.checkSnapshot(DSSearchBoxCO.snapshotPath('real-long-value'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-form/SearchBox/DSSearchBoxCO.js

@@ -0,0 +1,75 @@
+import { Key } from 'webdriverio';
+import { PATH_SEARCHBOX, PATH_E2E_SEARCHBOX } from '../../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../../helpers';
+
+export const knobs = {
+  disabled: 'knob-disabled',
+  disableButton: 'knob-disableButton',
+  clearOnSearch: 'knob-clearOnSearch',
+};
+
+export default class DSSearchBoxCO extends PageObject {
+  // Desktop
+  static basicURL = new Urlbuilder(PATH_SEARCHBOX, 'basic');
+
+  static disabledUrl = new Urlbuilder(PATH_SEARCHBOX, 'disabled');
+
+  static buttonDisabled = new Urlbuilder(PATH_SEARCHBOX, 'button-disabled');
+
+  static navURL = new Urlbuilder(PATH_SEARCHBOX, 'nav');
+
+  static clearableUrl = new Urlbuilder(PATH_SEARCHBOX, 'clearable');
+
+  static longValue = new Urlbuilder(PATH_E2E_SEARCHBOX, 'real-long-value');
+
+  static navScrollURL = new Urlbuilder(PATH_SEARCHBOX, 'nav-scroll-to-item');
+
+  static getUrl(component = 'basic') {
+    return PageObject.getUrl(PATH_SEARCHBOX, component);
+  }
+
+  static disableButton = new Urlbuilder(PATH_E2E_SEARCHBOX, 'search-box-disable-button');
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('SearchBox', example);
+  }
+
+  // selectors
+  static async getInputText() {
+    return $('[data-testid="ds-input_main-component"]');
+  }
+
+  static async getSearchBoxButton() {
+    return $('[data-testid="ds-searchbox-button"]');
+  }
+
+  static async getclearButton() {
+    return $('[data-testid="ds-searchbox-button-clear"]');
+  }
+
+  static async getInput() {
+    return $('[data-testid="ds-input_main-component"]');
+  }
+
+  static async getNavNextButton() {
+    return $('[data-testid="ds-navsearchbox-next"]');
+  }
+
+  static async getNavInput() {
+    return $('[data-testid="ds-nav-searchbox-input"]');
+  }
+
+  static async getHighlightedResultByText(query) {
+    return $(`//mark[contains(text(), '${query}')]`);
+  }
+
+  // actions
+  static async triggerBackspace(number = 1) {
+    for (let x = 0; x < number; x += 1) {
+      // eslint-disable-next-line no-await-in-loop
+      await browser.keys(Key.Backspace);
+    }
+  }
+  // utils
+}

package/ds-form/Toggle/DSToggle.func.spec.js

@@ -0,0 +1,70 @@
+/* eslint-disable wdio/no-pause */
+import DSToggleCO from './DSToggleCO';
+import { mouseOver } from '../../helpers';
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-4477 - Toggle, basic functional', () => {
+    describe('Toggle, states on/off', () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSToggleCO.basicURL.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should change state to ON', async () => {
+        await (await DSToggleCO.getToggle()).click();
+        const toggleStateOn = await DSToggleCO.getToggleState('ON');
+        await expect(toggleStateOn).toBeDisplayed();
+      });
+      it('should change state to OFF', async () => {
+        await (await DSToggleCO.getToggle()).click();
+        const toggleStateOff = await DSToggleCO.getToggleState('OFF');
+        await expect(toggleStateOff).toBeDisplayed();
+      });
+    });
+    describe('Toggle, disabled', () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSToggleCO.disabled.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should not change state in disabled toggle', async () => {
+        await (await DSToggleCO.getToggle()).click();
+        const toggleStateOff = await DSToggleCO.getToggleState('OFF');
+        await expect(toggleStateOff).toBeDisplayed();
+      });
+    });
+    describe('Toggle, read only', () => {
+      before('loading page', async () => {
+        const errorOnGo = await DSToggleCO.readOnly.go();
+        if (errorOnGo) throw errorOnGo;
+      });
+      it('should display tooltip in read only toggle', async () => {
+        const toggle = await DSToggleCO.getToggle();
+        await toggle.waitForDisplayed();
+        if (browser.capabilities.browserName === 'firefox') {
+          await toggle.moveTo();
+        } else {
+          await mouseOver(toggle, 25, 8);
+        }
+        await browser.pause(300);
+        const tooltip = await DSToggleCO.getTooltip();
+        await tooltip.waitForDisplayed();
+        await expect(tooltip).toBeDisplayed();
+      });
+    });
+  });
+  describe('PUI-4739 - Toggle, controlled functional', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSToggleCO.controlledURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should change state to ON', async () => {
+      await (await DSToggleCO.getToggleOff()).click();
+      const toggleStateText = await (await DSToggleCO.getToggleOff()).getText();
+      await expect(toggleStateText).toContain('ON');
+    });
+    it('should change state to OFF', async () => {
+      await (await DSToggleCO.getToggleOn()).click();
+      const toggleStateText = await (await DSToggleCO.getToggleOn()).getText();
+      await expect(toggleStateText).toContain('OFF');
+    });
+  });
+}

package/ds-form/Toggle/DSToggle.visual.spec.js

@@ -0,0 +1,21 @@
+import DSToggleCO from './DSToggleCO';
+
+if (!browser.capabilities['ice:options'].isPhone) {
+  describe('PUI-4476 - Toggle, visual test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSToggleCO.basicURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should display basic toggle', async () => {
+      await (await DSToggleCO.getToggle()).waitForDisplayed({ timeout: 10000 });
+      const snapshot = await browser.checkSnapshot(DSToggleCO.snapshotPath());
+      await expect(snapshot).toEqual(0);
+    });
+    it('should display toggle with focus', async () => {
+      await (await DSToggleCO.getToggle()).click();
+      await (await DSToggleCO.getToggleState('ON')).waitForDisplayed({ timeout: 10000 });
+      const snapshot = await browser.checkSnapshot(DSToggleCO.snapshotPath('with-focus'));
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-form/Toggle/DSToggleCO.js

@@ -0,0 +1,45 @@
+import { PATH_END_OF_LIFE_TOGGLE } from '../../../environments/storybook/paths';
+import { PageObject, Urlbuilder } from '../../helpers';
+export default class DSToggleCO extends PageObject {
+  // Desktop
+  static basicURL = new Urlbuilder(PATH_END_OF_LIFE_TOGGLE, 'basic');
+
+  static controlledURL = new Urlbuilder(PATH_END_OF_LIFE_TOGGLE, 'controlled');
+
+  static disabled = new Urlbuilder(PATH_END_OF_LIFE_TOGGLE, 'disabled');
+
+  static readOnly = new Urlbuilder(PATH_END_OF_LIFE_TOGGLE, 'read-only');
+
+  static getUrl(component = 'basic') {
+    return PageObject.getUrl(PATH_END_OF_LIFE_TOGGLE, component);
+  }
+
+  static async getToggle() {
+    return $('[data-testid="em-ds-toggle"]');
+  }
+
+  static async getToggleOff() {
+    return $('[data-testid="init-off"]');
+  }
+
+  static async getToggleOn() {
+    return $('[data-testid="init-on"]');
+  }
+
+  static async getToggleState(state) {
+    return $(`div*=${state}`);
+  }
+
+  static async getTooltip() {
+    return $('[data-testid="popper-container"]');
+  }
+
+  // Snapshots
+  static snapshotPath(example = 'basic') {
+    return PageObject.getSnapshotPathBuilder('Toggle', example);
+  }
+
+  // selectors
+  // actions
+  // utils
+}

package/ds-form-layout-blocks/form-layout-block-item/DSFormLayoutBlockItem.axe-core.func.spec.js

@@ -0,0 +1,144 @@
+/* eslint-disable max-lines */
+import { Key } from 'webdriverio';
+import { axeCoreCheck, type } from '../../helpers';
+import DSFormLayoutBlockItemCO from './DSFormLayoutBlockItemCO';
+
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-10963 - DSFormLayoutBlockItem: Basic - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.basicTestURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axecore scan for the basic formLayoutBlockItem', async () => {
+      const formLayout = await DSFormLayoutBlockItemCO.getByTestId('mytestid');
+      await formLayout.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10964 - DSFormLayoutBlockItem: Form Validation, onBlur - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.validationOnBlur.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axecore scan with onBlur validation, no error message displayed', async () => {
+      await browser.keys(Key.Tab);
+      await type('More than twenty char');
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should pass axecore scan with onBlur validation, error message displayed', async () => {
+      await browser.keys(Key.Tab);
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      const firstInputBlock = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      const errorMessage = await DSFormLayoutBlockItemCO.getErrorMessageByParent(firstInputBlock);
+      await errorMessage.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10965 - DSFormLayoutBlockItem: Form Validation, onChange - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.validationOnChange.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axecore scan with onChange validation, no error message displayed', async () => {
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      await browser.keys(Key.Tab);
+      await type('More than');
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should pass axecore scan with onChange validation, error message displayed', async () => {
+      await type(' twenty char');
+      const firstInputBlock = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      const errorMessage = await DSFormLayoutBlockItemCO.getErrorMessageByParent(firstInputBlock);
+      await expect(errorMessage).toBeDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10966 - DSFormLayoutBlockItem: Form Validaiton, onSubmit - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.validationOnSubmit.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('01: should pass axecore scan with onSubmit validation, no error message displayed, one caused', async () => {
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      await browser.keys(Key.Tab);
+      await type('More than twenty chars');
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('02: should pass axecore scan with onSubmit validation, no error message displayed, two caused', async () => {
+      const checkbox = await DSFormLayoutBlockItemCO.getCheckboxByIndex(0);
+      const checkbox2 = await DSFormLayoutBlockItemCO.getCheckboxByIndex(1);
+      await checkbox2.click();
+      await checkbox.click();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+    it('03: should pass axecore scan with onSubmit validation, errors messages displayed', async () => {
+      const submitBtn = await DSFormLayoutBlockItemCO.getSubmit();
+      await submitBtn.click();
+      const errorMessage = await DSFormLayoutBlockItemCO.getErrorMessagesByIndex(0);
+      await errorMessage.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10967 - DSFormLayoutBlockItem: ShowOff (other components) (within dialog) - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.showOffE2e.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should correctly display 4 formLayoutBlocks, second with hideLabel last one with leftLabel', async () => {
+      const openDialogBtn = await DSFormLayoutBlockItemCO.getOpenDialogBtn();
+      await openDialogBtn.click();
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10969 - DSFormLayoutBlockItem: isGroup radio - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.isGroupURL.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should show correctly display a radioGroup within the formLayoutBlock', async () => {
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+
+  describe('PUI-10970 - DSFormLayoutBlockItem: Required and Optional - AxeCore test', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSFormLayoutBlockItemCO.optionalAndRequired.go();
+      if (errorOnGo) throw errorOnGo;
+    });
+    it('should show one optional and one required formLayoutBlocks', async () => {
+      const formLayout = await DSFormLayoutBlockItemCO.getBlockContainersByIndex(0);
+      await formLayout.waitForDisplayed();
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}