@camunda/e2e-test-suite 0.0.1479 → 0.0.1480

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/package.json

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