@camunda/e2e-test-suite 0.0.1242 → 0.0.1244

package/dist/tests/api/v2/batch-operation/batch-operation-api-tests.spec.js

@@ -0,0 +1,264 @@
+"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 a process, starts `count` instances, and returns a filter that
+ * selects exactly those instances.
+ *
+ * The shell suite ran its batch operations against `{"filter":{}}` — every
+ * instance on the cluster — which is why its batch section had to be serial
+ * and why it needed a 900-line concurrency block to cope with the collisions
+ * that caused. Scoping each batch to its own process definition removes both.
+ */
+async function seedInstances(api, resources, count) {
+    const processId = (0, bpmn_1.uniqueId)('batch-api');
+    await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask((0, bpmn_1.uniqueId)('job'))));
+    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));
+    }
+    // The batch resolves its scope from the search store, so the instances must
+    // be exported before the batch is created or it selects nothing.
+    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, instanceKeys };
+}
+async function createCancellationBatch(api, processId) {
+    const response = await api.post('/process-instances/cancellation', {
+        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']);
+    return String(json.batchOperationKey);
+}
+api_1.test.describe('Batch operations', () => {
+    (0, api_1.test)('creates a cancellation batch and cancels its instances', async ({ api, resources, }) => {
+        const { processId, instanceKeys } = await seedInstances(api, resources, 3);
+        const batchKey = await createCancellationBatch(api, processId);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/batch-operations/{batchOperationKey}', {
+                params: { batchOperationKey: batchKey },
+                tenant: 'none',
+            });
+            const batch = (await (0, assertions_1.assertOk)(response));
+            (0, assertions_1.assertRequiredFields)(batch, [
+                'batchOperationKey',
+                'state',
+                'batchOperationType',
+            ]);
+            (0, test_1.expect)(batch.batchOperationType).toBe('CANCEL_PROCESS_INSTANCE');
+            (0, test_1.expect)(['COMPLETED', 'PARTIALLY_COMPLETED']).toContain(batch.state);
+        });
+        // The shell suite asserted only that the batch endpoint answered. Whether
+        // the instances were actually cancelled was never checked.
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/process-instances/search', {
+                body: {
+                    filter: { processDefinitionId: processId, state: 'ACTIVE' },
+                    page: { limit: 50 },
+                },
+            });
+            await (0, assertions_1.assertPaginated)(search, { exactItems: 0 });
+        });
+        (0, test_1.expect)(instanceKeys.length).toBe(3);
+    });
+    (0, api_1.test)('finds a created batch through search', async ({ api, resources }) => {
+        const { processId } = await seedInstances(api, resources, 1);
+        const batchKey = await createCancellationBatch(api, processId);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/batch-operations/search', {
+                body: { filter: { batchOperationKey: batchKey }, page: { limit: 10 } },
+                tenant: 'none',
+            });
+            await (0, assertions_1.assertPaginated)(response, { exactItems: 1 });
+        });
+    });
+    (0, api_1.test)('filters a batch search by state', async ({ api, resources }) => {
+        const { processId } = await seedInstances(api, resources, 1);
+        const batchKey = await createCancellationBatch(api, processId);
+        await (0, eventually_1.eventually)(async () => {
+            const lookup = await api.get('/batch-operations/{batchOperationKey}', {
+                params: { batchOperationKey: batchKey },
+                tenant: 'none',
+            });
+            const batch = (await (0, assertions_1.assertOk)(lookup));
+            const response = await api.post('/batch-operations/search', {
+                body: {
+                    filter: { state: batch.state },
+                    page: { limit: 20 },
+                },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            for (const item of page.items) {
+                (0, test_1.expect)(item.state).toBe(batch.state);
+            }
+        });
+    });
+    (0, api_1.test)('lists the items belonging to a batch', async ({ api, resources }) => {
+        const { processId } = await seedInstances(api, resources, 2);
+        const batchKey = await createCancellationBatch(api, processId);
+        await (0, eventually_1.eventuallyGet)(async () => {
+            const response = await api.post('/batch-operation-items/search', {
+                body: { filter: { batchOperationKey: batchKey }, page: { limit: 20 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response);
+            return page.items;
+        }, (items) => items.length >= 2, { description: `items of batch ${batchKey}` });
+    });
+    (0, api_1.test)('suspends and resumes a batch', async ({ api, resources }) => {
+        // A larger batch keeps the operation in flight long enough to suspend.
+        const { processId } = await seedInstances(api, resources, 5);
+        const batchKey = await createCancellationBatch(api, processId);
+        const suspend = await api.post('/batch-operations/{batchOperationKey}/suspension', { params: { batchOperationKey: batchKey }, body: {}, tenant: 'none' });
+        await (0, assertions_1.assertStatusIn)(suspend, [204, 409], 'a batch that has already finished cannot be suspended');
+        if (suspend.status() === 204) {
+            await (0, eventually_1.eventually)(async () => {
+                const lookup = await api.get('/batch-operations/{batchOperationKey}', {
+                    params: { batchOperationKey: batchKey },
+                    tenant: 'none',
+                });
+                const batch = (await (0, assertions_1.assertOk)(lookup));
+                (0, test_1.expect)(batch.state).toBe('SUSPENDED');
+            });
+            const resume = await api.post('/batch-operations/{batchOperationKey}/resumption', { params: { batchOperationKey: batchKey }, body: {}, tenant: 'none' });
+            await (0, assertions_1.assertStatusIn)(resume, [204], 'resumption is acknowledged');
+            await (0, eventually_1.eventually)(async () => {
+                const lookup = await api.get('/batch-operations/{batchOperationKey}', {
+                    params: { batchOperationKey: batchKey },
+                    tenant: 'none',
+                });
+                const batch = (await (0, assertions_1.assertOk)(lookup));
+                (0, test_1.expect)(batch.state).not.toBe('SUSPENDED');
+            });
+        }
+    });
+    (0, api_1.test)('cancels a suspended batch', async ({ api, resources }) => {
+        const { processId } = await seedInstances(api, resources, 5);
+        const batchKey = await createCancellationBatch(api, processId);
+        const suspend = await api.post('/batch-operations/{batchOperationKey}/suspension', { params: { batchOperationKey: batchKey }, body: {}, tenant: 'none' });
+        await (0, assertions_1.assertStatusIn)(suspend, [204, 409], 'a batch that has already finished cannot be suspended');
+        if (suspend.status() === 204) {
+            const cancel = await api.post('/batch-operations/{batchOperationKey}/cancellation', { params: { batchOperationKey: batchKey }, body: {}, tenant: 'none' });
+            await (0, assertions_1.assertStatusIn)(cancel, [204], 'cancellation is acknowledged');
+            await (0, eventually_1.eventually)(async () => {
+                const lookup = await api.get('/batch-operations/{batchOperationKey}', {
+                    params: { batchOperationKey: batchKey },
+                    tenant: 'none',
+                });
+                const batch = (await (0, assertions_1.assertOk)(lookup));
+                (0, test_1.expect)(batch.state).toBe('CANCELED');
+            });
+        }
+    });
+    (0, api_1.test)('creates a migration batch', async ({ api, resources }) => {
+        const processId = (0, bpmn_1.uniqueId)('batch-migration');
+        const jobType = (0, bpmn_1.uniqueId)('job');
+        const v1 = await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask(jobType), { name: 'v1' }));
+        const v2 = await (0, deployments_1.deployProcess)(api, resources, processId, (0, bpmn_1.linearProcess)(processId, bpmn_1.element.serviceTask(jobType), { name: 'v2' }));
+        (0, test_1.expect)(v2.version).toBe(v1.version + 1);
+        const start = await api.post('/process-instances', {
+            body: { processDefinitionId: processId },
+            tenant: 'root',
+        });
+        const instance = (await start.json());
+        resources.track('processInstance', String(instance.processInstanceKey));
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/process-instances/search', {
+                body: { filter: { processInstanceKey: instance.processInstanceKey } },
+            });
+            await (0, assertions_1.assertPaginated)(search, { exactItems: 1 });
+        });
+        const response = await api.post('/process-instances/migration', {
+            body: {
+                filter: { processDefinitionKey: v1.processDefinitionKey },
+                migrationPlan: {
+                    targetProcessDefinitionKey: v2.processDefinitionKey,
+                    mappingInstructions: [
+                        { sourceElementId: 'task', targetElementId: 'task' },
+                    ],
+                },
+            },
+            tenant: 'filter',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200], 'the batch key is returned');
+        const json = (await response.json());
+        (0, assertions_1.assertRequiredFields)(json, ['batchOperationKey']);
+    });
+    (0, api_1.test)('rejects a lookup for an absent batch', async ({ api }) => {
+        const response = await api.get('/batch-operations/{batchOperationKey}', {
+            params: { batchOperationKey: keys_1.ABSENT_KEY },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects suspending an absent batch', async ({ api }) => {
+        const response = await api.post('/batch-operations/{batchOperationKey}/suspension', {
+            params: { batchOperationKey: keys_1.ABSENT_ROUTABLE_KEY },
+            body: {},
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects resuming an absent batch', async ({ api }) => {
+        const response = await api.post('/batch-operations/{batchOperationKey}/resumption', {
+            params: { batchOperationKey: keys_1.ABSENT_ROUTABLE_KEY },
+            body: {},
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects cancelling an absent batch', async ({ api }) => {
+        const response = await api.post('/batch-operations/{batchOperationKey}/cancellation', {
+            params: { batchOperationKey: keys_1.ABSENT_ROUTABLE_KEY },
+            body: {},
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('reports an unknown batch operation id as not found', async ({ api }) => {
+        // A batch operation is addressed by a string id, not a numeric key, so
+        // there is no "malformed" shape to reject here — any string the cluster
+        // does not hold is simply absent.
+        const response = await api.get('/batch-operations/{batchOperationKey}', {
+            params: { batchOperationKey: 'not-a-key' },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response, /not found/i);
+    });
+    (0, api_1.test)('rejects a cancellation batch with an empty filter', async ({ api }) => {
+        const response = await api.post('/process-instances/cancellation', {
+            body: { filter: {} },
+            tenant: 'none',
+        });
+        // An unscoped batch would cancel every instance on the cluster. The shell
+        // suite asserted `200 202 400` here, so it accepted that outcome.
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+    (0, api_1.test)('rejects a batch search with an unknown state filter', async ({ api }) => {
+        const response = await api.post('/batch-operations/search', {
+            body: { filter: { state: 'NOT_A_STATE' } },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+});

package/dist/tests/api/v2/cluster/cluster-api-tests.spec.d.ts

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

package/dist/tests/api/v2/cluster/cluster-api-tests.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const api_1 = require("../../../../fixtures/api");
+const assertions_1 = require("../../../../utils/api/assertions");
+const test_1 = require("@playwright/test");
+const config_1 = require("../../../../utils/api/config");
+const capabilities_1 = require("../../../../utils/api/capabilities");
+api_1.test.describe('Cluster and authentication', () => {
+    (0, api_1.test)('returns the authenticated principal', async ({ api }) => {
+        api_1.test.skip(capabilities_1.unauthenticatedAccessAllowed !== false, capabilities_1.unauthenticatedAccessAllowed === false
+            ? ''
+            : capabilities_1.unauthenticatedAccessAllowed);
+        const response = await api.get('/authentication/me', { tenant: 'none' });
+        const me = (await (0, assertions_1.assertOk)(response));
+        // The shell suite accepted any 200 here and read the user id with a
+        // `// empty` fallback, so an empty body passed. What the endpoint
+        // guarantees is `CamundaUserResult`, whose required fields describe what
+        // the caller may do — assert those.
+        (0, assertions_1.assertRequiredFields)(me, [
+            'authorizedComponents',
+            'tenants',
+            'groups',
+            'roles',
+            'canLogout',
+        ]);
+        (0, test_1.expect)(Array.isArray(me.authorizedComponents)).toBe(true);
+        (0, test_1.expect)(Array.isArray(me.tenants)).toBe(true);
+        // `username` names a *user*. Authenticating with client credentials —
+        // which is how every OIDC cluster runs this suite — means the principal
+        // is a client and there is no username to return, so requiring one here
+        // asserted a property of the auth method rather than of the endpoint.
+        if (config_1.apiConfig.usersApiEnabled) {
+            (0, test_1.expect)(me.username, 'a user principal is identified by name').toBeTruthy();
+        }
+    });
+    // Not gated on `unauthenticatedAccessAllowed`: /v2/authentication/me
+    // refuses an anonymous caller even where the rest of the tree does not,
+    // so this one holds on an open cluster too and passed on c8Run.
+    (0, api_1.test)('rejects an unauthenticated principal lookup', async ({ api }) => {
+        const response = await api.get('/authentication/me', {
+            tenant: 'none',
+            authorization: null,
+        });
+        await (0, assertions_1.assertUnauthorized)(response);
+    });
+    (0, api_1.test)('reports cluster topology with at least one broker', async ({ api }) => {
+        const response = await api.get('/topology', { tenant: 'none' });
+        const topology = (await (0, assertions_1.assertOk)(response));
+        (0, assertions_1.assertRequiredFields)(topology, ['brokers', 'clusterSize']);
+        (0, test_1.expect)(topology.brokers?.length ?? 0).toBeGreaterThan(0);
+        (0, test_1.expect)(topology.clusterSize).toBeGreaterThan(0);
+        for (const broker of topology.brokers ?? []) {
+            (0, assertions_1.assertRequiredFields)(broker, ['nodeId', 'host', 'port', 'partitions']);
+        }
+    });
+    (0, api_1.test)('reports the cluster licence state', async ({ api }) => {
+        const response = await api.get('/license', { tenant: 'none' });
+        const license = (await (0, assertions_1.assertOk)(response));
+        (0, assertions_1.assertRequiredFields)(license, ['validLicense', 'licenseType']);
+        (0, test_1.expect)(typeof license.validLicense).toBe('boolean');
+    });
+    (0, api_1.test)('reports readiness on the status endpoint', async ({ api }) => {
+        const response = await api.get('/status', { tenant: 'none' });
+        await (0, assertions_1.assertNoContent)(response);
+    });
+    (0, api_1.test)('rejects an unauthenticated topology request', async ({ api }) => {
+        api_1.test.skip(capabilities_1.unauthenticatedAccessAllowed !== false, capabilities_1.unauthenticatedAccessAllowed === false
+            ? ''
+            : capabilities_1.unauthenticatedAccessAllowed);
+        const response = await api.get('/topology', {
+            tenant: 'none',
+            authorization: null,
+        });
+        await (0, assertions_1.assertUnauthorized)(response);
+    });
+    (0, api_1.test)('rejects a request bearing a malformed token', async ({ api }) => {
+        api_1.test.skip(capabilities_1.unauthenticatedAccessAllowed !== false, capabilities_1.unauthenticatedAccessAllowed === false
+            ? ''
+            : capabilities_1.unauthenticatedAccessAllowed);
+        const response = await api.get('/topology', {
+            tenant: 'none',
+            authorization: 'Bearer not-a-real-token',
+        });
+        await (0, assertions_1.assertStatus)(response, 401);
+    });
+});

package/dist/tests/api/v2/decision/decision-api-tests.spec.d.ts

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

package/dist/tests/api/v2/decision/decision-api-tests.spec.js

@@ -0,0 +1,233 @@
+"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 a decision for one test and tracks it for deletion.
+ *
+ * Per test rather than once per file: a definition shared through `beforeAll`
+ * outlives the test that needs it, so no single test can clean it up and the
+ * tests that evaluate it compete for the same instances — this file already
+ * carries two comments about a definition-scoped search returning a sibling
+ * test's instance. A private decision id per test removes that competition at
+ * the source.
+ */
+async function deployTestDecision(api, resources, prefix) {
+    const decisionId = (0, bpmn_1.uniqueId)(prefix);
+    const deployed = await (0, deployments_1.deployDecision)(api, resources, decisionId, (0, bpmn_1.simpleDecision)(decisionId));
+    return { decisionId, deployed };
+}
+api_1.test.describe('Decision definitions and instances', () => {
+    (0, api_1.test)('finds the deployed decision by id', async ({ api, resources }) => {
+        const { decisionId, deployed } = await deployTestDecision(api, resources, 'decision-api');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/decision-definitions/search', {
+                body: { filter: { decisionDefinitionId: decisionId } },
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const item = page.items[0];
+            (0, test_1.expect)(String(item.decisionDefinitionKey)).toBe(deployed.decisionDefinitionKey);
+        });
+    });
+    (0, api_1.test)('returns the decision definition by key', async ({ api, resources }) => {
+        const { decisionId, deployed } = await deployTestDecision(api, resources, 'decision-api');
+        // `x-eventually-consistent: true` — served from secondary storage, so it
+        // can 404 briefly after the deployment.
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/decision-definitions/{decisionDefinitionKey}', { params: { decisionDefinitionKey: deployed.decisionDefinitionKey } });
+            const definition = (await (0, assertions_1.assertOk)(response));
+            (0, assertions_1.assertRequiredFields)(definition, [
+                'decisionDefinitionKey',
+                'decisionDefinitionId',
+                'version',
+                'decisionRequirementsKey',
+            ]);
+            (0, test_1.expect)(definition.decisionDefinitionId).toBe(decisionId);
+        });
+    });
+    (0, api_1.test)('returns the decision XML by key', async ({ api, resources }) => {
+        const { decisionId, deployed } = await deployTestDecision(api, resources, 'decision-api');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/decision-definitions/{decisionDefinitionKey}/xml', { params: { decisionDefinitionKey: deployed.decisionDefinitionKey } });
+            // assertOk parses the body as JSON; this endpoint returns XML text.
+            await (0, assertions_1.assertStatus)(response, 200);
+            const xml = await response.text();
+            (0, test_1.expect)(xml).toContain(decisionId);
+        });
+    });
+    (0, api_1.test)('evaluates the decision and returns the matching output', async ({ api, resources, }) => {
+        const { deployed } = await deployTestDecision(api, resources, 'decision-api');
+        const response = await api.post('/decision-definitions/evaluation', {
+            body: {
+                decisionDefinitionKey: deployed.decisionDefinitionKey,
+                variables: { inputVariable: 'match' },
+            },
+            tenant: 'root',
+        });
+        const result = (await (0, assertions_1.assertOk)(response));
+        (0, assertions_1.assertRequiredFields)(result, [
+            'decisionDefinitionKey',
+            'decisionEvaluationKey',
+            'output',
+        ]);
+        // The shell suite accepted `200 400 404` here, so a decision that failed
+        // to evaluate passed. The rule table maps "match" to "matched", and
+        // `output` carries the JSON encoding of the value, not the bare value.
+        (0, test_1.expect)(result.output).toBe('"matched"');
+    });
+    (0, api_1.test)('evaluates the decision to its default rule', async ({ api, resources, }) => {
+        const { deployed } = await deployTestDecision(api, resources, 'decision-api');
+        const response = await api.post('/decision-definitions/evaluation', {
+            body: {
+                decisionDefinitionKey: deployed.decisionDefinitionKey,
+                variables: { inputVariable: 'anything-else' },
+            },
+            tenant: 'root',
+        });
+        const result = (await (0, assertions_1.assertOk)(response));
+        (0, test_1.expect)(result.output).toBe('"default"');
+    });
+    (0, api_1.test)('records an instance for each evaluation', async ({ api, resources }) => {
+        const { decisionId, deployed } = await deployTestDecision(api, resources, 'decision-api');
+        const evaluation = await api.post('/decision-definitions/evaluation', {
+            body: {
+                decisionDefinitionKey: deployed.decisionDefinitionKey,
+                variables: { inputVariable: 'match' },
+            },
+            tenant: 'root',
+        });
+        const evaluated = (await (0, assertions_1.assertOk)(evaluation));
+        const evaluationKey = String(evaluated.decisionEvaluationKey);
+        // Filtered by the evaluation, not by the definition: this test evaluates
+        // once, but a definition-scoped search would be satisfied by whichever
+        // instance is exported first, so as soon as a test evaluates twice
+        // `items[0]` is whichever evaluation landed first rather than the one
+        // under assertion. That is how it failed when the whole file shared one
+        // definition — one flake in run 35606946161, where the search returned a
+        // sibling test's instance.
+        const instances = await (0, eventually_1.eventuallyGet)(async () => {
+            const response = await api.post('/decision-instances/search', {
+                body: {
+                    filter: { decisionEvaluationKey: evaluationKey },
+                    page: { limit: 10 },
+                },
+            });
+            return (await (0, assertions_1.assertPaginated)(response)).items;
+        }, (items) => items.length > 0, { description: `decision instance for evaluation ${evaluationKey}` });
+        // The single-instance GET is addressed by `decisionEvaluationInstanceKey`
+        // — the compound `<decisionEvaluationKey>-<index>` that identifies one
+        // decision inside an evaluation, not the plain numeric evaluation key.
+        // Passing the numeric key earns a 400 naming the `^\d+-\d+$` pattern.
+        const byKey = await api.get('/decision-instances/{decisionEvaluationInstanceKey}', {
+            params: {
+                decisionEvaluationInstanceKey: String(instances[0].decisionEvaluationInstanceKey),
+            },
+        });
+        const json = (await (0, assertions_1.assertOk)(byKey));
+        (0, assertions_1.assertRequiredFields)(json, [
+            'decisionEvaluationInstanceKey',
+            'decisionDefinitionId',
+            'state',
+        ]);
+        (0, test_1.expect)(json.decisionDefinitionId).toBe(decisionId);
+    });
+    (0, api_1.test)('exposes the evaluated inputs and outputs of an instance', async ({ api, resources, }) => {
+        const { deployed } = await deployTestDecision(api, resources, 'decision-api');
+        const evaluation = await api.post('/decision-definitions/evaluation', {
+            body: {
+                decisionDefinitionKey: deployed.decisionDefinitionKey,
+                variables: { inputVariable: 'match' },
+            },
+            tenant: 'root',
+        });
+        const evaluated = (await (0, assertions_1.assertOk)(evaluation));
+        const evaluationKey = String(evaluated.decisionEvaluationKey);
+        // There are no `/evaluated-inputs` and `/evaluated-outputs`
+        // sub-resources: the single-instance GET carries `evaluatedInputs` and
+        // `matchedRules` inline, and the v2 spec marks both required on it. That
+        // also lets this assert the values rather than only that an array came
+        // back.
+        //
+        // The key comes from the search rather than the evaluation response: the
+        // GET is addressed by the compound `<evaluationKey>-<index>`, which the
+        // evaluation result does not carry. The search is scoped to this
+        // evaluation for the same reason as above — a definition-scoped one can
+        // return a sibling test's instance, whose input value differs.
+        await (0, eventually_1.eventually)(async () => {
+            const search = await api.post('/decision-instances/search', {
+                body: {
+                    filter: { decisionEvaluationKey: evaluationKey },
+                    page: { limit: 1 },
+                },
+            });
+            const page = await (0, assertions_1.assertPaginated)(search, { minItems: 1 });
+            const decisionEvaluationInstanceKey = String(page.items[0]
+                .decisionEvaluationInstanceKey);
+            const response = await api.get('/decision-instances/{decisionEvaluationInstanceKey}', { params: { decisionEvaluationInstanceKey } });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, test_1.expect)(json.evaluatedInputs).toEqual([
+                test_1.expect.objectContaining({ inputValue: '"match"' }),
+            ]);
+            (0, test_1.expect)(json.matchedRules).toEqual([
+                test_1.expect.objectContaining({ ruleId: 'rule_match' }),
+            ]);
+        });
+    });
+    (0, api_1.test)('rejects evaluating an absent decision', async ({ api }) => {
+        const response = await api.post('/decision-definitions/evaluation', {
+            body: { decisionDefinitionKey: keys_1.ABSENT_ROUTABLE_KEY, variables: {} },
+            tenant: 'root',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects a lookup for an absent decision key', async ({ api }) => {
+        const response = await api.get('/decision-definitions/{decisionDefinitionKey}', { params: { decisionDefinitionKey: keys_1.ABSENT_KEY } });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects a malformed decision key', async ({ api }) => {
+        const response = await api.get('/decision-definitions/{decisionDefinitionKey}', { params: { decisionDefinitionKey: 'not-a-key' } });
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+});
+api_1.test.describe('Decision requirements', () => {
+    (0, api_1.test)('returns the requirements definition by key', async ({ api, resources, }) => {
+        const { deployed } = await deployTestDecision(api, resources, 'drd-api');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/decision-requirements/{decisionRequirementsKey}', { params: { decisionRequirementsKey: deployed.decisionRequirementsKey } });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, assertions_1.assertRequiredFields)(json, [
+                'decisionRequirementsKey',
+                'decisionRequirementsId',
+                'version',
+            ]);
+        });
+    });
+    (0, api_1.test)('returns the requirements XML by key', async ({ api, resources }) => {
+        const { decisionId, deployed } = await deployTestDecision(api, resources, 'drd-api');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/decision-requirements/{decisionRequirementsKey}/xml', { params: { decisionRequirementsKey: deployed.decisionRequirementsKey } });
+            await (0, assertions_1.assertStatus)(response, 200);
+            (0, test_1.expect)(await response.text()).toContain(decisionId);
+        });
+    });
+    (0, api_1.test)('finds the requirements through search', async ({ api, resources }) => {
+        const { deployed } = await deployTestDecision(api, resources, 'drd-api');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/decision-requirements/search', {
+                body: {
+                    filter: { decisionRequirementsKey: deployed.decisionRequirementsKey },
+                },
+            });
+            await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+        });
+    });
+    (0, api_1.test)('rejects a lookup for absent requirements', async ({ api }) => {
+        const response = await api.get('/decision-requirements/{decisionRequirementsKey}', { params: { decisionRequirementsKey: keys_1.ABSENT_KEY } });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+});

package/dist/tests/api/v2/deployment/deployment-api-tests.spec.d.ts

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