@ironsource/shared-ui-e2e 2.1.1-test.1 → 2.1.1

package/tests/components/inputs/input-v4/inputs-component.d.ts

@@ -0,0 +1,66 @@
+import { Page } from '@playwright/test';
+import { BaseInputComponent } from '../base-input';
+import { HasHelpTextTypeParams } from '../../fieldHelpText/types';
+export declare class InputsComponent extends BaseInputComponent {
+    private readonly fieldLabelComponent;
+    private readonly fieldHelpTextComponent;
+    constructor(page: Page);
+    getInputsLabelText({ testId }: {
+        testId: string;
+    }): any;
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    isInputMandatory({ testId }: {
+        testId: string;
+    }): any;
+    hasInputExtraText({ testId }: {
+        testId: string;
+    }): any;
+    getInputExtraText({ testId }: {
+        testId: string;
+    }): any;
+    clickOnApplyButton({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    hasInlineErrorText({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    getInlineErrorText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    clickOnShowPassword({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    clickOnPasswordIcon({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    clickOnHidePassword({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    isPasswordHidden({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    clearInput({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    hasExtraTextIconType({ testId, type }: HasHelpTextTypeParams): any;
+    isDisabled({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    hasApplyButton({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    getMaxLengthNumber({ testId }: {
+        testId: string;
+    }): Promise<number>;
+    getActualNumberLength({ testId }: {
+        testId: string;
+    }): Promise<number>;
+    getFontCaptionText({ testId }: {
+        testId: string;
+    }): Promise<number[]>;
+    getHelpIconText({ testId }: {
+        testId: string;
+    }): any;
+}

package/tests/components/inputs/input-v4/inputs-page.d.ts

@@ -0,0 +1,32 @@
+import { Page } from '@playwright/test';
+import { InputsComponent } from './inputs-component';
+import { ComponentBasePage } from '../../base-page/component-base-page';
+export declare class InputsPage extends ComponentBasePage {
+    readonly component: InputsComponent;
+    constructor(page: Page);
+    getInputsFieldText(): Promise<string>;
+    getInputsLabelText(): any;
+    addInput({ textInput }: {
+        textInput: string;
+    }): Promise<void>;
+    isInputMandatory(): any;
+    getPlaceholderText(): Promise<string>;
+    hasInputExtraText(): any;
+    getInputExtraText(): any;
+    getInputsType(): Promise<string>;
+    hasInlineErrorText(): Promise<boolean>;
+    getInlineErrorText(): Promise<string>;
+    clickOnApplyButton(): Promise<void>;
+    hasApplyButton(): Promise<boolean>;
+    hasExtraTextIconType({ type }: {
+        type: string;
+    }): any;
+    isDisabled(): Promise<boolean>;
+    getMaxLengthNumber(): Promise<number>;
+    getActualNumberLength(): Promise<number>;
+    getHelpIconText(): any;
+    clickOnShowPassword(): Promise<void>;
+    clickOnHidePassword(): Promise<void>;
+    isPasswordHidden(): Promise<boolean>;
+    waitForComponent(): Promise<void>;
+}

package/tests/components/inputs/inputs-v3/checkbox/checkbox-component.d.ts

@@ -0,0 +1,20 @@
+import { Page } from '@playwright/test';
+export declare class CheckboxComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    getCheckboxText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    isChecked({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    clickOnCheckbox({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    isCheckboxDisabled({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+}

package/tests/components/inputs/inputs-v3/checkbox/checkbox-page.d.ts

@@ -0,0 +1,12 @@
+import { Page } from '@playwright/test';
+import { CheckboxComponent } from './checkbox-component';
+import { ComponentBasePage } from '../../../base-page/component-base-page';
+export declare class CheckboxPage extends ComponentBasePage {
+    readonly component: CheckboxComponent;
+    constructor(page: Page);
+    getCheckboxText(): Promise<string>;
+    isChecked(): Promise<boolean>;
+    clickOnCheckbox(): Promise<void>;
+    isCheckboxDisabled(): Promise<boolean>;
+    waitForComponent(): Promise<void>;
+}

package/tests/components/inputs/inputs-v3/checkbox/consts.d.ts

@@ -0,0 +1,5 @@
+export declare const checkboxStoryId = "ironsrc-components-inputs-checkbox--default";
+export declare const checkboxIntermediateStoryId = "ironsrc-components-inputs-checkbox--indeterminate";
+export declare const checkboxDisabledStoryId = "ironsrc-components-inputs-checkbox--disabled";
+export declare const defaultTestId = "checkbox-default";
+export declare const loadedPageSelector = "[data-testid='checkbox-default-cb-wrapper']";

package/tests/components/inputs/inputs-v3/radio/consts.d.ts

@@ -0,0 +1,6 @@
+export declare const radioStoryId = "ironsrc-components-inputs-radio--default";
+export declare const radioDisabledStoryId = "ironsrc-components-inputs-radio--disabled";
+export declare const radioHelperTextStoryId = "ironsrc-components-inputs-radio--helper-text";
+export declare const radioErrorTextStoryId = "ironsrc-components-inputs-radio--error";
+export declare const defaultTestId = "radio-default";
+export declare const loadedPageSelector = "[data-testid='radio-default-radio-group']";

package/tests/components/inputs/inputs-v3/radio/radio-component.d.ts

@@ -0,0 +1,19 @@
+import { Page } from '@playwright/test';
+import { RadioButtonParams } from './types';
+export declare class RadioComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    clickOnRadioButton({ testId, radioButtonText }: RadioButtonParams): Promise<void>;
+    isDisabled({ testId, radioButtonText }: RadioButtonParams): Promise<boolean>;
+    hasHelperText({ testId, radioButtonText }: RadioButtonParams): Promise<any>;
+    hasErrorText({ testId, radioButtonText }: RadioButtonParams): Promise<any>;
+    getHelperText({ testId, radioButtonText }: RadioButtonParams): Promise<any>;
+    getErrorText({ testId, radioButtonText }: RadioButtonParams): Promise<any>;
+    private findRadioButton;
+    getCheckedButtonText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+}

package/tests/components/inputs/inputs-v3/radio/radio-page.d.ts

@@ -0,0 +1,15 @@
+import { Page } from '@playwright/test';
+import { RadioComponent } from './radio-component';
+import { ComponentBasePage } from '../../../base-page/component-base-page';
+export declare class RadioPage extends ComponentBasePage {
+    readonly component: RadioComponent;
+    constructor(page: Page);
+    clickOnRadioButton(radioButtonText: string): Promise<void>;
+    isDisabled(radioButtonText: string): Promise<boolean>;
+    hasHelperText(radioButtonText: string): Promise<any>;
+    getHelperText(radioButtonText: string): Promise<any>;
+    hasErrorText(radioButtonText: string): Promise<any>;
+    getErrorText(radioButtonText: string): Promise<any>;
+    getCheckedButtonText(): Promise<string>;
+    waitForComponent(): Promise<void>;
+}

package/tests/components/inputs/inputs-v3/radio/types.d.ts

@@ -0,0 +1,4 @@
+export type RadioButtonParams = {
+    testId: string;
+    radioButtonText: string;
+};

package/tests/components/inputs/inputs-v3/switch/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const switchStoryId = "ironsrc-components-inputs-switch--default";
+export declare const defaultTestId = "switch-default";
+export declare const loadedPageSelector = "[data-testid='switch-default-swicth-wrapper']";

package/tests/components/inputs/inputs-v3/switch/switch-component.d.ts

@@ -0,0 +1,14 @@
+import { Page } from '@playwright/test';
+import { SwitchButtonParams } from './types';
+export declare class SwitchComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    getSwitchButtonText({ testId, switchButtonText }: SwitchButtonParams): Promise<string>;
+    clickOnSwitchButton({ testId, switchButtonText }: SwitchButtonParams): Promise<void>;
+    getSelectedSwitchButtonText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+}

package/tests/components/inputs/inputs-v3/switch/switch-page.d.ts

@@ -0,0 +1,11 @@
+import { Page } from '@playwright/test';
+import { SwitchComponent } from './switch-component';
+import { ComponentBasePage } from '../../../base-page/component-base-page';
+export declare class SwitchPage extends ComponentBasePage {
+    readonly component: SwitchComponent;
+    constructor(page: Page);
+    getSwitchButtonText(switchButtonText: string): Promise<string>;
+    clickOnSwitchButton(switchButtonIndex: string): Promise<void>;
+    getSelectedSwitchButtonText(): Promise<string>;
+    waitForComponent(): Promise<void>;
+}

package/tests/components/inputs/inputs-v3/switch/types.d.ts

@@ -0,0 +1,4 @@
+export type SwitchButtonParams = {
+    testId: string;
+    switchButtonText: string;
+};

package/tests/components/inputs/inputs-v3/text-area/consts.d.ts

@@ -0,0 +1,8 @@
+export declare const textAreaStoryId = "ironsrc-components-inputs-textarea--default";
+export declare const textAreaPlaceholderStoryId = "ironsrc-components-inputs-textarea--placeholder";
+export declare const textAreaLabelStoryId = "ironsrc-components-inputs-textarea--label";
+export declare const textAreaDisabledStoryId = "ironsrc-components-inputs-textarea--disabled";
+export declare const textAreaHelpTextStoryId = "ironsrc-components-inputs-textarea--help-text";
+export declare const textAreaErrorTextStoryId = "ironsrc-components-inputs-textarea--error-text";
+export declare const defaultTestId = "text-area-default";
+export declare const loadedPageSelector = "[data-testid='text-area-default-ta-field']";

package/tests/components/inputs/inputs-v3/text-area/text-area-component.d.ts

@@ -0,0 +1,37 @@
+import { Page } from '@playwright/test';
+import { InputParams } from './types';
+export declare class TextAreaComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    addInput({ testId, text }: InputParams): Promise<void>;
+    clearInput({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    getInput({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    getPlaceholderText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    getLabelText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    isDisabled({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    hasHelpText({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    getHelpText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    hasErrorText({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    getErrorText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+}

package/tests/components/inputs/inputs-v3/text-area/text-area-page.d.ts

@@ -0,0 +1,20 @@
+import { Page } from '@playwright/test';
+import { TextAreaComponent } from './text-area-component';
+import { ComponentBasePage } from '../../../base-page/component-base-page';
+export declare class TextAreaPage extends ComponentBasePage {
+    readonly component: TextAreaComponent;
+    constructor(page: Page);
+    addInput({ text }: {
+        text: string;
+    }): Promise<void>;
+    getInput(): Promise<string>;
+    clearInput(): Promise<void>;
+    getPlaceholderText(): Promise<string>;
+    getLabelText(): Promise<string>;
+    isDisabled(): Promise<boolean>;
+    hasHelpText(): Promise<boolean>;
+    getHelpText(): Promise<string>;
+    hasErrorText(): Promise<boolean>;
+    getErrorText(): Promise<string>;
+    waitForComponent(): Promise<void>;
+}

package/tests/components/inputs/inputs-v3/text-area/types.d.ts

@@ -0,0 +1,4 @@
+export type InputParams = {
+    testId: string;
+    text: string;
+};

package/tests/components/inputs/types.d.ts

@@ -0,0 +1,4 @@
+export type InputParams = {
+    testId: string;
+    text: string;
+};

package/tests/components/table/consts.d.ts

@@ -0,0 +1,6 @@
+export declare const tableStoryId = "v4-components-datagrid--basic";
+export declare const selectableRowsStoryId = "v4-components-datagrid--selectable-rows";
+export declare const infiniteScrollingStoryId = "v4-components-datagrid--infinite-scrolling";
+export declare const noDataStoryId = "v4-components-datagrid--no-data";
+export declare const defaultTestId = "table-default";
+export declare const loadedPageSelector = "[data-testid='table-default-tbl-container']";

package/tests/components/table/table-component.d.ts

@@ -0,0 +1,70 @@
+import { Page } from '@playwright/test';
+import { HeaderParams, SearchParams } from './types.ts';
+export declare class TableComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    getTableRowCount({ testId }: {
+        testId: string;
+    }): Promise<number>;
+    getTableRowContentByIndex({ testId, index, }: {
+        testId: string;
+        index: number;
+    }): Promise<string>;
+    getTableRowByRowValue({ testId, rowHeader, rowValue, }: {
+        testId: string;
+        rowHeader: string;
+        rowValue: string;
+    }): Promise<string>;
+    private getRowIndexByRowValue;
+    getColumnValuesByHeader({ header, testId, }: {
+        header: string;
+        testId: string;
+    }): Promise<any[]>;
+    private getColumnIndexByHeader;
+    private getColumnValuesByIndex;
+    private getColumnHeaders;
+    getTableLabel({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    getTableFooter({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    clickOnSortByHeaderName({ testId, headerName }: HeaderParams): Promise<void>;
+    clickOnHeaderByName({ testId, headerName }: HeaderParams): Promise<void>;
+    searchForItems({ testId, searchTerm }: SearchParams): Promise<void>;
+    clearSearchText({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    isArrowVisible({ testId, headerName }: HeaderParams): Promise<boolean>;
+    scrollDownTableRows({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    waitForTableToLoad(): Promise<void>;
+    expandRow({ testId, headerName, rowValue, }: {
+        testId: string;
+        headerName: string;
+        rowValue: string;
+    }): Promise<void>;
+    isRowExpanded({ testId, headerName, rowValue }: any): Promise<boolean>;
+    getExpandedRowContent({ testId, headerName, rowValue }: any): Promise<string>;
+    isEmptyStateVisible({ testId }: {
+        testId: string;
+    }): Promise<boolean>;
+    getEmptyStateTitle({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    getEmptyStateSubtitle({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    clickOnRowCheckboxByIndex({ testId, index }: any): Promise<void>;
+    clickOnRowCheckboxByRowValue({ testId, rowHeader, rowValue }: any): Promise<void>;
+    getCheckedRowsNumber({ testId }: {
+        testId: string;
+    }): Promise<number>;
+    clickOnSelectAllCheckbox({ testId }: {
+        testId: string;
+    }): Promise<void>;
+}

package/tests/components/table/table-page.d.ts

@@ -0,0 +1,35 @@
+import { Page } from '@playwright/test';
+import { ComponentBasePage } from '../base-page/component-base-page';
+import { TableComponent } from './table-component';
+export declare class TablePage extends ComponentBasePage {
+    readonly component: TableComponent;
+    constructor(page: Page);
+    waitForComponent(): Promise<void>;
+    getTableRowCount(): Promise<number>;
+    getTableRowContentByIndex({ index }: {
+        index: number;
+    }): Promise<string>;
+    getTableRowByRowValue({ rowHeader, rowValue, }: {
+        rowHeader: string;
+        rowValue: string;
+    }): Promise<string>;
+    getColumnValuesByHeader({ header }: {
+        header: string;
+    }): Promise<any[]>;
+    getTableLabel(): Promise<string>;
+    getTableFooter(): Promise<string>;
+    searchForItems(searchTerm: string): Promise<void>;
+    clickOnSortByHeaderName(headerName: string): Promise<void>;
+    isArrowVisible(headerName: string): Promise<boolean>;
+    scrollDownTableRows(): Promise<void>;
+    isEmptyStateVisible(): Promise<boolean>;
+    getEmptyStateTitle(): Promise<string>;
+    getEmptyStateSubtitle(): Promise<string>;
+    clickOnRowCheckboxByIndex(index: number): Promise<void>;
+    clickOnRowCheckboxByRowValue({ rowHeader, rowValue, }: {
+        rowHeader: string;
+        rowValue: string;
+    }): Promise<void>;
+    getCheckedRowsNumber(): Promise<number>;
+    clickOnSelectAllCheckbox(): Promise<void>;
+}

package/tests/components/table/types.d.ts

@@ -0,0 +1,8 @@
+export type HeaderParams = {
+    testId: string;
+    headerName: string;
+};
+export type SearchParams = {
+    testId: string;
+    searchTerm: string;
+};

package/tests/components/tabs/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const tabsStoryId = "v4-components-tabs--basic";
+export declare const defaultTestId = "tabs-default";
+export declare const loadedPageSelector = "[data-testid='tabs-default-tabs-wrapper']";

package/tests/components/tabs/tabs-component.d.ts

@@ -0,0 +1,15 @@
+import { Page } from '@playwright/test';
+import { TabsSelectionParams } from './types';
+export declare class TabsComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    getSelectedTabText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    selectTab({ testId, tabName }: TabsSelectionParams): Promise<void>;
+    private getTabIndex;
+    isTabDisabled({ testId, tabName }: TabsSelectionParams): Promise<boolean>;
+}

package/tests/components/tabs/tabs-page.d.ts

@@ -0,0 +1,15 @@
+import { Page } from '@playwright/test';
+import { ComponentBasePage } from '../base-page/component-base-page';
+import { TabsComponent } from './tabs-component';
+export declare class TabsPage extends ComponentBasePage {
+    readonly component: TabsComponent;
+    constructor(page: Page);
+    waitForComponent(): Promise<void>;
+    getSelectedTabText(): Promise<string>;
+    selectTab({ tabName }: {
+        tabName: string;
+    }): Promise<void>;
+    isTabDisabled({ tabName }: {
+        tabName: string;
+    }): Promise<boolean>;
+}

package/tests/components/tabs/types.d.ts

@@ -0,0 +1,4 @@
+export type TabsSelectionParams = {
+    testId: string;
+    tabName: string;
+};

package/tests/components/tooltip/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const tooltipStoryId = "v4-components-tooltip--basic";
+export declare const defaultTestId = "tooltip-default";
+export declare const loadedPageSelector = "[data-testid='tooltip-default-tt-trigger']";

package/tests/components/tooltip/tooltip-component.d.ts

@@ -0,0 +1,14 @@
+import { Page } from '@playwright/test';
+export declare class TooltipComponent {
+    readonly page: Page;
+    constructor(page: Page);
+    waitForComponent({ testId }: {
+        testId: string;
+    }): Promise<void>;
+    getTooltipText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+    getTooltipHeaderText({ testId }: {
+        testId: string;
+    }): Promise<string>;
+}

package/tests/components/tooltip/tooltip-page.d.ts

@@ -0,0 +1,13 @@
+import { Page } from '@playwright/test';
+import { ComponentBasePage } from '../base-page/component-base-page';
+import { GotoParams } from '../base-page/types';
+import { TooltipComponent } from './tooltip-component';
+export declare class TooltipPage extends ComponentBasePage {
+    readonly component: TooltipComponent;
+    constructor(page: Page);
+    waitForComponent(): Promise<void>;
+    goto(gotoParams?: GotoParams): Promise<void>;
+    getTooltipText(): Promise<string>;
+    getTooltipHeaderText(): Promise<string>;
+    private openTooltip;
+}

package/tests/global/types.d.ts

@@ -0,0 +1,3 @@
+export type ComponentParams = {
+    [key: string]: string;
+};

package/tests/global/utils.d.ts

@@ -0,0 +1,4 @@
+import { ComponentParams } from './types';
+export declare const addPropsToUrl: (props: ComponentParams, url: string) => string;
+export declare const createStoryBookComponentPath: (componentId: string, componentParams?: ComponentParams) => string;
+export declare const getTestId: (testId: string, testIdModifier: string) => string;

package/tests/index.d.ts

@@ -0,0 +1,13 @@
+export * from './global/types';
+export * from './components/banner/banner-component';
+export * from './components/base-page/component-base-page';
+export * from './components/dialog/dialog-component';
+export * from './components/dropdown/dropdown-v4/dropdown-component';
+export * from './components/dropdown/dropdown-v3/dropdown-component';
+export * from './components/fieldHelpText/field-help-text-component';
+export * from './components/fieldLabel/field-label-component';
+export * from './components/includeExclude/include-exclude-component';
+export * from './components/inputs/input-v4/inputs-component';
+export * from './components/tabs/tabs-component';
+export * from './components/tooltip/tooltip-component';
+export * from './components/table/table-component';