@camunda/e2e-test-suite 0.0.1443 → 0.0.1445

package/dist/pages/SM-8.11/IdentityUsersPage.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityUsersPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class IdentityUsersPage {
+    page;
+    usersTab;
+    optionsButton;
+    editUserMenuItem;
+    operationsEngineerCheckbox;
+    developerCheckbox;
+    analystCheckbox;
+    confirmButton;
+    settingsTab;
+    optInButton;
+    optInCheckbox;
+    newContextPadButton;
+    newContextPadButtonText;
+    mainUser;
+    authorizations;
+    noAuthorizedResourceMessage;
+    dialog;
+    deleteAuthorisedResourceButton;
+    deleteAuthorisedResourceSubButton;
+    createResourceAuthorizationButton;
+    createResourceAuthorizationDialog;
+    nextButton;
+    createButton;
+    idComboBox;
+    readPermissionCheckbox;
+    startProcessIPermissionCheckbox;
+    optInAICheckbox;
+    rows;
+    groupsTab;
+    createGroupButton;
+    createGroupSubButton;
+    groupNameInput;
+    noGroupsHeading;
+    createFirstGroupButton;
+    createGroupDialoge;
+    assignMembersButton;
+    assignMembersSubButton;
+    assignMembersSearchbox;
+    assignMembersSearchResult;
+    organizationManagementLink;
+    deleteSubButton;
+    deleteButton;
+    filterTableSearchbox;
+    assignAuthorizationButton;
+    assignedRolesTab;
+    constructor(page) {
+        this.page = page;
+        this.usersTab = page.getByRole('tab', { name: 'Users' });
+        this.optionsButton = page.getByRole('button', { name: 'Options' });
+        this.editUserMenuItem = page.getByRole('menuitem', { name: 'Edit User' });
+        this.operationsEngineerCheckbox = page
+            .getByRole('group')
+            .locator('label')
+            .filter({ hasText: 'Operations Engineer' });
+        this.developerCheckbox = page
+            .getByRole('group')
+            .locator('label')
+            .filter({ hasText: 'Developer' });
+        this.analystCheckbox = page
+            .getByRole('group')
+            .locator('label')
+            .filter({ hasText: 'Analyst' });
+        this.confirmButton = page.getByRole('button', { name: 'Confirm' });
+        this.settingsTab = page.getByRole('tab', { name: 'Settings' });
+        this.optInButton = page.getByRole('button', { name: 'Opt-in', exact: true });
+        this.optInCheckbox = page.getByLabel('I understand and agree to the');
+        this.newContextPadButton = page.getByRole('switch').last();
+        this.newContextPadButtonText = page
+            .locator('[class= "cds--toggle__text"]')
+            .last();
+        this.mainUser = page
+            .getByRole('row')
+            .filter({ hasText: process.env.C8_USERNAME });
+        this.authorizations = page.getByRole('tab', {
+            name: 'Authorizations',
+        });
+        this.noAuthorizedResourceMessage = page.getByText("You haven't created any resource authorizations yet", { exact: true });
+        this.dialog = page.getByRole('dialog');
+        this.deleteAuthorisedResourceButton = page.getByRole('button', {
+            name: 'Delete',
+        });
+        this.deleteAuthorisedResourceSubButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.createResourceAuthorizationButton = page.getByRole('button', {
+            name: 'Create resource authorization',
+            exact: true,
+        });
+        this.createResourceAuthorizationDialog = page.getByRole('dialog', {
+            name: 'Create resource authorizations',
+            exact: true,
+        });
+        this.nextButton = this.createResourceAuthorizationDialog.getByRole('button', {
+            name: 'Next',
+        });
+        this.createButton = this.createResourceAuthorizationDialog.getByRole('button', {
+            name: 'Create',
+        });
+        this.idComboBox = page.getByRole('combobox', { name: 'ID' });
+        this.readPermissionCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'ReadRead-only access to' });
+        this.startProcessIPermissionCheckbox = page.getByRole('checkbox', {
+            name: 'Start process instance',
+        });
+        this.optInAICheckbox = page.getByLabel('I understand and agree to Terms for AI Usage');
+        this.rows = this.page.getByRole('row');
+        this.groupsTab = page.getByRole('tab', { name: 'Groups' });
+        this.createGroupButton = page.getByRole('button', {
+            name: 'create group',
+        });
+        this.createGroupSubButton = page
+            .getByRole('button', {
+            name: 'create group',
+        })
+            .last();
+        this.groupNameInput = page.getByRole('textbox', { name: 'name' });
+        this.noGroupsHeading = page.getByRole('heading', {
+            name: 'you don’t have any groups yet',
+        });
+        this.createFirstGroupButton = page.getByRole('button', {
+            name: 'create a group',
+        });
+        this.createGroupDialoge = page.getByRole('dialog', {
+            name: 'create group',
+        });
+        this.assignMembersButton = page.getByRole('button', {
+            name: 'assign members',
+        });
+        this.assignMembersSubButton = page
+            .getByRole('button', {
+            name: 'assign',
+        })
+            .last();
+        this.assignMembersSearchbox = page.getByRole('searchbox', {
+            name: 'search by full name or email address',
+        });
+        this.assignMembersSearchResult = page.locator('.cds--list-box__menu-item');
+        this.organizationManagementLink = page.getByRole('link', {
+            name: 'organization management',
+        });
+        this.deleteButton = page.getByRole('button', { name: 'delete' });
+        this.deleteSubButton = page
+            .getByRole('button', {
+            name: 'danger',
+        })
+            .last();
+        this.filterTableSearchbox = page.getByRole('searchbox', {
+            name: 'Filter table',
+        });
+        this.assignAuthorizationButton = page.getByRole('button', {
+            name: 'Assign authorization',
+            exact: true,
+        });
+        this.assignedRolesTab = page.getByRole('tab', { name: 'Assigned roles' });
+    }
+    async clickCreateAuthorizedResourceButton() {
+        await (0, test_1.expect)(this.createButton).toBeVisible({ timeout: 60000 });
+        await this.createButton.click();
+    }
+    async processIdResourceAssertion(processId) {
+        await (0, test_1.expect)(this.page.getByRole('row', { name: processId })).toBeVisible({
+            timeout: 90000,
+        });
+    }
+    async clickCreateResourceAuthorizationButton() {
+        await (0, test_1.expect)(this.createResourceAuthorizationButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.createResourceAuthorizationButton.click();
+    }
+    async clickNextButton() {
+        await (0, test_1.expect)(this.nextButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.nextButton.click();
+    }
+    async clickProcessIdInput() {
+        await (0, test_1.expect)(this.idComboBox).toBeVisible({ timeout: 60000 });
+        await this.idComboBox.click();
+    }
+    async fillProcessIdInput(processId) {
+        await this.idComboBox.fill(processId);
+    }
+    async checkReadPermissionCheckbox() {
+        await (0, test_1.expect)(this.readPermissionCheckbox).toBeVisible({ timeout: 60000 });
+        if (!(await this.readPermissionCheckbox.isChecked())) {
+            await this.readPermissionCheckbox.click({ force: true });
+        }
+    }
+    async checkStartInstancePermissionCheckbox() {
+        if (!(await this.startProcessIPermissionCheckbox.isChecked())) {
+            await this.startProcessIPermissionCheckbox.click({ force: true });
+        }
+    }
+    async clickUsersTab() {
+        await this.usersTab.click({ timeout: 60000 });
+    }
+    async clickOptionsButton() {
+        await this.optionsButton.click({ timeout: 90000 });
+    }
+    async clickEditUserMenuItem() {
+        await this.editUserMenuItem.click({ timeout: 60000 });
+    }
+    async clickOperationsEngineerCheckbox() {
+        await this.operationsEngineerCheckbox.click();
+    }
+    async checkDeveloperCheckbox() {
+        if (!(await this.developerCheckbox.isChecked())) {
+            await this.developerCheckbox.click({ timeout: 60000 });
+        }
+    }
+    async uncheckDeveloperCheckbox() {
+        if (await this.developerCheckbox.isChecked()) {
+            await this.developerCheckbox.click({ timeout: 60000 });
+        }
+    }
+    async checkAnalystCheckbox() {
+        if (!(await this.analystCheckbox.isChecked())) {
+            await this.analystCheckbox.click({ timeout: 60000 });
+        }
+    }
+    async uncheckAnalystCheckbox() {
+        if (await this.analystCheckbox.isChecked()) {
+            await this.analystCheckbox.click({ timeout: 60000 });
+        }
+    }
+    async clickConfirmButton() {
+        await this.confirmButton.click({ timeout: 60000 });
+    }
+    async clickSettingsTab() {
+        await this.settingsTab.click({ timeout: 120000 });
+        try {
+            await (0, test_1.expect)(this.page.getByRole('heading', { name: 'Alpha features' })).toBeVisible({
+                timeout: 120000,
+            });
+        }
+        catch (error) {
+            await this.settingsTab.click({ timeout: 120000 });
+        }
+    }
+    async clickOptInButton() {
+        await this.optInButton.click({ timeout: 60000 });
+    }
+    async enableAlphaFeature(name) {
+        await (0, test_1.expect)(this.rows.first()).toBeVisible({ timeout: 10000 });
+        const alphaFeature = this.rows.filter({ hasText: name }).first();
+        if ((await alphaFeature.count()) < 1) {
+            console.error(`No alpha feature(${name}) is found.`);
+            return;
+        }
+        //Opt-in The Alpha Feature
+        const alphaFeatureOptInButton = alphaFeature.getByRole('button', {
+            name: 'Opt-in to enable',
+        });
+        if (await alphaFeatureOptInButton.isVisible({ timeout: 10000 })) {
+            await alphaFeatureOptInButton.click();
+            await this.optInAICheckbox.scrollIntoViewIfNeeded();
+            await this.optInAICheckbox.check({ timeout: 90000 });
+            await (0, sleep_1.sleep)(3000);
+        }
+        //Enable Alpha Feature
+        const toggleText = await alphaFeature
+            .locator('[class= "cds--toggle__text"]')
+            .textContent();
+        console.info(`Previous feature(${name}) setting is ${toggleText}.`);
+        if (toggleText == 'Enabled') {
+            console.log(`Feature ${name} is already enabled.`);
+            return;
+        }
+        if (toggleText == 'Disabled') {
+            await alphaFeature
+                .locator('[class= "cds--toggle__switch"]')
+                .first()
+                .click();
+            await (0, sleep_1.sleep)(10000);
+        }
+        await (0, test_1.expect)(alphaFeature.locator('[class= "cds--toggle__text"]')).toHaveText('Enabled');
+    }
+    async scrollToOptInCheckbox() {
+        await this.page
+            .getByText('Access and Use of the Camunda')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByText('Pre-release. The Customer')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByText('Confidential Information. The')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByText('THESE TERMS DO NOT ENTITLE')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByText('Rights and Obligations Upon')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByText('NOTWITHSTANDING ANYTHING TO')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByRole('heading', { name: 'General' })
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByText('Liability. Camunda is liable')
+            .scrollIntoViewIfNeeded();
+        await this.page
+            .getByLabel('I understand and agree to the')
+            .scrollIntoViewIfNeeded();
+    }
+    async checkOptInCheckbox() {
+        await this.optInCheckbox.check({ timeout: 90000 });
+    }
+    async clickMainUser() {
+        await (0, test_1.expect)(this.mainUser).toBeVisible({ timeout: 60000 });
+        await this.mainUser.click();
+    }
+    async clickAuthorizations() {
+        await (0, test_1.expect)(this.authorizations).toBeVisible({ timeout: 60000 });
+        await this.authorizations.click();
+    }
+    async authorizedResourceAssertion(processId, maxRetries = 3, timeout = 30000) {
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            try {
+                await this.page.reload();
+                await this.clickAuthorizations();
+                await (0, test_1.expect)(this.page.getByRole('row', { name: processId })).toBeVisible({ timeout: timeout });
+                return;
+            }
+            catch (error) {
+                if (attempt < maxRetries - 1) {
+                    console.warn(`Attempt ${attempt + 1} failed. Retrying...`);
+                }
+                else {
+                    throw new Error(`Assertion failed after ${maxRetries} attempts`);
+                }
+            }
+        }
+    }
+    async clickNewContextPadButton() {
+        try {
+            await (0, test_1.expect)(this.newContextPadButtonText).toHaveText('Enabled', {
+                timeout: 90000,
+            });
+        }
+        catch {
+            await this.page.reload();
+            await this.newContextPadButton.click({ timeout: 90000 });
+            await (0, test_1.expect)(this.newContextPadButtonText).toHaveText('Enabled', {
+                timeout: 60000,
+            });
+        }
+    }
+    async optInToAlphaFeatures() {
+        try {
+            await (0, test_1.expect)(this.optInButton).toBeVisible({ timeout: 30000 });
+            await this.clickOptInButton();
+            await this.scrollToOptInCheckbox();
+            await this.checkOptInCheckbox();
+        }
+        catch {
+            await (0, test_1.expect)(this.optInButton).not.toBeVisible();
+        }
+    }
+    async clickGroupsTab() {
+        await this.groupsTab.click({ timeout: 60000 });
+    }
+    async clickCreateGroupButton() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (!(await this.noGroupsHeading.isVisible({ timeout: 120000 }))) {
+                    await this.createGroupButton.click();
+                }
+                else {
+                    await this.createFirstGroupButton.click();
+                }
+                return;
+            }
+            catch (error) {
+                console.error(`Click attempt ${retries + 1} failed`);
+            }
+        }
+        throw new Error(`Failed to click the button after ${maxRetries} attempts.`);
+    }
+    async fillGroupNameInput(name) {
+        await this.groupNameInput.fill(name);
+    }
+    async clickCreateGroupSubButton() {
+        await this.createGroupSubButton.click();
+    }
+    async clickUserGroup(name) {
+        await this.page.getByRole('cell', { name: name }).click();
+    }
+    async clickAssignMembers() {
+        await this.assignMembersButton.click();
+    }
+    async fillAssignMembers(names) {
+        for (const name of names) {
+            await this.assignMembersSearchbox.click({ timeout: 60000 });
+            await this.assignMembersSearchbox.fill(name);
+            await this.assignMembersSearchResult
+                .filter({ hasText: name })
+                .click({ timeout: 120000 });
+        }
+    }
+    async filterTable(names) {
+        for (const name of names) {
+            await this.filterTableSearchbox.click({ timeout: 60000 });
+            await this.filterTableSearchbox.fill(name);
+        }
+    }
+    async clickAssignSubButton() {
+        await this.assignMembersSubButton.click();
+    }
+    async clickOrganizationManagementLink() {
+        await this.organizationManagementLink.click();
+    }
+    async deleteAllGroups() {
+        try {
+            await this.deleteButton
+                .first()
+                .waitFor({ state: 'visible', timeout: 60000 });
+            const count = await this.deleteButton.count();
+            if (count > 0) {
+                for (let i = 0; i < count; i++) {
+                    await this.deleteButton.nth(i).click({ timeout: 60000 });
+                    await this.deleteSubButton.click({ timeout: 60000 });
+                }
+            }
+        }
+        catch (error) {
+            console.log('Delete Button Not Clicked ' + error);
+        }
+    }
+    async createResourceAuthorization(processId) {
+        try {
+            await this.clickCreateResourceAuthorizationButton();
+        }
+        catch {
+            await this.clickAssignAuthorizationButton();
+        }
+        await (0, test_1.expect)(this.createResourceAuthorizationDialog).toBeVisible({
+            timeout: 60000,
+        });
+        await this.clickNextButton();
+        await this.clickProcessIdInput();
+        await this.fillProcessIdInput(processId);
+        await this.clickNextButton();
+        await this.checkReadPermissionCheckbox();
+        await this.checkStartInstancePermissionCheckbox();
+        await this.clickCreateAuthorizedResourceButton();
+        await this.processIdResourceAssertion(processId);
+    }
+    async clickAssignAuthorizationButton() {
+        await this.assignAuthorizationButton.click();
+    }
+    async clickAssignedRolesTab() {
+        await this.assignedRolesTab.click();
+    }
+    // A role entry may be a single name, or a list of interchangeable names when
+    // Management Identity ships the same permission set under more than one label
+    // (e.g. 'Hub'/'Web Modeler'); any one of the listed names satisfies the entry.
+    async assertUserIsAssignedCorrectRole(username, roles) {
+        await this.page.getByRole('cell', { name: username, exact: true }).click();
+        // Wait for the Assigned Roles tab to render before clicking it; after
+        // navigating to a user row the panel can take a moment to hydrate.
+        await (0, test_1.expect)(this.assignedRolesTab).toBeVisible({ timeout: 30000 });
+        await this.assignedRolesTab.click();
+        for (const role of roles) {
+            const acceptedNames = Array.isArray(role) ? role : [role];
+            const roleCell = acceptedNames
+                .map((name) => this.page.getByRole('cell', { name, exact: true }))
+                .reduce((combined, cell) => combined.or(cell));
+            // Use a generous timeout: on slow/post-upgrade clusters the role table
+            // may take several seconds to populate after the tab switch.
+            await (0, test_1.expect)(roleCell.first()).toBeVisible({ timeout: 60000 });
+        }
+    }
+}
+exports.IdentityUsersPage = IdentityUsersPage;

package/dist/pages/SM-8.11/KeycloakAdminPage.d.ts

@@ -0,0 +1,17 @@
+import { Page, Locator } from '@playwright/test';
+declare class KeycloakAdminPage {
+    private page;
+    readonly keycloakBanner: Locator;
+    readonly addUserButton: Locator;
+    readonly credentialsTab: Locator;
+    constructor(page: Page);
+    toBeVisible(): Promise<void>;
+    switchToCamundaPlatform(): Promise<void>;
+    clickUsersTab(): Promise<void>;
+    clickAddUser(): Promise<void>;
+    fillUser(username: string): Promise<void>;
+    saveUser(): Promise<void>;
+    fillPassword(password: string): Promise<void>;
+    savePassword(): Promise<void>;
+}
+export { KeycloakAdminPage };

package/dist/pages/SM-8.11/KeycloakAdminPage.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeycloakAdminPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class KeycloakAdminPage {
+    page;
+    keycloakBanner;
+    addUserButton;
+    credentialsTab;
+    constructor(page) {
+        this.page = page;
+        this.keycloakBanner = page.locator('#kc-main-content-page-container');
+        this.addUserButton = page.getByTestId('add-user');
+        this.credentialsTab = page.getByTestId('credentials');
+    }
+    async toBeVisible() {
+        await (0, test_1.expect)(this.keycloakBanner).toBeVisible({ timeout: 60000 });
+    }
+    async switchToCamundaPlatform() {
+        const realmSelector = this.page.getByTestId('nav-item-realms');
+        await realmSelector.click();
+        const searchField = this.page.getByTestId('selectRealminput');
+        await searchField.click();
+        await this.page
+            .getByPlaceholder('Search')
+            .fill(process.env.KEYCLOAK_REALM || 'camunda-platform');
+        await this.page
+            .locator('[data-ouia-component-id="OUIA-Generated-Button-control-1"]')
+            .click();
+        // The realm search result renders after an async lookup, so a bare click
+        // races Playwright's default 10s action timeout — wait for it explicitly
+        // (matching clickAddUser/fillPassword's 30s waits elsewhere in this file)
+        // instead of relying on the click's own implicit wait.
+        const realmResult = this.page.getByText(process.env.KEYCLOAK_REALM || 'camunda-platform');
+        await (0, test_1.expect)(realmResult).toBeVisible({ timeout: 30000 });
+        await realmResult.click();
+        const mainLocator = this.page.locator('#kc-main-content-page-container');
+        await (0, test_1.expect)(mainLocator).toBeVisible({ timeout: 60000 });
+    }
+    async clickUsersTab() {
+        await this.page.click('a[id="nav-item-users"]');
+    }
+    async clickAddUser() {
+        await (0, test_1.expect)(this.addUserButton).toBeVisible({ timeout: 30000 });
+        await this.addUserButton.click();
+    }
+    async fillUser(username) {
+        await this.page.getByTestId('username').fill(username);
+        await this.page.getByTestId('firstName').fill(`test${username}`);
+        await this.page.getByTestId('lastName').fill('user');
+        await this.page
+            .getByTestId('email')
+            .fill(`qacamunda+${username}@gmail.com`);
+    }
+    async saveUser() {
+        await this.page.getByTestId('user-creation-save').click();
+    }
+    async fillPassword(password) {
+        await (0, test_1.expect)(this.credentialsTab).toBeVisible({ timeout: 30000 });
+        await this.credentialsTab.click();
+        await this.page.getByTestId('no-credentials-empty-action').click();
+        await this.page.getByTestId('passwordField').fill(password);
+        await this.page.getByTestId('passwordConfirmationField').fill(password);
+    }
+    async savePassword() {
+        await this.page
+            .locator('label.pf-v5-c-switch[for="temporaryPassword"]')
+            .click();
+        await this.page.getByTestId('confirm').click();
+        await this.page.getByTestId('confirm').click();
+        // if the browser is firefox, delay for 500 ms
+        if (await this.page.evaluate(() => navigator.userAgent.includes('Firefox'))) {
+            await (0, sleep_1.sleep)(500);
+        }
+    }
+}
+exports.KeycloakAdminPage = KeycloakAdminPage;

package/dist/pages/SM-8.11/KeycloakLoginPage.d.ts

@@ -0,0 +1,12 @@
+import { Locator, Page } from '@playwright/test';
+declare class KeycloakLoginPage {
+    private page;
+    readonly keycloakBanner: Locator;
+    constructor(page: Page);
+    toBeVisible(): Promise<void>;
+    fillUsername(username: string): Promise<void>;
+    fillPassword(password: string): Promise<void>;
+    clearSession(): Promise<void>;
+    clickLogin(): Promise<void>;
+}
+export { KeycloakLoginPage };

package/dist/pages/SM-8.11/KeycloakLoginPage.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeycloakLoginPage = void 0;
+const test_1 = require("@playwright/test");
+class KeycloakLoginPage {
+    page;
+    keycloakBanner;
+    constructor(page) {
+        this.page = page;
+        this.keycloakBanner = page.locator('#keycloak-bg');
+    }
+    async toBeVisible() {
+        await (0, test_1.expect)(this.keycloakBanner).toBeVisible();
+    }
+    async fillUsername(username) {
+        await this.page.fill('#username', username);
+    }
+    async fillPassword(password) {
+        await this.page.fill('#password', password);
+    }
+    async clearSession() {
+        await this.page.context().clearCookies();
+    }
+    async clickLogin() {
+        // Submitting the Keycloak form starts a redirect chain that page.click
+        // implicitly waits on ("waiting for scheduled navigations to finish"), so
+        // the action inherits the 10s actionTimeout to cover a navigation. Give it
+        // the navigation budget the rest of the suite uses instead.
+        await this.page.click('button[type="submit"]', { timeout: 60000 });
+    }
+}
+exports.KeycloakLoginPage = KeycloakLoginPage;

package/dist/pages/SM-8.11/KeycloakUtils.d.ts

@@ -0,0 +1,17 @@
+import { NavigationPage } from '../SM-8.11/NavigationPage';
+import { ManagementIdentityPage } from '../SM-8.11/ManagementIdentityPage';
+import { KeycloakLoginPage } from '../SM-8.11/KeycloakLoginPage';
+import { KeycloakAdminPage } from '../SM-8.11/KeycloakAdminPage';
+import { OCIdentityHomePage } from './OCIdentityHomePage';
+import { OCIdentityRolesPage } from './OCIdentityRolesPage';
+import { IdentityTenantPage } from './IdentityTenantPage';
+export declare const keycloakAdminCredentials: () => {
+    username: string;
+    password: string;
+};
+export declare const setupKeycloakUser: (navigationPage: NavigationPage, identityPage: ManagementIdentityPage, keycloakLoginPage: KeycloakLoginPage, keycloakAdminPage: KeycloakAdminPage, ocIdentityHomePage: OCIdentityHomePage, ocIdentityRolesPage: OCIdentityRolesPage, assignToDefaultTenant?: boolean, managementIdentityTenantPage?: IdentityTenantPage) => Promise<{
+    testUsername: string;
+    testPassword: string;
+}>;
+export declare function createUser(navigationPage: NavigationPage, identityPage: ManagementIdentityPage, keycloakLoginPage: KeycloakLoginPage, keycloakAdminPage: KeycloakAdminPage, username: string, password: string): Promise<void>;
+export declare function createKeycloakUser(navigationPage: NavigationPage, keycloakLoginPage: KeycloakLoginPage, keycloakAdminPage: KeycloakAdminPage, username: string, password: string): Promise<void>;