@camunda/e2e-test-suite 0.0.1587 → 0.0.1589

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

@@ -90,20 +90,42 @@ class ConnectorTemplatePage {
         await (0, test_1.expect)(dialog).toBeHidden({ timeout: 60000 });
         return null;
     }
-    // Replace the whole content of the open template file. Monaco only picks up
-    // real input events, so the old content is selected and deleted via the
-    // keyboard and the new JSON is inserted as a single input.
+    // Replace the whole content of the open template file. Web Modeler's Monaco
+    // editor uses the EditContext API, under which keyboard.insertText of a
+    // multi-line string is re-indented line by line (and can end up as invalid
+    // JSON, which disables Publish). Pasting is applied verbatim, so the new
+    // JSON goes through the clipboard instead.
     async replaceTemplateJson(json, expectedText) {
         const editor = this.page.locator('.monaco-editor').first();
         await (0, test_1.expect)(editor).toBeVisible({ timeout: 90000 });
-        await editor.locator('.view-lines').click();
+        await this.page
+            .context()
+            .grantPermissions(['clipboard-read', 'clipboard-write']);
+        await this.page.evaluate(async (text) => await navigator.clipboard.writeText(text), json);
+        // Click inside the visible text area, just right of the line numbers:
+        // clicking the centre of `.view-lines` can land far right on a long line
+        // and miss the editor, so the shortcuts below would act on the page
+        // instead. Monaco marks the editor `focused` once it owns the keyboard.
+        await (0, test_1.expect)(async () => {
+            const box = await editor.boundingBox();
+            if (!box) {
+                throw new Error('Template editor has no bounding box');
+            }
+            await editor.click({
+                position: { x: Math.min(120, box.width / 2), y: box.height / 2 },
+                timeout: 10000,
+            });
+            await (0, test_1.expect)(editor).toHaveClass(/\bfocused\b/, { timeout: 5000 });
+        }).toPass({ timeout: 60000 });
         await this.page.keyboard.press('ControlOrMeta+A');
-        await this.page.keyboard.press('Delete');
-        await this.page.keyboard.insertText(json);
+        await this.page.keyboard.press('ControlOrMeta+V');
         await this.page.keyboard.press('ControlOrMeta+Home');
         await (0, test_1.expect)(editor.locator('.view-lines')).toContainText(expectedText, {
             timeout: 30000,
         });
+        await (0, test_1.expect)(this.page.getByText('Your JSON is invalid')).toBeHidden({
+            timeout: 30000,
+        });
     }
     async publishConnector() {
         try {

package/dist/pages/c8Run/PhysicalTenantPage.js

@@ -31,7 +31,10 @@ class PhysicalTenantPage {
         await (0, test_1.expect)(banner).toBeVisible({ timeout: 60000 });
     }
     async expectInstance(processId, instanceKey, visible) {
-        await this.page.goto(`${this.root}/operate/processes?active=true&incidents=true&completed=true&canceled=true&process=${encodeURIComponent(processId)}&processInstanceKey=${instanceKey}`);
+        // Each physical tenant has its own key space, so the same instance key can
+        // exist in both. Operate only honours `processDefinitionId` (an unknown
+        // `process` param is dropped), which scopes the lookup to this process.
+        await this.page.goto(`${this.root}/operate/processes?active=true&incidents=true&completed=true&canceled=true&processDefinitionId=${encodeURIComponent(processId)}&processInstanceKey=${instanceKey}`);
         const instance = this.page.getByRole('link', {
             name: `View instance ${instanceKey}`,
             exact: true,

package/dist/utils/c8runPhysicalTenants.js

@@ -19,18 +19,24 @@ class TenantAPI {
     async deploy(connector = false) {
         const id = `PhysicalTenant_${await (0, _setup_1.generateRandomStringAsync)(16)}`;
         const model = await (0, promises_1.readFile)(`resources/c8run-physical-tenant-${connector ? 'connector' : 'isolation'}.bpmn`, 'utf8');
-        const response = await this.request.post(`${this.root}/v2/deployments`, {
-            // Native Windows can exceed the inherited 10s action timeout while
-            // concurrent suites deploy. Wait for this command; never resend it.
-            timeout: 60000,
-            multipart: {
-                resources: {
-                    name: `${id}.bpmn`,
-                    mimeType: 'application/xml',
-                    buffer: Buffer.from(model.replace('PHYSICAL_TENANT_PROCESS', id)),
+        const buffer = Buffer.from(model.replace('PHYSICAL_TENANT_PROCESS', id));
+        let response;
+        // On slow native runners (macOS Intel) the single broker's actors stall
+        // for up to a minute while every suite starts at once, and the gateway
+        // answers 504 DEADLINE_EXCEEDED / 503 RESOURCE_EXHAUSTED. Retrying is safe:
+        // the same bytes under the same resource name are deduplicated by the
+        // engine, so a retry returns the original definition, not a new version.
+        await (0, test_1.expect)(async () => {
+            response = await this.request.post(`${this.root}/v2/deployments`, {
+                // Native Windows can exceed the inherited 10s action timeout while
+                // concurrent suites deploy.
+                timeout: 60000,
+                multipart: {
+                    resources: { name: `${id}.bpmn`, mimeType: 'application/xml', buffer },
                 },
-            },
-        });
+            });
+            (0, test_1.expect)([503, 504], await response.text()).not.toContain(response.status());
+        }).toPass({ timeout: 180000, intervals: [5000, 10000, 15000] });
         (0, test_1.expect)(response.status(), await response.text()).toBe(200);
         const body = await response.json();
         const definition = body.deployments[0].processDefinition;
@@ -46,6 +52,9 @@ class TenantAPI {
     }
     async create(key, variables = {}) {
         const response = await this.request.post(`${this.root}/v2/process-instances`, {
+            // Not idempotent, so never resent; wait out a busy broker instead of
+            // the inherited 10s action timeout (the gateway itself caps at 15s).
+            timeout: 60000,
             data: { processDefinitionKey: key, variables },
         });
         (0, test_1.expect)(response.status(), await response.text()).toBe(200);

package/package.json

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