@camunda/e2e-test-suite 0.0.1241 → 0.0.1243

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

@@ -0,0 +1,118 @@
+"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");
+/**
+ * Deploys the definition under test for one test, and tracks it for deletion.
+ *
+ * The shell suite hunted the cluster for a pre-existing process named
+ * "benchmark" or "one_task" and fell back to "first available" with a printed
+ * warning, so the endpoints under test were exercised against whatever
+ * happened to be deployed. Deploying our own makes every assertion below about
+ * a known model.
+ *
+ * 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.
+ */
+async function deployDefinitionUnderTest(api, resources) {
+    const processId = (0, bpmn_1.uniqueId)('process-definition-api');
+    const deployed = await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask((0, bpmn_1.uniqueId)('job-type'))));
+    return { processId, deployed };
+}
+api_1.test.describe('Process definitions', () => {
+    (0, api_1.test)('finds the deployed definition by id', async ({ api, resources }) => {
+        const { processId, deployed } = await deployDefinitionUnderTest(api, resources);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/process-definitions/search', {
+                body: { filter: { processDefinitionId: processId } },
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const item = page.items[0];
+            (0, test_1.expect)(String(item.processDefinitionKey)).toBe(deployed.processDefinitionKey);
+            (0, test_1.expect)(item.version).toBe(deployed.version);
+        });
+    });
+    (0, api_1.test)('returns the definition by key', async ({ api, resources }) => {
+        const { processId, deployed } = await deployDefinitionUnderTest(api, resources);
+        // Marked `x-eventually-consistent: true` in the API description: the read
+        // is served from secondary storage, so it can answer 404 for a short
+        // window after the deployment command is written.
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/process-definitions/{processDefinitionKey}', { params: { processDefinitionKey: deployed.processDefinitionKey } });
+            const definition = (await (0, assertions_1.assertOk)(response));
+            (0, assertions_1.assertRequiredFields)(definition, [
+                'processDefinitionKey',
+                'processDefinitionId',
+                'version',
+            ]);
+            (0, test_1.expect)(definition.processDefinitionId).toBe(processId);
+        });
+    });
+    (0, api_1.test)('returns the definition XML by key', async ({ api, resources }) => {
+        const { processId, deployed } = await deployDefinitionUnderTest(api, resources);
+        // Also `x-eventually-consistent: true`. The earlier "XML retrieval is
+        // synchronous for a deployed definition" reasoning was wrong.
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/process-definitions/{processDefinitionKey}/xml', { params: { processDefinitionKey: deployed.processDefinitionKey } });
+            await (0, assertions_1.assertStatus)(response, 200);
+            // The shell suite asserted only the 200. A definition whose XML came
+            // back empty or belonging to another process would have passed.
+            const xml = await response.text();
+            (0, test_1.expect)(xml).toContain(`id="${processId}"`);
+            (0, test_1.expect)(xml).toContain('bpmn:process');
+        });
+    });
+    (0, api_1.test)('reports element-instance statistics for the definition', async ({ api, resources, }) => {
+        const { deployed } = await deployDefinitionUnderTest(api, resources);
+        const response = await api.post('/process-definitions/{processDefinitionKey}/statistics/element-instances', {
+            params: { processDefinitionKey: deployed.processDefinitionKey },
+            body: { filter: {} },
+        });
+        const stats = (await (0, assertions_1.assertOk)(response));
+        (0, test_1.expect)(Array.isArray(stats.items)).toBe(true);
+    });
+    (0, api_1.test)('searches instances of the definition', async ({ api, resources }) => {
+        const { deployed } = await deployDefinitionUnderTest(api, resources);
+        // There is no /process-definitions/{key}/instances sub-resource in any
+        // supported version; instances of a definition are found by filtering the
+        // process-instance search. The nested path was read as "404 until the
+        // deployment reaches secondary storage", but it 404s because nothing
+        // serves it, so polling only spent the retry budget before failing.
+        const response = await api.post('/process-instances/search', {
+            body: { filter: { processDefinitionKey: deployed.processDefinitionKey } },
+        });
+        await (0, assertions_1.assertPaginated)(response);
+    });
+    (0, api_1.test)('reports no linked start form for a definition without one', async ({ api, resources, }) => {
+        const { deployed } = await deployDefinitionUnderTest(api, resources);
+        const response = await api.get('/process-definitions/{processDefinitionKey}/form', { params: { processDefinitionKey: deployed.processDefinitionKey } });
+        // The deployed model carries no start form, so the API reports "nothing
+        // linked". Which of these two it uses depends on the minor version.
+        await (0, assertions_1.assertStatusIn)(response, [204, 404], 'a definition with no linked start form reports 204 on 8.8+ and 404 on earlier minors');
+    });
+    (0, api_1.test)('rejects a lookup for an absent definition key', async ({ api }) => {
+        const response = await api.get('/process-definitions/{processDefinitionKey}', { params: { processDefinitionKey: keys_1.ABSENT_KEY } });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects an XML lookup for an absent definition key', async ({ api }) => {
+        const response = await api.get('/process-definitions/{processDefinitionKey}/xml', { params: { processDefinitionKey: keys_1.ABSENT_KEY } });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects a malformed definition key', async ({ api }) => {
+        const response = await api.get('/process-definitions/{processDefinitionKey}', { params: { processDefinitionKey: 'not-a-key' } });
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+    (0, api_1.test)('honours the page size on search', async ({ api }) => {
+        const response = await api.post('/process-definitions/search', {
+            body: { filter: {}, page: { limit: 1 } },
+        });
+        const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+        (0, test_1.expect)(page.items.length).toBe(1);
+    });
+});

package/dist/tests/api/v2/process-instance/process-instance-api-tests.spec.d.ts

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

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 {};