@camunda/e2e-test-suite 0.0.1478 → 0.0.1480

package/dist/pages/8.8/FormJsPage.js

@@ -209,7 +209,21 @@ class FormJsPage {
                 throw new Error(`The deploy dialog does not offer "${clusterName}": its stage ` +
                     'binding did not take. It will be rebound on the next attempt.');
             }
-            return;
+            // The probe above runs the instant the dialog opens, before its cluster
+            // list has rendered, so a selectable list can be mistaken for the
+            // auto-selecting one. The dialog then deploys to whichever cluster it
+            // pre-selected: a nightly trace shows the form going to "Test Cluster"
+            // while "AWS Cluster" was requested, so the user task linking it never
+            // reached Tasklist. Re-probe now that the name has rendered and select
+            // the cluster explicitly when it turns out to be a list row.
+            const isSelectableRow = await legacyClusterToggle
+                .first()
+                .waitFor({ state: 'visible', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!isSelectableRow) {
+                return;
+            }
         }
         // "HealthydevManage" was the Carbon row's chrome concatenated together.
         // The design-system dialog renders the cluster row as

package/dist/pages/8.8/ModelerCreatePage.js

@@ -879,7 +879,20 @@ class ModelerCreatePage {
                 throw new Error(`The deploy dialog does not offer "${clusterName}": its stage ` +
                     'binding did not take. It will be rebound on the next attempt.');
             }
-            return;
+            // The probe above runs the instant the dialog opens, before its cluster
+            // list has rendered, so a selectable list can be mistaken for the
+            // auto-selecting one and the run goes to whichever cluster the dialog
+            // pre-selected (seen in FormJsPage.selectCluster's nightly trace).
+            // Re-probe now that the name has rendered and select the cluster
+            // explicitly when it turns out to be a list row.
+            const isSelectableRow = await legacyClusterToggle
+                .first()
+                .waitFor({ state: 'visible', timeout: 5000 })
+                .then(() => true)
+                .catch(() => false);
+            if (!isSelectableRow) {
+                return;
+            }
         }
         const healthyRegex = new RegExp(`${clusterName}.*?Healthy`);
         const clusterLabel = this.dialog

package/dist/pages/8.8/ModelerHomePage.js

@@ -1169,7 +1169,19 @@ class ModelerHomePage {
         // rows. Fall back to clicking the row itself (it is `cursor-pointer` and
         // handles the row activation) when the id is not exposed.
         const rowMenuTrigger = projectEntryRow.locator('[data-test="project-row-menu-trigger"]');
-        if (await this.becameVisible(rowMenuTrigger, 10000)) {
+        let rowVisible = await this.becameVisible(rowMenuTrigger, 10000);
+        // Hub can drop the session while the list loads (its projects call answers
+        // 230 and the SPA bounces to /login), so the probe above misses a project
+        // that exists and the create branch below adds an empty duplicate -- in
+        // which the caller's diagram can never be found. Re-sign-in (often a
+        // silent SSO round trip that has already finished by now, so do not gate
+        // on recoverModelerSession's result) returns the browser to this list;
+        // look again before creating anything.
+        if (!rowVisible) {
+            await this.recoverModelerSession();
+            rowVisible = await this.becameVisible(rowMenuTrigger, 30000);
+        }
+        if (rowVisible) {
             const projectId = await rowMenuTrigger.getAttribute('data-project-id');
             const workspaceId = new URL(this.page.url()).pathname.match(/\/workspaces\/([^/]+)/)?.[1];
             if (workspaceId) {

package/dist/pages/SM-8.10/ConnectorTemplatePage.d.ts

@@ -6,6 +6,7 @@ declare class ConnectorTemplatePage {
     constructor(page: Page);
     clickPublishToOrgButton(): Promise<void>;
     clickPublishButton(): Promise<void>;
+    publishImportedTemplateToWorkspace(version: number): Promise<void>;
     publishConnector(): Promise<void>;
 }
 export { ConnectorTemplatePage };

package/dist/pages/SM-8.10/ConnectorTemplatePage.js

@@ -20,6 +20,21 @@ class ConnectorTemplatePage {
     async clickPublishButton() {
         await this.publishButton.click({ timeout: 90000 });
     }
+    async publishImportedTemplateToWorkspace(version) {
+        await this.page.getByRole('button', { name: 'Publish', exact: true }).click();
+        await this.page
+            .getByRole('menuitem', { name: 'Publish to workspace', exact: true })
+            .click();
+        const dialog = this.page.getByRole('dialog').filter({
+            has: this.page.getByRole('heading', {
+                name: 'Publish version to workspace',
+                exact: true,
+            }),
+        });
+        await (0, test_1.expect)(dialog.getByRole('spinbutton', { name: 'Version number', exact: true })).toHaveValue(String(version));
+        await dialog.getByRole('button', { name: 'Publish', exact: true }).click();
+        await (0, test_1.expect)(dialog).toBeHidden({ timeout: 60000 });
+    }
     async publishConnector() {
         try {
             await (0, test_1.expect)(this.publishToOrgButton).toBeVisible({ timeout: 15000 });

package/dist/pages/SM-8.10/ModelerCreatePage.d.ts

@@ -175,6 +175,17 @@ declare class ModelerCreatePage {
     openChangeElementPopupForElement(elementId: string): Promise<void>;
     private clickChangeElementTemplateOption;
     assertChangeElementTemplateListed(option: Locator, searchTerm: string, elementId: string): Promise<void>;
+    appendTemplateTarget(previousElementId: string, type: 'task' | 'receiveTask' | 'intermediateCatchEvent'): Promise<string>;
+    applyImportedTemplate(elementId: string, template: {
+        id: string;
+        name: string;
+    }): Promise<void>;
+    assertExportedTemplateBindings(bindings: {
+        elementId: string;
+        id: string;
+        version: number;
+        elementType: string;
+    }[]): Promise<void>;
     changeElementToAdHocSubProcess(elementId: string): Promise<void>;
     applyAiAgentSubProcessTemplate(): Promise<void>;
     clickWebhookMessageStartEventConnectorOption(): Promise<void>;

package/dist/pages/SM-8.10/ModelerCreatePage.js

@@ -1424,6 +1424,84 @@ class ModelerCreatePage {
         await (0, test_1.expect)(option).toBeVisible({ timeout: 30000 });
         await (0, test_1.expect)(option).toBeEnabled({ timeout: 30000 });
     }
+    async appendTemplateTarget(previousElementId, type) {
+        const previous = this.page.locator(`.djs-shape[data-element-id="${previousElementId}"]`);
+        await this.page.keyboard.press('Escape');
+        if (!(await previous.evaluate((shape) => shape.classList.contains('selected')))) {
+            await previous.click();
+        }
+        await this.page
+            .getByRole('button', {
+            name: type === 'intermediateCatchEvent'
+                ? 'Append intermediate/boundary event'
+                : 'Append task',
+            exact: true,
+        })
+            .click();
+        const selected = this.page.locator('.djs-shape.selected');
+        await (0, test_1.expect)(selected).not.toHaveAttribute('data-element-id', previousElementId);
+        const elementId = await selected.getAttribute('data-element-id');
+        if (!elementId)
+            throw new Error('The appended template target has no ID.');
+        if (type !== 'task') {
+            await this.openChangeElementPopupForElement(elementId);
+            await this.changeElementSearchInput.fill('');
+            await this.changeElementSearchInput.pressSequentially(type === 'receiveTask'
+                ? 'Receive task'
+                : 'Message intermediate catch event');
+            const entry = type === 'receiveTask'
+                ? 'replace-with-receive-task'
+                : 'replace-with-message-intermediate-catch';
+            await this.page.locator(`.djs-popup [data-id="${entry}"]`).click();
+        }
+        return elementId;
+    }
+    async applyImportedTemplate(elementId, template) {
+        const option = this.page.locator(`.djs-popup [data-id="replace.template-${template.id}"]`);
+        await this.assertChangeElementTemplateListed(option, template.name, elementId);
+        await option.click();
+        await (0, test_1.expect)(this.changeElementSearchInput).toBeHidden();
+        const selected = this.page.locator(`.djs-shape[data-element-id="${elementId}"]`);
+        await (0, test_1.expect)(selected).toHaveClass(/(?:^|\s)selected(?:\s|$)/);
+        const details = this.page.getByRole('region', { name: 'Details panel' });
+        await (0, test_1.expect)(details
+            .locator('[data-test="properties-panel-header-container"]')
+            .getByText(template.name, { exact: true })).toBeVisible();
+        await (0, test_1.expect)(details.getByText('Applied', { exact: true })).toBeVisible();
+        await (0, test_1.expect)(this.templateNotFoundTag).toBeHidden();
+    }
+    async assertExportedTemplateBindings(bindings) {
+        await this.page
+            .getByRole('button', { name: 'Browse more actions', exact: true })
+            .click();
+        const downloadPromise = this.page.waitForEvent('download');
+        await this.page
+            .getByRole('menuitem', { name: 'Download as BPMN 2.0 XML', exact: true })
+            .click();
+        const download = await downloadPromise;
+        const stream = await download.createReadStream();
+        if (!stream)
+            throw new Error('The BPMN download has no readable content.');
+        const chunks = [];
+        for await (const chunk of stream)
+            chunks.push(Buffer.from(chunk));
+        const xml = Buffer.concat(chunks).toString('utf8');
+        const actual = await this.page.evaluate(({ xml, bindings }) => {
+            const document = new DOMParser().parseFromString(xml, 'application/xml');
+            if (document.querySelector('parsererror'))
+                throw new Error('Invalid BPMN XML.');
+            return bindings.map(({ elementId }) => {
+                const element = Array.from(document.getElementsByTagName('*')).find((element) => element.getAttribute('id') === elementId);
+                return {
+                    elementId,
+                    id: element?.getAttribute('zeebe:modelerTemplate'),
+                    version: Number(element?.getAttribute('zeebe:modelerTemplateVersion')),
+                    elementType: element?.localName,
+                };
+            });
+        }, { xml, bindings });
+        (0, test_1.expect)(actual).toEqual(bindings);
+    }
     // Turns the appended task into an ad-hoc sub-process through the
     // change-element popup. The popup is filtered first: it virtualizes its list.
     async changeElementToAdHocSubProcess(elementId) {

package/dist/pages/SM-8.10/ModelerHomePage.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { Browser, Page, Locator } from '@playwright/test';
 declare class ModelerHomePage {
     private page;
@@ -75,7 +76,7 @@ declare class ModelerHomePage {
     private openWorkspaceTile;
     private openOrCreateLegacyFolder;
     private dismissModals;
-    clickProcessDiagram(name: string): Promise<void>;
+    clickProcessDiagram(name: string, exact?: boolean): Promise<void>;
     clickHomeBreadcrumb(): Promise<void>;
     clickChooseBpmnTemplateButton(): Promise<void>;
     clickDiagramTypeDropdown(): Promise<void>;
@@ -86,7 +87,15 @@ declare class ModelerHomePage {
     private waitForEntityCrumb;
     clickProjectBreadcrumb(): Promise<void>;
     clickWorkspaceBreadcrumb(): Promise<void>;
-    enterResourceContainer(name?: string): Promise<void>;
+    enterResourceContainer(name?: string, options?: {
+        configureEnvironment?: boolean;
+    }): Promise<void>;
+    uploadTemplateFiles(files: {
+        name: string;
+        buffer: Buffer;
+    }[]): Promise<void>;
+    private importedTemplateRow;
+    openImportedTemplate(resourceName: string): Promise<void>;
     private clickCreateProcessApplication;
     private ensureInResourceContainer;
     returnToResourceContainer(): Promise<void>;

package/dist/pages/SM-8.10/ModelerHomePage.js

@@ -669,16 +669,20 @@ class ModelerHomePage {
     // entirely (to Optimize, to Operate) and come back via
     // clickCrossComponentProjectFolder(), which lands at workspace root -- the
     // resource is one level down, so re-enter the container first.
-    async clickProcessDiagram(name) {
+    async clickProcessDiagram(name, exact = false) {
         await this.ensureInResourceContainer();
         // A Design System table row opens through a link laid over the row, which
         // sits on top of the title text and takes its clicks -- so click the link.
         // The link comes before the title in DOM order, so `first()` picks it
         // whenever it exists; the title stays as the fallback for the classic table.
-        const row = this.rows.filter({ hasText: name });
+        const row = exact
+            ? this.importedTemplateRow(name)
+            : this.rows.filter({ hasText: name });
+        if (exact)
+            await (0, test_1.expect)(row).toHaveCount(1);
         const process = row
-            .getByRole('link', { name })
-            .or(row.getByTitle(name))
+            .getByRole('link', { name, exact })
+            .or(row.getByTitle(name, { exact }))
             .first();
         await (0, test_1.expect)(process).toBeVisible({ timeout: 90000 });
         await process.click();
@@ -877,7 +881,7 @@ class ModelerHomePage {
     // One container per test rather than one shared with the seeded workspace:
     // deploying is process-application-wide, so a shared container would let one
     // spec's deploy pick up every other spec's half-modelled diagram.
-    async enterResourceContainer(name) {
+    async enterResourceContainer(name, options = {}) {
         if (this.processApplicationUrl) {
             const stillInside = await this.becameVisible(this.processApplicationPage.breadcrumb, 5000);
             if (!stillInside) {
@@ -902,7 +906,41 @@ class ModelerHomePage {
         // this connection step (or failing on the warning). ensureStageCluster()
         // memoizes per test, so runProcessInstance()'s own call is a no-op after
         // this.
-        await this.processApplicationPage.ensureStageCluster(process.env.MODELER_CLUSTER_NAME);
+        if (options.configureEnvironment !== false) {
+            await this.processApplicationPage.ensureStageCluster(process.env.MODELER_CLUSTER_NAME);
+        }
+    }
+    async uploadTemplateFiles(files) {
+        await (0, test_1.expect)(this.processApplicationPage.createNewDropdown).toBeVisible({
+            timeout: 30000,
+        });
+        for (const file of files) {
+            await (0, test_1.expect)(this.importedTemplateRow(file.name.replace(/\.json$/, ''))).toHaveCount(0);
+        }
+        await this.processApplicationPage.createNewDropdown.click();
+        const chooserPromise = this.page.waitForEvent('filechooser');
+        await this.page
+            .getByRole('menuitem', { name: 'Upload files', exact: true })
+            .click();
+        await (await chooserPromise).setFiles(files.map((file) => ({ ...file, mimeType: 'application/json' })));
+        // The batch handler can report success for a partial upload.
+        for (const file of files) {
+            const row = this.importedTemplateRow(file.name.replace(/\.json$/, ''));
+            await (0, test_1.expect)(row).toHaveCount(1, { timeout: 60000 });
+            await (0, test_1.expect)(row).toBeVisible({ timeout: 60000 });
+        }
+    }
+    importedTemplateRow(name) {
+        return this.rows.filter({
+            has: this.page
+                .getByRole('link', { name, exact: true })
+                .or(this.page.getByTitle(name, { exact: true }))
+                .or(this.page.getByRole('cell', { name, exact: true })),
+        });
+    }
+    async openImportedTemplate(resourceName) {
+        await this.clickProcessDiagram(resourceName, true);
+        await this.page.waitForURL(/\/element-templates\//, { timeout: 30000 });
     }
     // Which control creates a process application depends on the hub version
     // under test. Since camunda/camunda-hub#25831 it is a plain primary button on

package/dist/tests/SM-8.10/connectors-user-flows.spec.js

@@ -351,6 +351,108 @@ test.describe('Connectors User Flow Tests @tasklistV2', () => {
             await modelerCreatePage.applyAiAgentSubProcessTemplate();
         });
     });
+    test('Agentic Connector Template File Import User Flow', async ({ request, modelerHomePage, modelerCreatePage, connectorTemplatePage, }) => {
+        const suffix = await (0, _setup_1.generateRandomStringAsync)(8);
+        const source = 'https://raw.githubusercontent.com/camunda/connectors/' +
+            '44784a99762663e60b5224578645ecbff4a1065f/' +
+            'connectors/agentic-ai/connector-agentic-ai/element-templates/';
+        const templates = [
+            {
+                file: 'agenticai-mcp-client-outbound-connector.json',
+                id: 'io.camunda.connectors.agenticai.mcp.client.v0',
+                name: 'MCP Client',
+                version: 3,
+                engine: '^8.9',
+                target: 'task',
+            },
+            {
+                file: 'agenticai-mcp-remote-client-outbound-connector.json',
+                id: 'io.camunda.connectors.agenticai.mcp.remoteclient.v0',
+                name: 'MCP Remote Client',
+                version: 3,
+                engine: '^8.9',
+                target: 'task',
+            },
+            {
+                file: 'agenticai-adhoctoolsschema-outbound-connector.json',
+                id: 'io.camunda.connectors.agenticai.adhoctoolsschema.v1',
+                name: 'Ad-hoc tools schema',
+                version: 2,
+                engine: '^8.8',
+                target: 'task',
+            },
+            {
+                file: 'agenticai-a2a-client-webhook-inbound-connector-receive.json',
+                id: 'io.camunda.connectors.agenticai.a2a.client.webhook.receive.v0',
+                name: 'A2A Client Webhook Receive Task Connector (early access)',
+                version: 1,
+                engine: '^8.9',
+                target: 'receiveTask',
+            },
+            {
+                file: 'agenticai-a2a-client-webhook-inbound-connector-intermediate.json',
+                id: 'io.camunda.connectors.agenticai.a2a.client.webhook.intermediate.v0',
+                name: 'A2A Client Webhook Intermediate Catch Event Connector (early access)',
+                version: 1,
+                engine: '^8.9',
+                target: 'intermediateCatchEvent',
+            },
+        ];
+        const files = await test.step('Download pinned compatible template files', async () => {
+            const files = [];
+            for (const template of templates) {
+                const response = await request.get(source + template.file);
+                (0, test_1.expect)(response.ok(), `Download ${template.file}: ${response.status()}`).toBe(true);
+                const buffer = await response.body();
+                const content = JSON.parse(buffer.toString('utf8'));
+                (0, test_1.expect)(content).toMatchObject({
+                    id: template.id,
+                    name: template.name,
+                    version: template.version,
+                    engines: { camunda: template.engine },
+                });
+                (0, test_1.expect)(content).not.toHaveProperty('deprecated');
+                files.push({ name: `${template.id}_${suffix}.json`, buffer });
+            }
+            return files;
+        });
+        await test.step('Import files into a fresh Workspace project', async () => {
+            await modelerHomePage.createDisposableWorkspace(`Template import ${suffix}`);
+            await modelerHomePage.enterResourceContainer(`Template import ${suffix}`, {
+                configureEnvironment: false,
+            });
+            await modelerHomePage.uploadTemplateFiles(files);
+        });
+        await test.step('Publish each imported draft to this Workspace only', async () => {
+            for (const template of templates) {
+                await modelerHomePage.openImportedTemplate(`${template.id}_${suffix}`);
+                await connectorTemplatePage.publishImportedTemplateToWorkspace(template.version);
+                await modelerHomePage.returnToResourceContainer();
+            }
+        });
+        await modelerHomePage.clickDiagramTypeDropdown();
+        await modelerHomePage.clickBpmnTemplateOption();
+        await modelerCreatePage.enterDiagramName(`Imported templates ${suffix}`);
+        await modelerCreatePage.setEngineVersion('8.10');
+        let previousElementId = 'StartEvent_1';
+        const bindings = [];
+        for (const template of templates) {
+            await test.step(`Apply ${template.name} to its supported element`, async () => {
+                const elementId = await modelerCreatePage.appendTemplateTarget(previousElementId, template.target);
+                await modelerCreatePage.applyImportedTemplate(elementId, template);
+                bindings.push({
+                    elementId,
+                    id: template.id,
+                    version: template.version,
+                    elementType: template.target === 'task' ? 'serviceTask' : template.target,
+                });
+                previousElementId = elementId;
+            });
+        }
+        await test.step('Verify exact template IDs and versions in the exported diagram', async () => {
+            await modelerCreatePage.assertExportedTemplateBindings(bindings);
+        });
+    });
     //Skipped due to bug 1252: https://github.com/camunda/c8-cross-component-e2e-tests/issues/1252
     test.skip('Connectors Timer Event User Flow', async ({ page, modelerHomePage, modelerCreatePage, connectorMarketplacePage, connectorTemplatePage, navigationPage, operateProcessInstancePage, operateHomePage, operateProcessesPage, }) => {
         test.slow();

package/dist/utils/apiHelpers.js

@@ -273,31 +273,46 @@ async function authSaasAPI(audience, clusterType) {
     // "You are being rate limited" page when many specs fetch a token at once
     // (each MCP spec authenticates in beforeAll). Retry with exponential
     // backoff so the rate-limit window clears instead of failing the suite.
-    const maxAttempts = 5;
-    const baseDelayMs = 3000;
+    // While throttled, Cloudflare may also hold the connection open, so a
+    // request timeout is retried like a 429 rather than aborting the loop.
+    const maxAttempts = 7;
+    const baseDelayMs = 5000;
+    const maxDelayMs = 60000;
+    const requestTimeoutMs = 30000;
     let lastErrorMessage = '';
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        const tokenResponse = await apiRequestContext.post(creds.authUrl, {
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            data: {
-                audience: tokenAudience,
-                client_id: creds.clientId,
-                client_secret: creds.clientSecret,
-                grant_type: 'client_credentials',
-            },
-        });
-        if (tokenResponse.status() === 200) {
-            const tokenJson = await tokenResponse.json();
-            return `Bearer ${tokenJson.access_token}`;
+        let retryAfterMs = 0;
+        try {
+            const tokenResponse = await apiRequestContext.post(creds.authUrl, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                data: {
+                    audience: tokenAudience,
+                    client_id: creds.clientId,
+                    client_secret: creds.clientSecret,
+                    grant_type: 'client_credentials',
+                },
+                timeout: requestTimeoutMs,
+            });
+            if (tokenResponse.status() === 200) {
+                const tokenJson = await tokenResponse.json();
+                return `Bearer ${tokenJson.access_token}`;
+            }
+            const retryAfter = Number(tokenResponse.headers()['retry-after']);
+            if (Number.isFinite(retryAfter) && retryAfter > 0) {
+                retryAfterMs = Math.min(retryAfter * 1000, maxDelayMs);
+            }
+            const errorBody = await tokenResponse.text();
+            lastErrorMessage = `HTTP ${tokenResponse.status()} - ${errorBody.slice(0, 200)}`;
+        }
+        catch (error) {
+            lastErrorMessage = error.message.split('\n')[0];
         }
-        const errorBody = await tokenResponse.text();
-        lastErrorMessage = `HTTP ${tokenResponse.status()} - ${errorBody.slice(0, 200)}`;
         if (attempt < maxAttempts) {
+            const backoffMs = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs);
             console.warn(`authSaasAPI attempt ${attempt}/${maxAttempts} failed to fetch access token (${lastErrorMessage}); retrying after backoff...`);
-            await new Promise((r) => setTimeout(r, baseDelayMs * 2 ** (attempt - 1)));
-            continue;
+            await new Promise((r) => setTimeout(r, Math.max(backoffMs, retryAfterMs)));
         }
     }
     throw new Error(`Failed to fetch access token. Response: ${lastErrorMessage}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1478",
+  "version": "0.0.1480",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",