@camunda/e2e-test-suite 0.0.1443 → 0.0.1444

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeycloakUser = exports.createUser = exports.setupKeycloakUser = exports.keycloakAdminCredentials = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+const keycloakAdminCredentials = () => {
+    return {
+        username: process.env.DISTRO_QA_E2E_TESTS_KEYCLOAK_USERNAME || 'admin',
+        password: process.env.DISTRO_QA_E2E_TESTS_KEYCLOAK_PASSWORD,
+    };
+};
+exports.keycloakAdminCredentials = keycloakAdminCredentials;
+const setupKeycloakUser = async (navigationPage, identityPage, keycloakLoginPage, keycloakAdminPage, ocIdentityHomePage, ocIdentityRolesPage, assignToDefaultTenant = false, managementIdentityTenantPage) => {
+    const testUsername = `test-user-${new Date().getTime()}-${Math.random()
+        .toString(36)
+        .substring(7)}`;
+    const testPassword = 'test-password';
+    await createKeycloakUser(navigationPage, keycloakLoginPage, keycloakAdminPage, testUsername, testPassword);
+    await createIdentityUser(navigationPage, identityPage, testUsername);
+    if (assignToDefaultTenant && managementIdentityTenantPage) {
+        const userEmail = `qacamunda+${testUsername}@gmail.com`;
+        await navigationPage.goToManagementIdentity();
+        await (0, test_1.expect)(identityPage.usersLink).toBeVisible({ timeout: 10000 });
+        if (await identityPage.tenantTab.isVisible()) {
+            await managementIdentityTenantPage.assignUserToTenant('Default', testUsername, userEmail);
+        }
+    }
+    await createOCUser(navigationPage, ocIdentityHomePage, ocIdentityRolesPage, testUsername);
+    return { testUsername, testPassword };
+};
+exports.setupKeycloakUser = setupKeycloakUser;
+async function createUser(navigationPage, identityPage, keycloakLoginPage, keycloakAdminPage, username, password) {
+    await createKeycloakUser(navigationPage, keycloakLoginPage, keycloakAdminPage, username, password);
+    await createIdentityUser(navigationPage, identityPage, username);
+}
+exports.createUser = createUser;
+// Keycloak occasionally serves "We are sorry... Unexpected error when
+// handling authentication request to identity provider" instead of
+// completing the admin login (the same transient 5xx NavigationPage.goTo's
+// progressive backoff already guards against for app logins). This flow logs
+// into the Keycloak admin console directly rather than through goTo, so it
+// needs the same retry of the whole login sequence instead of failing the
+// test outright on the first hit.
+async function loginToKeycloakAdmin(navigationPage, keycloakLoginPage, keycloakAdminPage, maxRetries = 5) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            await navigationPage.goToKeycloak();
+            await keycloakLoginPage.toBeVisible();
+            await keycloakLoginPage.fillUsername((0, exports.keycloakAdminCredentials)().username);
+            await keycloakLoginPage.fillPassword((0, exports.keycloakAdminCredentials)().password);
+            await keycloakLoginPage.clickLogin();
+            await keycloakAdminPage.toBeVisible();
+            return;
+        }
+        catch (error) {
+            if (attempt >= maxRetries - 1) {
+                throw error;
+            }
+            console.warn(`[KeycloakUtils] Keycloak admin login attempt ${attempt + 1} failed, retrying: ${error instanceof Error ? error.message : error}`);
+            await (0, sleep_1.sleep)(2000 * (attempt + 1));
+        }
+    }
+}
+async function createKeycloakUser(navigationPage, keycloakLoginPage, keycloakAdminPage, username, password) {
+    await loginToKeycloakAdmin(navigationPage, keycloakLoginPage, keycloakAdminPage);
+    await keycloakAdminPage.switchToCamundaPlatform();
+    await keycloakAdminPage.clickUsersTab();
+    await keycloakAdminPage.clickAddUser();
+    await keycloakAdminPage.fillUser(username);
+    await keycloakAdminPage.saveUser();
+    await keycloakAdminPage.fillPassword(password);
+    await keycloakAdminPage.savePassword();
+}
+exports.createKeycloakUser = createKeycloakUser;
+const createIdentityUser = async (navigationPage, managementIdentity, username) => {
+    await navigationPage.goToManagementIdentity();
+    await managementIdentity.clickUsersLink();
+    await managementIdentity.clickUser(username);
+    await managementIdentity.clickAssignedRolesTab();
+    await managementIdentity.clickAssignRolesButton();
+    if (process.env.IS_OPTIMIZE !== 'false') {
+        await managementIdentity.clickOptimizeCheckbox();
+    }
+    await managementIdentity.clickModelerCheckbox();
+    await managementIdentity.clickIdentityCheckbox();
+    await managementIdentity.clickOrchestrationCheckbox();
+    await managementIdentity.clickAddButton();
+};
+const createOCUser = async (navigationPage, ocIdentityHomePage, ocIdentityRolesPage, username) => {
+    await navigationPage.goToOCAdmin();
+    await ocIdentityHomePage.clickRolesTab();
+    await ocIdentityRolesPage.clickAdminRole();
+    await ocIdentityRolesPage.assignUserToRole(username);
+};

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

@@ -0,0 +1,21 @@
+import { Page, Locator } from '@playwright/test';
+declare class LoginPage {
+    private page;
+    readonly usernameInput: Locator;
+    readonly passwordInput: Locator;
+    readonly loginButton: Locator;
+    readonly coreUsernameInput: Locator;
+    readonly corePasswordInput: Locator;
+    readonly coreLoginButton: Locator;
+    readonly keycloakBanner: Locator;
+    private useCore;
+    private useKeycloak;
+    constructor(page: Page);
+    detectLoginForm(): Promise<void>;
+    fillUsername(username: string): Promise<void>;
+    clickUsername(): Promise<void>;
+    fillPassword(password: string): Promise<void>;
+    clickLoginButton(): Promise<void>;
+    login(username: string, password: string): Promise<boolean>;
+}
+export { LoginPage };

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoginPage = void 0;
+class LoginPage {
+    page;
+    usernameInput;
+    passwordInput;
+    loginButton;
+    coreUsernameInput;
+    corePasswordInput;
+    coreLoginButton;
+    keycloakBanner;
+    useCore = false;
+    useKeycloak = false;
+    constructor(page) {
+        this.page = page;
+        this.usernameInput = page.getByLabel('Username or email');
+        this.passwordInput = page.getByLabel('Password');
+        this.loginButton = page.getByRole('button', { name: /log in|sign in/i });
+        this.coreUsernameInput = page.getByPlaceholder('Username');
+        this.corePasswordInput = page.getByPlaceholder('Password');
+        this.coreLoginButton = page.getByRole('button', { name: 'Login' });
+        this.keycloakBanner = page.locator('body#keycloak-bg[data-page-id="login-login"]');
+    }
+    async detectLoginForm() {
+        // If we're on an app page that's about to redirect to KC, wait for
+        // the navigation to complete before looking for login form elements.
+        const url = this.page.url();
+        if (!url.includes('/auth/') && !url.includes('/login-callback')) {
+            await this.page
+                .waitForURL((u) => u.pathname.includes('/auth/'), {
+                timeout: 30000,
+                waitUntil: 'domcontentloaded',
+            })
+                .catch(() => { });
+        }
+        const kcUsername = this.page.locator('#username');
+        const anyForm = kcUsername
+            .or(this.coreLoginButton)
+            .or(this.keycloakBanner)
+            .first();
+        await anyForm.waitFor({ state: 'visible', timeout: 30000 });
+        if (await this.coreLoginButton.isVisible()) {
+            this.useCore = true;
+        }
+        else if (await this.keycloakBanner.isVisible()) {
+            this.useKeycloak = true;
+        }
+    }
+    async fillUsername(username) {
+        if (await this.page.locator('#username').isVisible()) {
+            await this.page.fill('#username', username);
+        }
+        else {
+            await (this.useCore
+                ? this.coreUsernameInput.fill(username)
+                : this.usernameInput.fill(username));
+        }
+    }
+    async clickUsername() {
+        if (await this.page.locator('#username').isVisible()) {
+            await this.page.click('#username');
+        }
+        else {
+            await (this.useCore
+                ? this.coreUsernameInput.click({ timeout: 60000 })
+                : this.usernameInput.click({ timeout: 60000 }));
+        }
+    }
+    async fillPassword(password) {
+        if (await this.page.locator('#password').isVisible()) {
+            await this.page.fill('#password', password);
+        }
+        else {
+            await (this.useCore
+                ? this.corePasswordInput.fill(password)
+                : this.passwordInput.fill(password));
+        }
+    }
+    async clickLoginButton() {
+        if (await this.page.locator('button[type="submit"]').isVisible()) {
+            // The Keycloak submit path was the only click here without an explicit
+            // timeout, so it inherited the 10s actionTimeout while page.click waits
+            // out the OAuth redirect chain it triggers. Match the 60s budget the
+            // sibling branches already use.
+            await this.page.click('button[type="submit"]', { timeout: 60000 });
+        }
+        else {
+            await (this.useCore
+                ? this.coreLoginButton.click({ timeout: 60000 })
+                : this.loginButton.click({ timeout: 60000 }));
+        }
+    }
+    // Resolves to whether credentials were actually submitted. A missing form is
+    // not an error -- the caller may already hold a session, in which case there
+    // is nothing to fill -- but the caller has to be able to tell that apart from
+    // a submitted form, because only the latter leaves a page transition pending.
+    async login(username, password) {
+        try {
+            await this.detectLoginForm();
+        }
+        catch (error) {
+            return false;
+        }
+        await this.clickUsername();
+        await this.fillUsername(username);
+        await this.fillPassword(password);
+        await this.clickLoginButton();
+        return true;
+    }
+}
+exports.LoginPage = LoginPage;

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

@@ -0,0 +1,44 @@
+import { Page, Locator } from '@playwright/test';
+declare class ManagementIdentityPage {
+    private page;
+    readonly identityBanner: Locator;
+    readonly usersLink: Locator;
+    readonly assignedRolesTab: Locator;
+    readonly demoUser: Locator;
+    readonly confirmDeleteButton: Locator;
+    readonly assignRolesButton: Locator;
+    readonly addButton: Locator;
+    readonly optimizeCheckbox: Locator;
+    readonly modelerCheckbox: Locator;
+    readonly deleteButton: Locator;
+    readonly deleteSubButton: Locator;
+    readonly tenantTab: Locator;
+    readonly licenseKeyTagNonProduction: Locator;
+    readonly licenseKeyTagNonCommercial: Locator;
+    readonly licenseKeyTagProduction: Locator;
+    readonly licenseKeyTagCommercial: Locator;
+    readonly modelerAdminCheckbox: Locator;
+    readonly identityCheckbox: Locator;
+    readonly openSidebarButton: Locator;
+    readonly logoutButton: Locator;
+    readonly orchestrationCheckbox: Locator;
+    constructor(page: Page);
+    clickUsersLink(): Promise<void>;
+    clickUser(username: string): Promise<void>;
+    clickAssignedRolesTab(): Promise<void>;
+    clickDemoUser(): Promise<void>;
+    clickDeleteAccessButton(accessToDelete: string | string[]): Promise<void>;
+    clickConfirmDeleteButton(): Promise<void>;
+    clickAssignRolesButton(): Promise<void>;
+    clickAddButton(): Promise<void>;
+    clickOptimizeCheckbox(): Promise<void>;
+    clickModelerCheckbox(): Promise<void>;
+    clickIdentityCheckbox(): Promise<void>;
+    clickModelerAdminCheckbox(): Promise<void>;
+    clickUserGroup(name: string): Promise<void>;
+    clickTenantTab(): Promise<void>;
+    clickOpenSidebarButton(): Promise<void>;
+    clickLogoutButton(): Promise<void>;
+    clickOrchestrationCheckbox(): Promise<void>;
+}
+export { ManagementIdentityPage };

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

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagementIdentityPage = void 0;
+const test_1 = require("@playwright/test");
+class ManagementIdentityPage {
+    page;
+    identityBanner;
+    usersLink;
+    assignedRolesTab;
+    demoUser;
+    confirmDeleteButton;
+    assignRolesButton;
+    addButton;
+    optimizeCheckbox;
+    modelerCheckbox;
+    deleteButton;
+    deleteSubButton;
+    tenantTab;
+    licenseKeyTagNonProduction;
+    licenseKeyTagNonCommercial;
+    licenseKeyTagProduction;
+    licenseKeyTagCommercial;
+    modelerAdminCheckbox;
+    identityCheckbox;
+    openSidebarButton;
+    logoutButton;
+    orchestrationCheckbox;
+    constructor(page) {
+        this.page = page;
+        this.identityBanner = page
+            .locator('a')
+            .filter({ hasText: /^Camunda logo\s*Management Identity$/ })
+            .first();
+        this.usersLink = page.locator('a').filter({ hasText: 'Users' });
+        this.tenantTab = page
+            .getByRole('link', { name: 'Tenants' })
+            .or(page.locator('a').filter({ hasText: 'Tenants' }))
+            .first();
+        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.optimizeCheckbox = page
+            .locator('label')
+            .filter({ hasText: 'Optimize (Grants full access to Optimize)' });
+        // The chart's Keycloak preset (camunda-platform-helm#6896) renamed the Hub
+        // application and added "Hub"/"Hub Admin" roles while keeping the identical
+        // legacy "Web Modeler"/"Web Modeler Admin" roles for 8.10-alpha upgrades,
+        // so the straddle alternation that matched either wording now resolves to
+        // two rows and trips strict mode. Both roles grant the same permissions on
+        // the same application; target the go-forward "Hub" name, which is also
+        // what the chart assigns its own QA users. The `for` attribute is the role
+        // name, so this survives further description rewording.
+        this.modelerCheckbox = page.locator('label[for="Hub"]');
+        this.identityCheckbox = page.locator('label').filter({
+            hasText: 'ManagementIdentity (Provides full access to Management Identity)',
+        });
+        this.deleteSubButton = page.getByRole('button', { name: 'danger delete' });
+        this.deleteButton = page.locator('button', { hasText: 'danger' });
+        this.licenseKeyTagNonProduction = page
+            .getByText('Non-production license')
+            .first();
+        this.licenseKeyTagNonCommercial = page.getByText('Non-commercial license');
+        this.licenseKeyTagProduction = page.getByText('Production license').first();
+        this.licenseKeyTagCommercial = page.getByText('Commercial license');
+        // Same two-role split as `modelerCheckbox` above.
+        this.modelerAdminCheckbox = page.locator('label[for="Hub Admin"]');
+        this.openSidebarButton = page.getByLabel('Open User Sidebar');
+        this.logoutButton = page.getByRole('button', { name: 'Log out' });
+        this.orchestrationCheckbox = page.locator('label').filter({
+            hasText: 'Orchestration (Grants full access to Orchestration)',
+        });
+    }
+    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 clickUser(username) {
+        const searchbox = this.page.getByRole('searchbox');
+        await searchbox.click({ timeout: 30000 });
+        await searchbox.fill(username);
+        const user = this.page.getByRole('cell', { name: username, exact: true });
+        await (0, test_1.expect)(user).toBeVisible({ timeout: 60000 });
+        await user.click();
+    }
+    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 });
+    }
+    // The assigned-roles table can come up with a stale row set shortly after the
+    // roles were assigned — run 32920068272 recorded `/api/users/<id>/roles`
+    // returning Optimize while the table repeated the neighbouring row's label —
+    // and it does not re-render on its own. Rebuild it from a fresh response
+    // between attempts before reporting the role as missing.
+    async clickDeleteAccessButton(accessToDelete) {
+        const candidates = typeof accessToDelete === 'string' ? [accessToDelete] : accessToDelete;
+        const rowSelector = candidates.map((c) => `:text("${c}")`).join(', ');
+        const roleRow = this.page.locator(rowSelector).first();
+        for (let attempt = 1; attempt <= 2; attempt++) {
+            const rowVisible = await roleRow
+                .waitFor({ state: 'visible', timeout: 30000 })
+                .then(() => true)
+                .catch(() => false);
+            if (rowVisible) {
+                break;
+            }
+            await this.page.reload({ waitUntil: 'domcontentloaded' });
+            await this.clickAssignedRolesTab();
+        }
+        await (0, test_1.expect)(roleRow, `No assigned role matching ${candidates
+            .map((c) => `"${c}"`)
+            .join(' or ')} was found. The role may already be removed, or its ` +
+            `label may have changed in this version.`).toBeVisible({ timeout: 60000 });
+        // Click the Delete control inside the matched role's own table row. A
+        // `td:right-of(:text(...))` spatial match resolves to a neighbouring row's
+        // button once the roles table carries rows before the target (Orchestration
+        // is ordered above Hub), so it removed the wrong role and left the intended
+        // one still assigned.
+        await this.page
+            .locator('tr')
+            .filter({ has: this.page.locator(rowSelector) })
+            .first()
+            .getByRole('button', { name: 'Delete' })
+            .click({ timeout: 60000 });
+    }
+    async clickConfirmDeleteButton() {
+        await (0, test_1.expect)(this.confirmDeleteButton, 'The delete-role confirmation dialog did not appear.').toBeVisible({ timeout: 60000 });
+        await this.confirmDeleteButton.click();
+    }
+    async clickAssignRolesButton() {
+        await this.assignRolesButton.click();
+    }
+    async clickAddButton() {
+        await this.addButton.click();
+    }
+    async clickOptimizeCheckbox() {
+        await this.optimizeCheckbox.click();
+    }
+    async clickModelerCheckbox() {
+        await this.modelerCheckbox.click();
+    }
+    async clickIdentityCheckbox() {
+        await this.identityCheckbox.click();
+    }
+    async clickModelerAdminCheckbox() {
+        await this.modelerAdminCheckbox.click();
+    }
+    async clickUserGroup(name) {
+        await this.page.getByRole('cell', { name: name }).click();
+    }
+    async clickTenantTab() {
+        await this.tenantTab.click();
+    }
+    async clickOpenSidebarButton() {
+        await this.openSidebarButton.click({ timeout: 60000 });
+    }
+    async clickLogoutButton() {
+        await this.logoutButton.click({ timeout: 60000 });
+    }
+    async clickOrchestrationCheckbox() {
+        await this.orchestrationCheckbox.click();
+    }
+}
+exports.ManagementIdentityPage = ManagementIdentityPage;