@camunda/e2e-test-suite 0.0.1242 → 0.0.1244

package/dist/tests/api/v2/process-instance/process-instance-api-tests.spec.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../../../../fixtures/api");
+const test_1 = require("@playwright/test");
+const assertions_1 = require("../../../../utils/api/assertions");
+const deployments_1 = require("../../../../utils/api/deployments");
+const bpmn_1 = require("../../../../utils/api/bpmn");
+const eventually_1 = require("../../../../utils/api/eventually");
+const capabilities_1 = require("../../../../utils/api/capabilities");
+const keys_1 = require("../../../../utils/api/keys");
+/**
+ * Deploys the one-service-task process this file's tests start instances of,
+ * and tracks it for deletion.
+ *
+ * Per test rather than once per file: a definition deployed in `beforeAll`
+ * outlives the test that needs it, so no test can clean it up and the run
+ * leaves it on the cluster and in its indices for good. The service task is
+ * what makes an instance wait rather than complete, which every assertion
+ * below about a running instance depends on.
+ */
+async function deployProcessUnderTest(api, resources, prefix = 'process-instance-api') {
+    const processId = (0, bpmn_1.uniqueId)(prefix);
+    const deployed = await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask((0, bpmn_1.uniqueId)('pi-job'))));
+    return { processId, deployed };
+}
+async function startInstance(api, processDefinitionId, variables = {}) {
+    const response = await api.post('/process-instances', {
+        body: { processDefinitionId, variables },
+        tenant: 'root',
+    });
+    await (0, assertions_1.assertStatusIn)(response, [200], 'instance creation answers synchronously unless awaitCompletion is set');
+    const json = (await response.json());
+    (0, assertions_1.assertRequiredFields)(json, [
+        'processInstanceKey',
+        'processDefinitionKey',
+        'processDefinitionId',
+    ]);
+    return json;
+}
+api_1.test.describe('Process instances', () => {
+    (0, api_1.test)('starts an instance of the deployed process', async ({ api, resources, }) => {
+        const { processId, deployed } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        resources.track('processInstance', instance.processInstanceKey);
+        (0, test_1.expect)(String(instance.processDefinitionKey)).toBe(deployed.processDefinitionKey);
+        (0, test_1.expect)(instance.processDefinitionId).toBe(processId);
+    });
+    (0, api_1.test)('starts an instance carrying variables', async ({ api, resources }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId, {
+            orderId: 'order-42',
+            amount: 99,
+        });
+        resources.track('processInstance', instance.processInstanceKey);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/variables/search', {
+                body: {
+                    filter: { processInstanceKey: instance.processInstanceKey },
+                    page: { limit: 50 },
+                },
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const names = page.items.map((item) => item.name);
+            (0, test_1.expect)(names).toEqual(test_1.expect.arrayContaining(['orderId', 'amount']));
+        });
+    });
+    (0, api_1.test)('finds a started instance through search', async ({ api, resources }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        resources.track('processInstance', instance.processInstanceKey);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/process-instances/search', {
+                body: { filter: { processInstanceKey: instance.processInstanceKey } },
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { exactItems: 1 });
+            const item = page.items[0];
+            (0, test_1.expect)(item.processDefinitionId).toBe(processId);
+            (0, test_1.expect)(item.state).toBe('ACTIVE');
+        });
+    });
+    (0, api_1.test)('returns a started instance by key', async ({ api, resources }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/process-instances/{processInstanceKey}', { params: { processInstanceKey: key } });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, assertions_1.assertRequiredFields)(json, [
+                'processInstanceKey',
+                'processDefinitionId',
+                'state',
+            ]);
+            (0, test_1.expect)(json.state).toBe('ACTIVE');
+        });
+    });
+    (0, api_1.test)('reports sequence flows taken by the instance', async ({ api, resources, }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/process-instances/{processInstanceKey}/sequence-flows', { params: { processInstanceKey: key } });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, test_1.expect)(Array.isArray(json.items)).toBe(true);
+            // The instance waits at the service task, so the flow into it is taken.
+            (0, test_1.expect)(json.items.length).toBeGreaterThan(0);
+        });
+    });
+    (0, api_1.test)('reports element-instance statistics for the instance', async ({ api, resources, }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/process-instances/{processInstanceKey}/statistics/element-instances', { params: { processInstanceKey: key } });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, test_1.expect)(Array.isArray(json.items)).toBe(true);
+        });
+    });
+    (0, api_1.test)('reports an empty call hierarchy for a top-level instance', async ({ api, resources, }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/process-instances/{processInstanceKey}/call-hierarchy', { params: { processInstanceKey: key } });
+            await (0, assertions_1.assertStatusIn)(response, [200], 'call hierarchy is available once the instance is exported');
+            const json = (await response.json());
+            // A process with no call activity is its own only hierarchy entry.
+            (0, test_1.expect)(Array.isArray(json)).toBe(true);
+        });
+    });
+    (0, api_1.test)('reports no incidents for a healthy instance', async ({ api, resources, }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/process-instances/{processInstanceKey}/incidents/search', { params: { processInstanceKey: key }, body: { filter: {} } });
+            await (0, assertions_1.assertPaginated)(response, { exactItems: 0 });
+        });
+    });
+    (0, api_1.test)('cancels a running instance', async ({ api, resources }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        const response = await api.post('/process-instances/{processInstanceKey}/cancellation', { params: { processInstanceKey: key }, body: {}, tenant: 'none' });
+        await (0, assertions_1.assertStatusIn)(response, [204], 'cancellation is acknowledged once the command is written');
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/process-instances/search', {
+                body: { filter: { processInstanceKey: key } },
+            });
+            const page = await (0, assertions_1.assertPaginated)(search, { exactItems: 1 });
+            (0, test_1.expect)(page.items[0].state).toBe('TERMINATED');
+        });
+    });
+    (0, api_1.test)('updates instance variables through modification', async ({ api, resources, }) => {
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        const response = await api.post('/process-instances/{processInstanceKey}/modification', {
+            params: { processInstanceKey: key },
+            body: {
+                activateInstructions: [
+                    {
+                        elementId: 'task',
+                        variableInstructions: [{ variables: { injected: 'value' } }],
+                    },
+                ],
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [204], 'modification is acknowledged once the command is written');
+        await (0, eventually_1.eventually)(async () => {
+            const variables = await api.post('/variables/search', {
+                body: {
+                    filter: { processInstanceKey: key, name: 'injected' },
+                    page: { limit: 10 },
+                },
+            });
+            await (0, assertions_1.assertPaginated)(variables, { minItems: 1 });
+        });
+    });
+    (0, api_1.test)('rejects starting an instance of an absent process', async ({ api }) => {
+        const response = await api.post('/process-instances', {
+            body: { processDefinitionId: (0, bpmn_1.uniqueId)('does-not-exist') },
+            tenant: 'root',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects starting an instance with no process identifier', async ({ api, }) => {
+        const response = await api.post('/process-instances', {
+            body: { variables: {} },
+            tenant: 'root',
+        });
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+    (0, api_1.test)('rejects a lookup for an absent instance key', async ({ api }) => {
+        const response = await api.get('/process-instances/{processInstanceKey}', {
+            params: { processInstanceKey: keys_1.ABSENT_KEY },
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects cancelling an absent instance', async ({ api }) => {
+        const response = await api.post('/process-instances/{processInstanceKey}/cancellation', {
+            params: { processInstanceKey: keys_1.ABSENT_ROUTABLE_KEY },
+            body: {},
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects an unauthenticated instance start', async ({ api, resources, }) => {
+        api_1.test.skip(capabilities_1.unauthenticatedAccessAllowed !== false, capabilities_1.unauthenticatedAccessAllowed === false
+            ? ''
+            : capabilities_1.unauthenticatedAccessAllowed);
+        const { processId } = await deployProcessUnderTest(api, resources);
+        const response = await api.post('/process-instances', {
+            body: { processDefinitionId: processId },
+            tenant: 'root',
+            authorization: null,
+        });
+        await (0, assertions_1.assertUnauthorized)(response);
+    });
+});
+api_1.test.describe('Process instance migration', () => {
+    (0, api_1.test)('migrates a running instance to a new definition version', async ({ api, resources, }) => {
+        const processId = (0, bpmn_1.uniqueId)('migration-api');
+        const jobType = (0, bpmn_1.uniqueId)('migration-job');
+        const source = await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask(jobType), {
+            name: 'version one',
+        }));
+        const target = await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask(jobType), {
+            name: 'version two',
+        }));
+        (0, test_1.expect)(target.version).toBe(source.version + 1);
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        const response = await api.post('/process-instances/{processInstanceKey}/migration', {
+            params: { processInstanceKey: key },
+            body: {
+                targetProcessDefinitionKey: target.processDefinitionKey,
+                mappingInstructions: [
+                    { sourceElementId: 'task', targetElementId: 'task' },
+                ],
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [204], 'migration is acknowledged once the command is written');
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/process-instances/search', {
+                body: { filter: { processInstanceKey: key } },
+            });
+            const page = await (0, assertions_1.assertPaginated)(search, { exactItems: 1 });
+            // The shell suite accepted `200 204 400 500` for this call, so a
+            // migration that never happened counted as a pass. Reading the instance
+            // back is what proves it did.
+            (0, test_1.expect)(String(page.items[0].processDefinitionKey)).toBe(target.processDefinitionKey);
+        });
+    });
+    (0, api_1.test)('rejects migration to an absent target definition', async ({ api, resources, }) => {
+        const processId = (0, bpmn_1.uniqueId)('migration-bad-target');
+        await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask((0, bpmn_1.uniqueId)('job'))));
+        const instance = await startInstance(api, processId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        const response = await api.post('/process-instances/{processInstanceKey}/migration', {
+            params: { processInstanceKey: key },
+            body: {
+                targetProcessDefinitionKey: keys_1.ABSENT_KEY,
+                mappingInstructions: [
+                    { sourceElementId: 'task', targetElementId: 'task' },
+                ],
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+});
+api_1.test.describe('Call activity migration', () => {
+    /**
+     * Regression cover for the 8.9 NPE: migrating an instance whose active
+     * element is a call activity used to fail inside the engine rather than
+     * returning a result. The shell suite's version of this accepted
+     * `200 204 400 500`, which would have passed on the very 500 the test was
+     * written to catch.
+     */
+    (0, api_1.test)('migrates an instance waiting at a call activity', async ({ api, resources, }) => {
+        const childId = (0, bpmn_1.uniqueId)('migration-child');
+        const parentId = (0, bpmn_1.uniqueId)('migration-parent');
+        await (0, deployments_1.deployProcess)(api, resources, childId, (0, bpmn_1.linearProcess)(childId, bpmn_1.element.serviceTask((0, bpmn_1.uniqueId)('child-job'))));
+        const parentV1 = await (0, deployments_1.deployProcess)(api, resources, parentId, (0, bpmn_1.linearProcess)(parentId, bpmn_1.element.callActivity(childId), {
+            name: 'parent v1',
+        }));
+        const parentV2 = await (0, deployments_1.deployProcess)(api, resources, parentId, (0, bpmn_1.linearProcess)(parentId, bpmn_1.element.callActivity(childId), {
+            name: 'parent v2',
+        }));
+        (0, test_1.expect)(parentV2.version).toBe(parentV1.version + 1);
+        const instance = await startInstance(api, parentId);
+        const key = instance.processInstanceKey;
+        resources.track('processInstance', key);
+        // The call activity must be active before migrating, otherwise the test
+        // exercises an instance that has not reached the element under test.
+        await (0, eventually_1.eventually)(async () => {
+            const elements = await api.post('/element-instances/search', {
+                body: {
+                    filter: { processInstanceKey: key, elementId: 'task' },
+                    page: { limit: 10 },
+                },
+            });
+            await (0, assertions_1.assertPaginated)(elements, { minItems: 1 });
+        });
+        const response = await api.post('/process-instances/{processInstanceKey}/migration', {
+            params: { processInstanceKey: key },
+            body: {
+                targetProcessDefinitionKey: parentV2.processDefinitionKey,
+                mappingInstructions: [
+                    { sourceElementId: 'task', targetElementId: 'task' },
+                ],
+            },
+            tenant: 'none',
+        });
+        (0, test_1.expect)(response.status(), 'migrating at a call activity must not fault the engine').not.toBe(500);
+        await (0, assertions_1.assertStatusIn)(response, [204], 'migration is acknowledged once the command is written');
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/process-instances/search', {
+                body: { filter: { processInstanceKey: key } },
+            });
+            const page = await (0, assertions_1.assertPaginated)(search, { exactItems: 1 });
+            (0, test_1.expect)(String(page.items[0].processDefinitionKey)).toBe(parentV2.processDefinitionKey);
+        });
+    });
+});

package/dist/tests/api/v2/runtime/batch-modification-api-tests.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/api/v2/runtime/batch-modification-api-tests.spec.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../../../../fixtures/api");
+const test_1 = require("@playwright/test");
+const assertions_1 = require("../../../../utils/api/assertions");
+const deployments_1 = require("../../../../utils/api/deployments");
+const bpmn_1 = require("../../../../utils/api/bpmn");
+const eventually_1 = require("../../../../utils/api/eventually");
+async function seed(api, resources, count) {
+    const processId = (0, bpmn_1.uniqueId)('batch-mod');
+    const jobType = (0, bpmn_1.uniqueId)('batch-mod-job');
+    await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask(jobType)));
+    const instanceKeys = [];
+    for (let i = 0; i < count; i++) {
+        const response = await api.post('/process-instances', {
+            body: { processDefinitionId: processId },
+            tenant: 'root',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200], 'instance creation is synchronous');
+        const json = (await response.json());
+        instanceKeys.push(String(json.processInstanceKey));
+    }
+    await (0, eventually_1.eventually)(async () => {
+        const search = await api.post('/process-instances/search', {
+            body: { filter: { processDefinitionId: processId }, page: { limit: 50 } },
+        });
+        await (0, assertions_1.assertPaginated)(search, { minItems: count });
+    });
+    return { processId, jobType, instanceKeys };
+}
+api_1.test.describe('Batch process-instance modification', () => {
+    (0, api_1.test)('creates a modification batch scoped to a definition', async ({ api, resources, }) => {
+        const { processId, instanceKeys } = await seed(api, resources, 2);
+        instanceKeys.forEach((key) => resources.track('processInstance', key));
+        const response = await api.post('/process-instances/modification', {
+            body: {
+                filter: { processDefinitionId: processId },
+                moveInstructions: [{ sourceElementId: 'task', targetElementId: 'task' }],
+            },
+            tenant: 'filter',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200], 'the batch is accepted and its key returned synchronously');
+        const json = (await response.json());
+        (0, assertions_1.assertRequiredFields)(json, ['batchOperationKey']);
+    });
+    (0, api_1.test)('rejects a modification batch with an empty filter', async ({ api }) => {
+        const response = await api.post('/process-instances/modification', {
+            body: {
+                filter: {},
+                moveInstructions: [{ sourceElementId: 'a', targetElementId: 'b' }],
+            },
+            tenant: 'none',
+        });
+        // An unscoped batch would modify every instance on the cluster.
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+});
+api_1.test.describe('Batch incident resolution', () => {
+    (0, api_1.test)('resolves the incidents of a definition through a batch', async ({ api, resources, }) => {
+        const { processId, jobType, instanceKeys } = await seed(api, resources, 2);
+        instanceKeys.forEach((key) => resources.track('processInstance', key));
+        // Drive both jobs to zero retries so each instance carries an incident.
+        const jobs = await (0, eventually_1.eventuallyGet)(async () => {
+            const response = await api.post('/jobs/activation', {
+                body: {
+                    type: jobType,
+                    worker: 'api-v2-suite',
+                    maxJobsToActivate: 2,
+                    timeout: 60000,
+                },
+                tenant: 'tenantIds',
+            });
+            const json = (await response.json());
+            return json.jobs ?? [];
+        }, (found) => found.length >= 2, { description: `jobs of type ${jobType}` });
+        for (const job of jobs) {
+            await api.post('/jobs/{jobKey}/failure', {
+                params: { jobKey: String(job.jobKey) },
+                body: { errorMessage: 'exhausted', retries: 0, retryBackOff: 0 },
+                tenant: 'none',
+            });
+        }
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/incidents/search', {
+                body: {
+                    filter: { processDefinitionId: processId, state: 'ACTIVE' },
+                    page: { limit: 20 },
+                },
+            });
+            await (0, assertions_1.assertPaginated)(search, { minItems: 2 });
+        });
+        const response = await api.post('/process-instances/incident-resolution', {
+            body: { filter: { processDefinitionId: processId } },
+            tenant: 'filter',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200], 'the batch is accepted and its key returned synchronously');
+        const json = (await response.json());
+        (0, assertions_1.assertRequiredFields)(json, ['batchOperationKey']);
+        // The batch retries each failed element. With no retries left on the jobs
+        // the incidents return, so the assertion here is that the batch itself ran
+        // to a terminal state rather than that the incidents disappeared.
+        // A batch is scheduled cluster-wide and works through its items, so it
+        // takes materially longer than an index refresh — the search-tuned
+        // default left it still in CREATED. The assertion names the state it got
+        // stuck in, so a batch that never starts is distinguishable from one that
+        // is merely slow.
+        await (0, eventually_1.eventually)(async () => {
+            const lookup = await api.get('/batch-operations/{batchOperationKey}', {
+                params: { batchOperationKey: String(json.batchOperationKey) },
+                tenant: 'none',
+            });
+            const batch = (await lookup.json());
+            (0, test_1.expect)(['COMPLETED', 'PARTIALLY_COMPLETED'], `batch ${String(json.batchOperationKey)} reached ${String(batch.state)} rather than a terminal state`).toContain(batch.state);
+        }, { timeout: 180000 });
+    });
+    (0, api_1.test)('rejects an incident-resolution batch with an empty filter', async ({ api, }) => {
+        const response = await api.post('/process-instances/incident-resolution', {
+            body: { filter: {} },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+});

package/dist/tests/api/v2/runtime/variable-incident-api-tests.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/api/v2/runtime/variable-incident-api-tests.spec.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../../../../fixtures/api");
+const test_1 = require("@playwright/test");
+const assertions_1 = require("../../../../utils/api/assertions");
+const deployments_1 = require("../../../../utils/api/deployments");
+const bpmn_1 = require("../../../../utils/api/bpmn");
+const eventually_1 = require("../../../../utils/api/eventually");
+const keys_1 = require("../../../../utils/api/keys");
+async function startWithVariables(api, resources, variables) {
+    const processId = (0, bpmn_1.uniqueId)('variable-api');
+    await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask((0, bpmn_1.uniqueId)('job'))));
+    const start = await api.post('/process-instances', {
+        body: { processDefinitionId: processId, variables },
+        tenant: 'root',
+    });
+    await (0, assertions_1.assertStatusIn)(start, [200], 'instance creation is synchronous');
+    const instance = (await start.json());
+    return String(instance.processInstanceKey);
+}
+api_1.test.describe('Variables', () => {
+    (0, api_1.test)('finds a variable set at instance start', async ({ api, resources }) => {
+        const processInstanceKey = await startWithVariables(api, resources, {
+            customerId: 'cust-1',
+        });
+        resources.track('processInstance', processInstanceKey);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/variables/search', {
+                body: {
+                    filter: { processInstanceKey, name: 'customerId' },
+                    page: { limit: 10 },
+                },
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { exactItems: 1 });
+            const item = page.items[0];
+            (0, test_1.expect)(item.name).toBe('customerId');
+            (0, test_1.expect)(item.value).toBe('"cust-1"');
+        });
+    });
+    (0, api_1.test)('returns a variable by key', async ({ api, resources }) => {
+        const processInstanceKey = await startWithVariables(api, resources, {
+            total: 17,
+        });
+        resources.track('processInstance', processInstanceKey);
+        const items = await (0, eventually_1.eventuallyGet)(async () => {
+            const response = await api.post('/variables/search', {
+                body: {
+                    filter: { processInstanceKey, name: 'total' },
+                    page: { limit: 10 },
+                },
+            });
+            return (await (0, assertions_1.assertPaginated)(response)).items;
+        }, (found) => found.length > 0, { description: 'variables' });
+        const response = await api.get('/variables/{variableKey}', {
+            params: { variableKey: String(items[0].variableKey) },
+        });
+        const json = (await (0, assertions_1.assertOk)(response));
+        (0, assertions_1.assertRequiredFields)(json, ['variableKey', 'name', 'value', 'scopeKey']);
+        (0, test_1.expect)(json.name).toBe('total');
+    });
+    (0, api_1.test)('rejects a lookup for an absent variable key', async ({ api }) => {
+        const response = await api.get('/variables/{variableKey}', {
+            params: { variableKey: keys_1.ABSENT_KEY },
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+});
+api_1.test.describe('Incidents', () => {
+    /**
+     * Drives a service task job to zero retries, which is how the engine is made
+     * to raise an incident deterministically. The shell suite instead searched
+     * the cluster for whatever incident happened to exist, so its incident tests
+     * asserted against unrelated runs and passed with `exactItems: 0`.
+     */
+    async function raiseIncident(api, resources) {
+        const processId = (0, bpmn_1.uniqueId)('incident-api');
+        const jobType = (0, bpmn_1.uniqueId)('incident-job');
+        await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask(jobType)));
+        const start = await api.post('/process-instances', {
+            body: { processDefinitionId: processId },
+            tenant: 'root',
+        });
+        await (0, assertions_1.assertStatusIn)(start, [200], 'instance creation is synchronous');
+        const instance = (await start.json());
+        const processInstanceKey = String(instance.processInstanceKey);
+        const jobs = await (0, eventually_1.eventuallyGet)(async () => {
+            const response = await api.post('/jobs/activation', {
+                body: {
+                    type: jobType,
+                    worker: 'api-v2-suite',
+                    maxJobsToActivate: 1,
+                    timeout: 60000,
+                },
+                tenant: 'tenantIds',
+            });
+            const json = (await response.json());
+            return json.jobs ?? [];
+        }, (found) => found.length > 0, { description: 'activated job' });
+        await api.post('/jobs/{jobKey}/failure', {
+            params: { jobKey: String(jobs[0].jobKey) },
+            body: { errorMessage: 'no retries left', retries: 0, retryBackOff: 0 },
+            tenant: 'none',
+        });
+        const incidents = await (0, eventually_1.eventuallyGet)(async () => {
+            const response = await api.post('/incidents/search', {
+                body: { filter: { processInstanceKey }, page: { limit: 10 } },
+            });
+            return (await (0, assertions_1.assertPaginated)(response)).items;
+        }, (found) => found.length > 0, { description: 'incidents' });
+        return { processInstanceKey, incidentKey: String(incidents[0].incidentKey) };
+    }
+    (0, api_1.test)('raises an incident for a job with no retries left', async ({ api, resources, }) => {
+        const { processInstanceKey, incidentKey } = await raiseIncident(api, resources);
+        resources.track('processInstance', processInstanceKey);
+        // `PENDING` is a real state in `IncidentStateEnum`, not an error: an
+        // incident is exported as PENDING and becomes ACTIVE once the engine has
+        // finished raising it. Reading once caught the earlier state.
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/incidents/{incidentKey}', {
+                params: { incidentKey },
+            });
+            const incident = (await (0, assertions_1.assertOk)(response));
+            (0, assertions_1.assertRequiredFields)(incident, [
+                'incidentKey',
+                'processInstanceKey',
+                'errorType',
+                'state',
+            ]);
+            (0, test_1.expect)(incident.state).toBe('ACTIVE');
+            (0, test_1.expect)(String(incident.processInstanceKey)).toBe(processInstanceKey);
+        });
+    });
+    (0, api_1.test)('resolves an incident once its job has retries again', async ({ api, resources, }) => {
+        const { processInstanceKey, incidentKey } = await raiseIncident(api, resources);
+        resources.track('processInstance', processInstanceKey);
+        const incident = (await (await api.get('/incidents/{incidentKey}', { params: { incidentKey } })).json());
+        // Resolution retries the element, so the job needs retries first —
+        // otherwise the engine immediately raises the incident again.
+        await api.patch('/jobs/{jobKey}', {
+            params: { jobKey: String(incident.jobKey) },
+            body: { changeset: { retries: 3 } },
+            tenant: 'none',
+        });
+        const response = await api.post('/incidents/{incidentKey}/resolution', {
+            params: { incidentKey },
+            body: {},
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [204], 'resolution is acknowledged once the command is written');
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/incidents/search', {
+                body: {
+                    filter: { processInstanceKey, state: 'ACTIVE' },
+                    page: { limit: 10 },
+                },
+            });
+            await (0, assertions_1.assertPaginated)(search, { exactItems: 0 });
+        });
+    });
+    (0, api_1.test)('rejects a lookup for an absent incident key', async ({ api }) => {
+        const response = await api.get('/incidents/{incidentKey}', {
+            params: { incidentKey: keys_1.ABSENT_KEY },
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects resolving an absent incident', async ({ api }) => {
+        const response = await api.post('/incidents/{incidentKey}/resolution', {
+            params: { incidentKey: keys_1.ABSENT_ROUTABLE_KEY },
+            body: {},
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+});

package/dist/tests/api/v2/system/clock-api-tests.spec.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Cluster clock endpoints.
+ *
+ * In its own file because it is its own Playwright project: pinning the clock
+ * moves time for **every** caller on the cluster, so these tests cannot share
+ * the parallel window with the rest of the suite. See the `clock` project in
+ * `playwright.api.config.ts` for why a project is what isolates them and what
+ * that costs.
+ *
+ * `mode: 'serial'` is still needed, but only for the reason it can deliver:
+ * ordering the tests *within this file* so two of them do not pin and reset
+ * against each other.
+ *
+ * The shell suite ran these from inside its EXIT trap, after the process exit
+ * code had already been computed — so a clock assertion could not fail the
+ * run, and a crash before the trap left the cluster clock pinned for whatever
+ * ran next.
+ */
+export {};