@camunda/e2e-test-suite 0.0.1241 → 0.0.1243

package/dist/tests/api/v2/identity/role-api-tests.spec.js

@@ -0,0 +1,212 @@
+"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 beans_1 = require("../../../../utils/api/beans");
+const identity_1 = require("../../../../utils/api/identity");
+const eventually_1 = require("../../../../utils/api/eventually");
+const bpmn_1 = require("../../../../utils/api/bpmn");
+const capabilities_1 = require("../../../../utils/api/capabilities");
+async function createRole(api, resources) {
+    const role = (0, beans_1.newRole)();
+    const response = await api.post('/roles', { body: role, tenant: 'none' });
+    await (0, assertions_1.assertCreated)(response);
+    resources.track('role', role.roleId);
+    return role;
+}
+api_1.test.describe('Roles', () => {
+    (0, api_1.test)('creates a role', async ({ api, resources }) => {
+        const role = (0, beans_1.newRole)();
+        const response = await api.post('/roles', { body: role, tenant: 'none' });
+        // The shell suite expected `200 201 403` here, so a cluster rejecting
+        // every role creation reported this as a pass.
+        const created = (await (0, assertions_1.assertCreated)(response));
+        (0, assertions_1.assertRequiredFields)(created, beans_1.roleRequiredFields);
+        (0, test_1.expect)(created.roleId).toBe(role.roleId);
+        (0, test_1.expect)(created.name).toBe(role.name);
+        resources.track('role', role.roleId);
+    });
+    (0, api_1.test)('returns a created role by id', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/roles/{roleId}', {
+                params: { roleId: role.roleId },
+                tenant: 'none',
+            });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, test_1.expect)(json.roleId).toBe(role.roleId);
+            (0, test_1.expect)(json.name).toBe(role.name);
+        });
+    });
+    (0, api_1.test)('updates a role', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        const updatedName = `Updated ${role.name}`;
+        const response = await api.put('/roles/{roleId}', {
+            params: { roleId: role.roleId },
+            body: { name: updatedName, description: 'updated by the API suite' },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200, 204], 'the update returns the role on 8.8+ and an empty body on earlier minors');
+        await (0, eventually_1.eventually)(async () => {
+            const lookup = await api.get('/roles/{roleId}', {
+                params: { roleId: role.roleId },
+                tenant: 'none',
+            });
+            const json = (await (0, assertions_1.assertOk)(lookup));
+            (0, test_1.expect)(json.name).toBe(updatedName);
+        });
+    });
+    (0, api_1.test)('finds a created role through search', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/roles/search', {
+                body: { filter: { roleId: role.roleId }, page: { limit: 10 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { exactItems: 1 });
+            (0, test_1.expect)(page.items[0].roleId).toBe(role.roleId);
+        });
+    });
+    (0, api_1.test)('deletes a role', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        const response = await api.delete('/roles/{roleId}', {
+            params: { roleId: role.roleId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [204], 'deletion is acknowledged');
+        resources.forget('role', role.roleId);
+        await (0, eventually_1.eventually)(async () => {
+            const lookup = await api.get('/roles/{roleId}', {
+                params: { roleId: role.roleId },
+                tenant: 'none',
+            });
+            await (0, assertions_1.assertNotFound)(lookup);
+        });
+    });
+    (0, api_1.test)('rejects a role whose id already exists', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        const response = await api.post('/roles', {
+            body: (0, beans_1.newRole)({ roleId: role.roleId }),
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertConflict)(response);
+    });
+    (0, api_1.test)('rejects a role with no name', async ({ api }) => {
+        const response = await api.post('/roles', {
+            body: { roleId: (0, bpmn_1.uniqueId)('role'), description: 'no name' },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertBadRequest)(response, /name/i);
+    });
+    (0, api_1.test)('rejects a role with no id', async ({ api }) => {
+        const response = await api.post('/roles', {
+            body: { name: 'nameless role' },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertBadRequest)(response, /roleId/i);
+    });
+    (0, api_1.test)('rejects a lookup for an absent role', async ({ api }) => {
+        const response = await api.get('/roles/{roleId}', {
+            params: { roleId: (0, bpmn_1.uniqueId)('absent-role') },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects an unauthenticated role creation', async ({ api }) => {
+        api_1.test.skip(capabilities_1.unauthenticatedAccessAllowed !== false, capabilities_1.unauthenticatedAccessAllowed === false
+            ? ''
+            : capabilities_1.unauthenticatedAccessAllowed);
+        const response = await api.post('/roles', {
+            body: (0, beans_1.newRole)(),
+            tenant: 'none',
+            authorization: null,
+        });
+        await (0, assertions_1.assertUnauthorized)(response);
+    });
+});
+api_1.test.describe('Role membership', () => {
+    (0, api_1.test)('assigns and removes a user', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        const username = await (0, identity_1.provisionUsername)(api, resources);
+        const assign = await api.put('/roles/{roleId}/users/{username}', {
+            params: { roleId: role.roleId, username },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(assign, [204], 'assignment is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/roles/{roleId}/users/search', {
+                params: { roleId: role.roleId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const usernames = page.items.map((item) => item.username);
+            (0, test_1.expect)(usernames).toContain(username);
+        });
+        const remove = await api.delete('/roles/{roleId}/users/{username}', {
+            params: { roleId: role.roleId, username },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(remove, [204], 'removal is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/roles/{roleId}/users/search', {
+                params: { roleId: role.roleId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response);
+            const usernames = page.items.map((item) => item.username);
+            (0, test_1.expect)(usernames).not.toContain(username);
+        });
+    });
+    (0, api_1.test)('assigns and removes a group', async ({ api, resources }) => {
+        const role = await createRole(api, resources);
+        const group = (0, beans_1.newGroup)();
+        await (0, assertions_1.assertCreated)(await api.post('/groups', { body: group, tenant: 'none' }));
+        resources.track('group', group.groupId);
+        const assign = await api.put('/roles/{roleId}/groups/{groupId}', {
+            params: { roleId: role.roleId, groupId: group.groupId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(assign, [204], 'assignment is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/roles/{roleId}/groups/search', {
+                params: { roleId: role.roleId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const groupIds = page.items.map((item) => item.groupId);
+            (0, test_1.expect)(groupIds).toContain(group.groupId);
+        });
+        const remove = await api.delete('/roles/{roleId}/groups/{groupId}', {
+            params: { roleId: role.roleId, groupId: group.groupId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(remove, [204], 'removal is acknowledged');
+    });
+    (0, api_1.test)('rejects assigning a user to an absent role', async ({ api, resources, }) => {
+        const username = await (0, identity_1.provisionUsername)(api, resources);
+        const response = await api.put('/roles/{roleId}/users/{username}', {
+            params: { roleId: (0, bpmn_1.uniqueId)('absent-role'), username },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects assigning an absent user to a role', async ({ api, resources, }) => {
+        const role = await createRole(api, resources);
+        const response = await api.put('/roles/{roleId}/users/{username}', {
+            params: {
+                roleId: role.roleId,
+                username: (0, bpmn_1.uniqueId)('absent-user'),
+            },
+            tenant: 'none',
+        });
+        // The shell suite asserted `200 204` here — that is, it asserted the
+        // assignment SUCCEEDS for a user that does not exist. Whether it should
+        // depends on the cluster's identity mode, so the expectation follows the
+        // mode and states why.
+        await (0, assertions_1.assertStatusIn)(response, [capabilities_1.absentUserMembership.status], capabilities_1.absentUserMembership.reason);
+    });
+});

package/dist/tests/api/v2/identity/tenant-api-tests.spec.d.ts

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

package/dist/tests/api/v2/identity/tenant-api-tests.spec.js

@@ -0,0 +1,319 @@
+"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 beans_1 = require("../../../../utils/api/beans");
+const identity_1 = require("../../../../utils/api/identity");
+const eventually_1 = require("../../../../utils/api/eventually");
+const bpmn_1 = require("../../../../utils/api/bpmn");
+const capabilities_1 = require("../../../../utils/api/capabilities");
+async function createTenant(api, resources) {
+    const tenant = (0, beans_1.newTenant)();
+    await (0, assertions_1.assertCreated)(await api.post('/tenants', { body: tenant, tenant: 'none' }));
+    resources.track('tenant', tenant.tenantId);
+    return tenant;
+}
+api_1.test.describe('Tenants', () => {
+    (0, api_1.test)('creates a tenant', async ({ api, resources }) => {
+        const tenant = (0, beans_1.newTenant)();
+        const response = await api.post('/tenants', {
+            body: tenant,
+            tenant: 'none',
+        });
+        // The shell suite expected `200 201 403 404 405` — five statuses, three of
+        // which mean the request never took effect.
+        const created = (await (0, assertions_1.assertCreated)(response));
+        (0, assertions_1.assertRequiredFields)(created, beans_1.tenantRequiredFields);
+        (0, test_1.expect)(created.tenantId).toBe(tenant.tenantId);
+        resources.track('tenant', tenant.tenantId);
+    });
+    (0, api_1.test)('returns a created tenant by id', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/tenants/{tenantId}', {
+                params: { tenantId: tenant.tenantId },
+                tenant: 'none',
+            });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, test_1.expect)(json.tenantId).toBe(tenant.tenantId);
+            (0, test_1.expect)(json.name).toBe(tenant.name);
+        });
+    });
+    (0, api_1.test)('updates a tenant', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const updatedName = `Updated ${tenant.name}`;
+        const response = await api.put('/tenants/{tenantId}', {
+            params: { tenantId: tenant.tenantId },
+            body: { name: updatedName, description: 'updated by the API suite' },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200, 204], 'the update returns the tenant on 8.8+ and an empty body on earlier minors');
+        await (0, eventually_1.eventually)(async () => {
+            const lookup = await api.get('/tenants/{tenantId}', {
+                params: { tenantId: tenant.tenantId },
+                tenant: 'none',
+            });
+            const json = (await (0, assertions_1.assertOk)(lookup));
+            (0, test_1.expect)(json.name).toBe(updatedName);
+        });
+    });
+    (0, api_1.test)('finds a created tenant through search', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/tenants/search', {
+                body: { filter: { tenantId: tenant.tenantId }, page: { limit: 10 } },
+                tenant: 'none',
+            });
+            await (0, assertions_1.assertPaginated)(response, { exactItems: 1 });
+        });
+    });
+    (0, api_1.test)('deletes a tenant', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const response = await api.delete('/tenants/{tenantId}', {
+            params: { tenantId: tenant.tenantId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [204], 'deletion is acknowledged');
+        resources.forget('tenant', tenant.tenantId);
+        await (0, eventually_1.eventually)(async () => {
+            const lookup = await api.get('/tenants/{tenantId}', {
+                params: { tenantId: tenant.tenantId },
+                tenant: 'none',
+            });
+            await (0, assertions_1.assertNotFound)(lookup);
+        });
+    });
+    (0, api_1.test)('rejects a tenant whose id already exists', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const response = await api.post('/tenants', {
+            body: (0, beans_1.newTenant)({ tenantId: tenant.tenantId }),
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertConflict)(response);
+    });
+    (0, api_1.test)('rejects an over-long tenant id', async ({ api }) => {
+        const response = await api.post('/tenants', {
+            body: (0, beans_1.newTenant)({ tenantId: 'a'.repeat(300) }),
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertBadRequest)(response);
+    });
+    (0, api_1.test)('rejects a lookup for an absent tenant', async ({ api }) => {
+        const response = await api.get('/tenants/{tenantId}', {
+            params: { tenantId: (0, bpmn_1.uniqueId)('absent-tenant') },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects an unauthenticated tenant creation', async ({ api }) => {
+        api_1.test.skip(capabilities_1.unauthenticatedAccessAllowed !== false, capabilities_1.unauthenticatedAccessAllowed === false
+            ? ''
+            : capabilities_1.unauthenticatedAccessAllowed);
+        const response = await api.post('/tenants', {
+            body: (0, beans_1.newTenant)(),
+            tenant: 'none',
+            authorization: null,
+        });
+        await (0, assertions_1.assertUnauthorized)(response);
+    });
+});
+api_1.test.describe('Tenant membership', () => {
+    (0, api_1.test)('assigns and removes a user', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const username = await (0, identity_1.provisionUsername)(api, resources);
+        const assign = await api.put('/tenants/{tenantId}/users/{username}', {
+            params: { tenantId: tenant.tenantId, username },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(assign, [204], 'assignment is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/tenants/{tenantId}/users/search', {
+                params: { tenantId: tenant.tenantId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const usernames = page.items.map((item) => item.username);
+            (0, test_1.expect)(usernames).toContain(username);
+        });
+        const remove = await api.delete('/tenants/{tenantId}/users/{username}', {
+            params: { tenantId: tenant.tenantId, username },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(remove, [204], 'removal is acknowledged');
+    });
+    (0, api_1.test)('assigns and removes a group', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const group = (0, beans_1.newGroup)();
+        await (0, assertions_1.assertCreated)(await api.post('/groups', { body: group, tenant: 'none' }));
+        resources.track('group', group.groupId);
+        const assign = await api.put('/tenants/{tenantId}/groups/{groupId}', {
+            params: { tenantId: tenant.tenantId, groupId: group.groupId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(assign, [204], 'assignment is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/tenants/{tenantId}/groups/search', {
+                params: { tenantId: tenant.tenantId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            const page = await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+            const groupIds = page.items.map((item) => item.groupId);
+            (0, test_1.expect)(groupIds).toContain(group.groupId);
+        });
+        const remove = await api.delete('/tenants/{tenantId}/groups/{groupId}', {
+            params: { tenantId: tenant.tenantId, groupId: group.groupId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(remove, [204], 'removal is acknowledged');
+    });
+    (0, api_1.test)('assigns and removes a role', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const role = (0, beans_1.newRole)();
+        await (0, assertions_1.assertCreated)(await api.post('/roles', { body: role, tenant: 'none' }));
+        resources.track('role', role.roleId);
+        const assign = await api.put('/tenants/{tenantId}/roles/{roleId}', {
+            params: { tenantId: tenant.tenantId, roleId: role.roleId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(assign, [204], 'assignment is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/tenants/{tenantId}/roles/search', {
+                params: { tenantId: tenant.tenantId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+        });
+        const remove = await api.delete('/tenants/{tenantId}/roles/{roleId}', {
+            params: { tenantId: tenant.tenantId, roleId: role.roleId },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(remove, [204], 'removal is acknowledged');
+    });
+    (0, api_1.test)('assigns and removes a mapping rule', async ({ api, resources }) => {
+        const tenant = await createTenant(api, resources);
+        const rule = (0, beans_1.newMappingRule)();
+        await (0, assertions_1.assertCreated)(await api.post('/mapping-rules', { body: rule, tenant: 'none' }));
+        resources.track('mappingRule', rule.mappingRuleId);
+        const assign = await api.put('/tenants/{tenantId}/mapping-rules/{mappingRuleId}', {
+            params: {
+                tenantId: tenant.tenantId,
+                mappingRuleId: rule.mappingRuleId,
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(assign, [204], 'assignment is acknowledged');
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.post('/tenants/{tenantId}/mapping-rules/search', {
+                params: { tenantId: tenant.tenantId },
+                body: { page: { limit: 20 } },
+                tenant: 'none',
+            });
+            await (0, assertions_1.assertPaginated)(response, { minItems: 1 });
+        });
+        const remove = await api.delete('/tenants/{tenantId}/mapping-rules/{mappingRuleId}', {
+            params: {
+                tenantId: tenant.tenantId,
+                mappingRuleId: rule.mappingRuleId,
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(remove, [204], 'removal is acknowledged');
+    });
+    (0, api_1.test)('rejects assigning a user to an absent tenant', async ({ api, resources, }) => {
+        const username = await (0, identity_1.provisionUsername)(api, resources);
+        const response = await api.put('/tenants/{tenantId}/users/{username}', {
+            params: {
+                tenantId: (0, bpmn_1.uniqueId)('absent-tenant'),
+                username,
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects assigning an absent user to a tenant', async ({ api, resources, }) => {
+        const tenant = await createTenant(api, resources);
+        const response = await api.put('/tenants/{tenantId}/users/{username}', {
+            params: {
+                tenantId: tenant.tenantId,
+                username: (0, bpmn_1.uniqueId)('absent-user'),
+            },
+            tenant: 'none',
+        });
+        // The shell suite called this case "idempotent" and asserted
+        // `200 204 403 404` — i.e. it passed whether the API accepted or refused.
+        // The real answer depends on the cluster's identity mode; the expectation
+        // follows it and states why.
+        await (0, assertions_1.assertStatusIn)(response, [capabilities_1.absentUserMembership.status], capabilities_1.absentUserMembership.reason);
+    });
+});
+api_1.test.describe('Mapping rules', () => {
+    (0, api_1.test)('creates a mapping rule', async ({ api, resources }) => {
+        const rule = (0, beans_1.newMappingRule)();
+        const response = await api.post('/mapping-rules', {
+            body: rule,
+            tenant: 'none',
+        });
+        const created = (await (0, assertions_1.assertCreated)(response));
+        (0, assertions_1.assertRequiredFields)(created, ['mappingRuleId', 'claimName', 'claimValue']);
+        (0, test_1.expect)(created.mappingRuleId).toBe(rule.mappingRuleId);
+        resources.track('mappingRule', rule.mappingRuleId);
+    });
+    (0, api_1.test)('returns a created mapping rule by id', async ({ api, resources }) => {
+        const rule = (0, beans_1.newMappingRule)();
+        await (0, assertions_1.assertCreated)(await api.post('/mapping-rules', { body: rule, tenant: 'none' }));
+        resources.track('mappingRule', rule.mappingRuleId);
+        await (0, eventually_1.eventually)(async () => {
+            const response = await api.get('/mapping-rules/{mappingRuleId}', {
+                params: { mappingRuleId: rule.mappingRuleId },
+                tenant: 'none',
+            });
+            const json = (await (0, assertions_1.assertOk)(response));
+            (0, test_1.expect)(json.claimName).toBe(rule.claimName);
+            (0, test_1.expect)(json.claimValue).toBe(rule.claimValue);
+        });
+    });
+    (0, api_1.test)('updates a mapping rule', async ({ api, resources }) => {
+        const rule = (0, beans_1.newMappingRule)();
+        await (0, assertions_1.assertCreated)(await api.post('/mapping-rules', { body: rule, tenant: 'none' }));
+        resources.track('mappingRule', rule.mappingRuleId);
+        const response = await api.put('/mapping-rules/{mappingRuleId}', {
+            params: { mappingRuleId: rule.mappingRuleId },
+            body: {
+                claimName: rule.claimName,
+                claimValue: rule.claimValue,
+                name: `Updated ${rule.name}`,
+            },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertStatusIn)(response, [200, 204], 'the update returns the rule on 8.8+ and an empty body on earlier minors');
+    });
+    (0, api_1.test)('rejects a mapping rule whose id already exists', async ({ api, resources, }) => {
+        const rule = (0, beans_1.newMappingRule)();
+        await (0, assertions_1.assertCreated)(await api.post('/mapping-rules', { body: rule, tenant: 'none' }));
+        resources.track('mappingRule', rule.mappingRuleId);
+        const response = await api.post('/mapping-rules', {
+            body: (0, beans_1.newMappingRule)({ mappingRuleId: rule.mappingRuleId }),
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertConflict)(response);
+    });
+    (0, api_1.test)('rejects updating an absent mapping rule', async ({ api }) => {
+        const response = await api.put('/mapping-rules/{mappingRuleId}', {
+            params: { mappingRuleId: (0, bpmn_1.uniqueId)('absent-rule') },
+            body: { claimName: 'c', claimValue: 'v', name: 'absent' },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+    (0, api_1.test)('rejects deleting an absent mapping rule', async ({ api }) => {
+        const response = await api.delete('/mapping-rules/{mappingRuleId}', {
+            params: { mappingRuleId: (0, bpmn_1.uniqueId)('absent-rule') },
+            tenant: 'none',
+        });
+        await (0, assertions_1.assertNotFound)(response);
+    });
+});

package/dist/tests/api/v2/identity/user-api-tests.spec.d.ts

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