@camunda/e2e-test-suite 0.0.1

package/dist/pages/SM-8.5/FormJsPage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormJsPage = void 0;
+class FormJsPage {
+    page;
+    aiFormGeneratorButton;
+    formRequestInput;
+    generateFormButton;
+    constructor(page) {
+        this.page = page;
+        this.aiFormGeneratorButton = page.getByRole('button', {
+            name: 'AI Form Generator',
+        });
+        this.formRequestInput = page.getByPlaceholder('A form for an american standard loan request');
+        this.generateFormButton = page.getByRole('button', { name: 'Generate form' });
+    }
+    async clickAIFormGeneratorButton() {
+        await this.aiFormGeneratorButton.click();
+    }
+    async clickFormRequestInput() {
+        await this.formRequestInput.click();
+    }
+    async fillFormRequestInput(formRequest) {
+        await this.formRequestInput.fill(formRequest);
+    }
+    async clickGenerateFormButton() {
+        await this.generateFormButton.click();
+    }
+}
+exports.FormJsPage = FormJsPage;

package/dist/pages/SM-8.5/HomePage.d.ts

@@ -0,0 +1,20 @@
+import { Page, Locator } from '@playwright/test';
+declare class HomePage {
+    private page;
+    readonly dashboardTab: Locator;
+    readonly clusterTab: Locator;
+    readonly organizationTab: Locator;
+    readonly organizationViewTitle: Locator;
+    readonly welcomeMessage: Locator;
+    readonly informationDialog: Locator;
+    readonly camundaAppsButton: Locator;
+    readonly camundaComponentsButton: Locator;
+    constructor(page: Page);
+    clickClusters(): Promise<void>;
+    clickDashboard(): Promise<void>;
+    clickOrganization(): Promise<void>;
+    closeInformationDialog(): Promise<void>;
+    clickCamundaComponents(): Promise<void>;
+    clickCamundaApps(): Promise<void>;
+}
+export { HomePage };

package/dist/pages/SM-8.5/HomePage.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HomePage = void 0;
+class HomePage {
+    page;
+    dashboardTab;
+    clusterTab;
+    organizationTab;
+    organizationViewTitle;
+    welcomeMessage;
+    informationDialog;
+    camundaAppsButton;
+    camundaComponentsButton;
+    constructor(page) {
+        this.page = page;
+        this.dashboardTab = page.getByRole('link', { name: 'Dashboard' });
+        this.clusterTab = page.getByRole('link', { name: 'Clusters' });
+        this.organizationTab = page.getByRole('link', { name: 'Organization' });
+        this.organizationViewTitle = page.getByText('Organization Management');
+        this.welcomeMessage = page.getByText('Welcome, demo').first();
+        this.informationDialog = page.getByRole('button', {
+            name: 'Close this dialog',
+        });
+        this.camundaComponentsButton = page.getByLabel('Camunda components');
+        this.camundaAppsButton = page.getByLabel('Camunda apps');
+    }
+    async clickClusters() {
+        await this.clusterTab.click({ timeout: 90000 });
+    }
+    async clickDashboard() {
+        await this.dashboardTab.click({ timeout: 90000 });
+    }
+    async clickOrganization() {
+        await this.organizationTab.click({ timeout: 90000 });
+    }
+    async closeInformationDialog() {
+        const isLocalTest = process.env.LOCAL_TEST;
+        if (isLocalTest) {
+            await this.informationDialog.click();
+        }
+    }
+    async clickCamundaComponents() {
+        await this.camundaComponentsButton.click({ timeout: 90000 });
+    }
+    async clickCamundaApps() {
+        await this.camundaAppsButton.click({ timeout: 90000 });
+    }
+}
+exports.HomePage = HomePage;

package/dist/pages/SM-8.5/IdentityPage.d.ts

@@ -0,0 +1,56 @@
+import { Page, Locator } from '@playwright/test';
+declare class IdentityPage {
+    private page;
+    readonly identityBanner: Locator;
+    readonly usersLink: Locator;
+    readonly assignedRolesTab: Locator;
+    readonly demoUser: Locator;
+    readonly confirmDeleteButton: Locator;
+    readonly assignRolesButton: Locator;
+    readonly addButton: Locator;
+    readonly operateCheckbox: Locator;
+    readonly tasklistCheckbox: Locator;
+    readonly optimizeCheckbox: Locator;
+    readonly modelerCheckbox: Locator;
+    readonly consoleCheckbox: Locator;
+    readonly groupsTab: Locator;
+    readonly createFirstGroupButton: Locator;
+    readonly createGroupButton: Locator;
+    readonly createGroupSubButton: Locator;
+    readonly groupNameInput: Locator;
+    readonly assignMembersButton: Locator;
+    readonly assignMembersSubButton: Locator;
+    readonly assignMembersSearchbox: Locator;
+    readonly assignMembersSearchResult: Locator;
+    readonly noGoupsHeading: Locator;
+    readonly deleteButton: Locator;
+    readonly deleteSubButton: Locator;
+    readonly createGroupDialoge: Locator;
+    readonly authorizationsTab: Locator;
+    readonly tenantTab: Locator;
+    constructor(page: Page);
+    clickUsersLink(): Promise<void>;
+    clickAssignedRolesTab(): Promise<void>;
+    clickDemoUser(): Promise<void>;
+    clickDeleteAccessButton(accessToDelete: string): Promise<void>;
+    clickConfirmDeleteButton(): Promise<void>;
+    clickAssignRolesButton(): Promise<void>;
+    clickAddButton(): Promise<void>;
+    clickOperateCheckbox(): Promise<void>;
+    clickTasklistCheckbox(): Promise<void>;
+    clickOptimizeCheckbox(): Promise<void>;
+    clickModelerCheckbox(): Promise<void>;
+    clickConsoleCheckbox(): Promise<void>;
+    clickGroupsTab(): Promise<void>;
+    clickCreateGroupButton(): Promise<void>;
+    fillGroupNameInput(name: string): Promise<void>;
+    clickUserGroup(name: string): Promise<void>;
+    clickAssignMembers(): Promise<void>;
+    fillAssignMembers(names: string[]): Promise<void>;
+    clickAssignSubButton(): Promise<void>;
+    clickCreateGroupSubButton(): Promise<void>;
+    deleteAllGroups(): Promise<void>;
+    clickAuthorizationsTab(): Promise<void>;
+    clickTenantTab(): Promise<void>;
+}
+export { IdentityPage };

package/dist/pages/SM-8.5/IdentityPage.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityPage = void 0;
+const test_1 = require("@playwright/test");
+class IdentityPage {
+    page;
+    identityBanner;
+    usersLink;
+    assignedRolesTab;
+    demoUser;
+    confirmDeleteButton;
+    assignRolesButton;
+    addButton;
+    operateCheckbox;
+    tasklistCheckbox;
+    optimizeCheckbox;
+    modelerCheckbox;
+    consoleCheckbox;
+    groupsTab;
+    createFirstGroupButton;
+    createGroupButton;
+    createGroupSubButton;
+    groupNameInput;
+    assignMembersButton;
+    assignMembersSubButton;
+    assignMembersSearchbox;
+    assignMembersSearchResult;
+    noGoupsHeading;
+    deleteButton;
+    deleteSubButton;
+    createGroupDialoge;
+    authorizationsTab;
+    tenantTab;
+    constructor(page) {
+        this.page = page;
+        this.identityBanner = page.getByRole('link', { name: 'Camunda Identity' });
+        this.usersLink = page.getByRole('link', { name: 'Users' });
+        this.assignedRolesTab = page.getByRole('tab', { name: 'Assigned roles' });
+        this.demoUser = page.getByRole('cell', { name: 'demo' }).first();
+        this.confirmDeleteButton = page.getByRole('button', {
+            name: 'danger Delete',
+        });
+        this.assignRolesButton = page.getByRole('button', { name: 'Assign roles' });
+        this.addButton = page.getByRole('button', { name: 'Add' });
+        this.operateCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Operate (Grants full access to Operate)' });
+        this.tasklistCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Tasklist (Grants full access to Tasklist)' });
+        this.optimizeCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Optimize (Grants full access to Optimize)' });
+        this.modelerCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Web Modeler (Grants full access to Web Modeler)' });
+        this.consoleCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Console (Grants full access to Console)' });
+        this.groupsTab = page.getByText('groups').first();
+        this.createGroupButton = page.getByRole('button', {
+            name: 'create group',
+        });
+        this.createFirstGroupButton = page.getByRole('button', {
+            name: 'create a group',
+        });
+        this.createGroupSubButton = page
+            .getByRole('button', {
+            name: 'create group',
+        })
+            .last();
+        this.groupNameInput = page.getByRole('textbox', { name: 'name' });
+        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.noGoupsHeading = page.getByRole('heading', {
+            name: 'you don’t have any groups yet',
+        });
+        this.deleteSubButton = page.getByRole('button', { name: 'danger delete' });
+        this.deleteButton = page.locator('button', { hasText: 'danger' });
+        this.createGroupDialoge = page.getByRole('dialog', {
+            name: 'create group',
+        });
+        this.authorizationsTab = page.getByRole('tab', { name: 'Authorizations' });
+        this.tenantTab = page
+            .getByLabel('Top navigation')
+            .getByRole('link', { name: 'Tenants' });
+    }
+    async clickUsersLink() {
+        try {
+            await this.usersLink.click({ timeout: 180000, force: true });
+        }
+        catch {
+            await this.page.reload();
+            await this.usersLink.click({ timeout: 180000, force: true });
+        }
+    }
+    async clickAssignedRolesTab() {
+        await (0, test_1.expect)(this.assignedRolesTab).toBeVisible({ timeout: 60000 });
+        await this.assignedRolesTab.click();
+    }
+    async clickDemoUser() {
+        await (0, test_1.expect)(this.demoUser).toBeVisible({ timeout: 60000 });
+        await this.demoUser.click({ timeout: 180000 });
+    }
+    async clickDeleteAccessButton(accessToDelete) {
+        try {
+            await this.page
+                .locator('td:right-of(:text("' + accessToDelete + '"))')
+                .first()
+                .click({ timeout: 60000 });
+        }
+        catch {
+            console.log('Access already deleted');
+        }
+    }
+    async clickConfirmDeleteButton() {
+        try {
+            await this.confirmDeleteButton.click();
+        }
+        catch {
+            console.log('Access already deleted');
+        }
+    }
+    async clickAssignRolesButton() {
+        await this.assignRolesButton.click();
+    }
+    async clickAddButton() {
+        await this.addButton.click();
+    }
+    async clickOperateCheckbox() {
+        await this.operateCheckbox.click();
+    }
+    async clickTasklistCheckbox() {
+        await this.tasklistCheckbox.click();
+    }
+    async clickOptimizeCheckbox() {
+        await this.optimizeCheckbox.click();
+    }
+    async clickModelerCheckbox() {
+        await this.modelerCheckbox.click();
+    }
+    async clickConsoleCheckbox() {
+        await this.consoleCheckbox.click();
+    }
+    async clickGroupsTab() {
+        await this.groupsTab.click({ timeout: 120000 });
+    }
+    async clickCreateGroupButton() {
+        const maxRetries = 3;
+        for (let retries = 0; retries < maxRetries; retries++) {
+            try {
+                if (!(await this.noGoupsHeading.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 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();
+            await this.assignMembersSearchbox.fill(name);
+            await this.assignMembersSearchResult.filter({ hasText: name }).click();
+        }
+    }
+    async clickAssignSubButton() {
+        await this.assignMembersSubButton.click();
+    }
+    async clickCreateGroupSubButton() {
+        await this.createGroupSubButton.click();
+    }
+    async deleteAllGroups() {
+        try {
+            await this.deleteButton
+                .first()
+                .waitFor({ state: 'visible', timeout: 120000 });
+            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 clickAuthorizationsTab() {
+        await this.authorizationsTab.click();
+    }
+    async clickTenantTab() {
+        await this.tenantTab.click();
+    }
+}
+exports.IdentityPage = IdentityPage;

package/dist/pages/SM-8.5/IdentityTenantPage.d.ts

@@ -0,0 +1,50 @@
+import { Page, Locator } from '@playwright/test';
+declare class IdentityTenantPage {
+    private page;
+    readonly createTenantMainButton: Locator;
+    readonly enterTenantNameInput: Locator;
+    readonly enterTenantIdInput: Locator;
+    readonly createTenantSubButton: Locator;
+    readonly assignedUsersTab: Locator;
+    readonly assignUsersButton: Locator;
+    readonly searchUsersInput: Locator;
+    readonly assignUserFinalButton: Locator;
+    readonly removeUserButton: Locator;
+    readonly removeButton: Locator;
+    readonly openSidebarButton: Locator;
+    readonly logoutButton: Locator;
+    readonly assignedApplicationsTab: Locator;
+    readonly searchApplicationsInput: Locator;
+    readonly assignApplicationsButtonFinal: Locator;
+    readonly assignApplicationsButton: Locator;
+    readonly rows: Locator;
+    readonly confirmDeleteInput: Locator;
+    readonly dangerDeleteButton: Locator;
+    constructor(page: Page);
+    clickCreateTenantMainButton(): Promise<void>;
+    clickCreateTenantSubButton(): Promise<void>;
+    clickEnterTenantNameInput(): Promise<void>;
+    fillEnterTenantNameInput(tenantName: string): Promise<void>;
+    clickEnterTenantIdInput(): Promise<void>;
+    fillEnterTenantIdInput(tenantId: string): Promise<void>;
+    clickAssignedUsersTab(): Promise<void>;
+    clickAssignUsersButton(): Promise<void>;
+    clickSearchUsersInput(): Promise<void>;
+    fillSearchUsersInput(user: string): Promise<void>;
+    clickAssignUserFinalButton(): Promise<void>;
+    clickRemoveUserButton(): Promise<void>;
+    clickRemoveButton(): Promise<void>;
+    createTenant(tenantName: string): Promise<void>;
+    deleteTenant(tenantName: string, tenant: Locator): Promise<void>;
+    assignUserToTenant(tenantName: string, user: string, userEmail: string): Promise<void>;
+    removeUserFromTenant(tenantName: string): Promise<void>;
+    clickOpenSidebarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+    assignClientToTenant(clientName: string): Promise<void>;
+    clickAssignedApplicationsTab(): Promise<void>;
+    clickSearchApplicationsInput(): Promise<void>;
+    fillSearchApplicationsInput(clientName: string): Promise<void>;
+    clickAssignApplicationsButtonFinal(): Promise<void>;
+    clickAssignApplicationsButton(): Promise<void>;
+}
+export { IdentityTenantPage };

package/dist/pages/SM-8.5/IdentityTenantPage.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityTenantPage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class IdentityTenantPage {
+    page;
+    createTenantMainButton;
+    enterTenantNameInput;
+    enterTenantIdInput;
+    createTenantSubButton;
+    assignedUsersTab;
+    assignUsersButton;
+    searchUsersInput;
+    assignUserFinalButton;
+    removeUserButton;
+    removeButton;
+    openSidebarButton;
+    logoutButton;
+    assignedApplicationsTab;
+    searchApplicationsInput;
+    assignApplicationsButtonFinal;
+    assignApplicationsButton;
+    rows;
+    confirmDeleteInput;
+    dangerDeleteButton;
+    constructor(page) {
+        this.page = page;
+        this.createTenantMainButton = page.getByRole('button', {
+            name: 'Create Tenant',
+        });
+        this.enterTenantNameInput = page.getByPlaceholder('Enter tenant name');
+        this.enterTenantIdInput = page.getByPlaceholder('Enter tenant ID');
+        this.createTenantSubButton = page.getByRole('button', {
+            name: 'Create tenant',
+            exact: true,
+        });
+        this.assignedUsersTab = page.getByRole('tab', { name: 'Assigned users' });
+        this.assignedApplicationsTab = page.getByRole('tab', {
+            name: 'Assigned applications',
+        });
+        this.assignUsersButton = page.getByRole('button', { name: 'Assign users' });
+        this.searchUsersInput = page.getByPlaceholder('Search users');
+        this.assignUserFinalButton = page
+            .getByLabel('Assign users')
+            .getByRole('button', { name: 'Assign users' });
+        this.removeUserButton = page.getByLabel('Remove user');
+        this.removeButton = page.getByRole('button', { name: 'danger Remove' });
+        this.openSidebarButton = page.getByLabel('User menu');
+        this.logoutButton = page.getByRole('link', { name: 'Log out' });
+        this.assignedApplicationsTab = page.getByRole('tab', {
+            name: 'Assigned applications',
+        });
+        this.searchApplicationsInput = page.getByPlaceholder('Search applications');
+        this.assignApplicationsButtonFinal = page
+            .getByLabel('Assign applications')
+            .getByRole('button', { name: 'Assign applications' });
+        this.assignApplicationsButton = page.getByRole('button', {
+            name: 'Assign applications',
+        });
+        this.rows = this.page.getByRole('row');
+        this.confirmDeleteInput = page.getByRole('textbox', {
+            name: 'Type the word DELETE to confirm',
+        });
+        this.dangerDeleteButton = page.getByRole('button', { name: 'danger Delete' });
+    }
+    async clickCreateTenantMainButton() {
+        await this.createTenantMainButton.click({ timeout: 60000 });
+    }
+    async clickCreateTenantSubButton() {
+        await this.createTenantSubButton.click({ timeout: 60000 });
+    }
+    async clickEnterTenantNameInput() {
+        await this.enterTenantNameInput.click();
+    }
+    async fillEnterTenantNameInput(tenantName) {
+        await this.enterTenantNameInput.fill(tenantName);
+    }
+    async clickEnterTenantIdInput() {
+        await this.enterTenantIdInput.click();
+    }
+    async fillEnterTenantIdInput(tenantId) {
+        await this.enterTenantIdInput.fill(tenantId);
+    }
+    async clickAssignedUsersTab() {
+        await this.assignedUsersTab.click({ timeout: 60000 });
+    }
+    async clickAssignUsersButton() {
+        await this.assignUsersButton.click();
+    }
+    async clickSearchUsersInput() {
+        await this.searchUsersInput.click();
+    }
+    async fillSearchUsersInput(user) {
+        await this.searchUsersInput.fill(user);
+    }
+    async clickAssignUserFinalButton() {
+        await this.assignUserFinalButton.click();
+    }
+    async clickRemoveUserButton() {
+        await this.removeUserButton.click();
+    }
+    async clickRemoveButton() {
+        await this.removeButton.click();
+    }
+    async createTenant(tenantName) {
+        await (0, sleep_1.sleep)(5000);
+        const tenant = this.rows.filter({ hasText: tenantName }).first();
+        if (await tenant.isVisible({ timeout: 20000 })) {
+            await this.deleteTenant(tenantName, tenant);
+        }
+        await this.clickCreateTenantMainButton();
+        await this.clickEnterTenantNameInput();
+        await this.fillEnterTenantNameInput(tenantName);
+        await this.clickEnterTenantIdInput();
+        await this.fillEnterTenantIdInput(tenantName);
+        await this.clickCreateTenantSubButton();
+        await (0, test_1.expect)(this.page.getByText('Tenant created')).toBeVisible({
+            timeout: 60000,
+        });
+        await (0, sleep_1.sleep)(30000);
+    }
+    async deleteTenant(tenantName, tenant) {
+        console.log(`Tenant ${tenantName} already exists, deleting.`);
+        const deleteButton = tenant.getByRole('button', { name: 'Delete' });
+        if (await deleteButton.isVisible()) {
+            await deleteButton.click({ force: true, timeout: 60000 });
+            await this.confirmDeleteInput.click({ force: true, timeout: 60000 });
+            await this.confirmDeleteInput.fill('DELETE', { timeout: 60000 });
+            const dangerDeleteButtons = await this.dangerDeleteButton.all();
+            const lastDangerDeleteButton = dangerDeleteButtons[dangerDeleteButtons.length - 1];
+            await lastDangerDeleteButton.click();
+            await (0, test_1.expect)(this.page.getByText('Deleting...')).not.toBeVisible({
+                timeout: 60000,
+            });
+            await (0, sleep_1.sleep)(1000);
+        }
+    }
+    async assignUserToTenant(tenantName, user, userEmail) {
+        await this.page.getByText(tenantName).first().click();
+        await this.clickAssignedUsersTab();
+        await this.clickAssignUsersButton();
+        await this.clickSearchUsersInput();
+        await this.fillSearchUsersInput(user);
+        await this.page.getByText(userEmail).click();
+        await this.clickAssignUserFinalButton();
+        await (0, test_1.expect)(this.page.getByText('Users assigned')).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async removeUserFromTenant(tenantName) {
+        await this.page.getByText(tenantName).first().click();
+        await this.clickAssignedUsersTab();
+        await this.clickRemoveUserButton();
+        await this.clickRemoveButton();
+        await (0, test_1.expect)(this.page.getByText('users.Entity removed')).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickOpenSidebarButton() {
+        await this.openSidebarButton.click({ timeout: 60000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 60000 });
+    }
+    async assignClientToTenant(clientName) {
+        if (await this.page
+            .getByText(clientName, { exact: true })
+            .isVisible({ timeout: 30000 })) {
+            return;
+        }
+        else {
+            await this.clickAssignedApplicationsTab();
+            await this.clickAssignApplicationsButton();
+            await this.clickSearchApplicationsInput();
+            await this.fillSearchApplicationsInput(clientName);
+            await this.page
+                .getByText(clientName, { exact: true })
+                .click({ timeout: 60000, force: true });
+            await this.clickAssignApplicationsButtonFinal();
+            await (0, test_1.expect)(this.page.getByText('Applications assigned')).toBeVisible({
+                timeout: 60000,
+            });
+        }
+    }
+    async clickAssignedApplicationsTab() {
+        await this.assignedApplicationsTab.click({ timeout: 60000 });
+    }
+    async clickSearchApplicationsInput() {
+        await this.searchApplicationsInput.click({ timeout: 60000 });
+    }
+    async fillSearchApplicationsInput(clientName) {
+        await this.searchApplicationsInput.fill(clientName);
+    }
+    async clickAssignApplicationsButtonFinal() {
+        await this.assignApplicationsButtonFinal.click({ timeout: 60000 });
+    }
+    async clickAssignApplicationsButton() {
+        await this.assignApplicationsButton.click({ timeout: 60000 });
+    }
+}
+exports.IdentityTenantPage = IdentityTenantPage;