@camunda/e2e-test-suite 0.0.868 → 0.0.870

package/dist/tests/8.10/optimize-exporter-filters-importer-e2e.spec.d.ts

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

package/dist/tests/8.10/optimize-exporter-filters-importer-e2e.spec.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const _8_10_1 = require("../../fixtures/8.10");
+const apiHelpers_1 = require("../../utils/apiHelpers");
+const randomName_1 = require("../../utils/randomName");
+const sleep_1 = require("../../utils/sleep");
+_8_10_1.test.describe.configure({ mode: 'serial' });
+const VARIABLE_DEFINITION_FILE = './resources/Job_Worker_Process.bpmn';
+const VARIABLE_DEFINITION_KEY = 'Job_Worker_Process';
+const OPTIMIZE_MODE_DEFINITION_FILE = './resources/Play_Test_User_Service_Task.bpmn';
+const OPTIMIZE_MODE_DEFINITION_KEY = 'Play_Test_User_Service_Task';
+const TYPE_STRING_VARIABLE = 'stringVar';
+const TYPE_OBJECT_VARIABLE = 'objectVar';
+const TYPE_CONTROL_VARIABLE = 'business_marker';
+const VALUE_TYPE_EXCLUSION_KEY = 'variableValueTypeExclusion';
+const OPTIMIZE_MODE_KEY = 'optimizeModeEnabled';
+const FILTER_REFLECT_TIMEOUT_MS = 30000;
+const FILTER_REFLECT_INTERVAL_MS = 3000;
+const IMPORT_POLL_TIMEOUT_MS = 180000;
+const IMPORT_POLL_INTERVAL_MS = 10000;
+let managementToken;
+let clusterUuid;
+let originalFilters = null;
+let dataFiltersAvailable = false;
+let zeebeToken;
+let optimizeCookie;
+let optimizeExportToken;
+let optimizeBaseUrl;
+const createdCollectionIds = [];
+const reportIdByDefinitionKey = new Map();
+const skipIfUnavailable = () => {
+    _8_10_1.test.skip(!dataFiltersAvailable, 'Console Data Filters API not reachable on this cluster (endpoint returned non-2xx or is not yet enabled). See epic camunda/product-hub#3288.');
+};
+const setFilters = async (config) => {
+    let current = {};
+    const currentResponse = await (0, apiHelpers_1.getClusterDataFilters)(managementToken, clusterUuid);
+    if (currentResponse.status() >= 200 && currentResponse.status() < 300) {
+        try {
+            current = (await currentResponse.json());
+        }
+        catch {
+            current = {};
+        }
+    }
+    const response = await (0, apiHelpers_1.updateClusterDataFilters)(managementToken, clusterUuid, {
+        ...current,
+        ...config,
+    });
+    return response.status();
+};
+const waitForFilterConfig = async (predicate) => {
+    const deadline = Date.now() + FILTER_REFLECT_TIMEOUT_MS;
+    let lastStatus = 0;
+    let lastBody = '';
+    while (Date.now() < deadline) {
+        const response = await (0, apiHelpers_1.getClusterDataFilters)(managementToken, clusterUuid);
+        lastStatus = response.status();
+        lastBody = await response.text().catch(() => '');
+        if (lastStatus >= 200 && lastStatus < 300) {
+            let body = null;
+            try {
+                body = JSON.parse(lastBody);
+            }
+            catch {
+                body = null;
+            }
+            if (body && predicate(body)) {
+                return;
+            }
+        }
+        await (0, sleep_1.sleep)(FILTER_REFLECT_INTERVAL_MS);
+    }
+    throw new Error(`Timed out after ${FILTER_REFLECT_TIMEOUT_MS}ms waiting for the cluster data-filters config to reflect the requested update (last HTTP status=${lastStatus}, last body=${lastBody.slice(0, 500)}).`);
+};
+const getOrCreateReport = async (request, definitionKey) => {
+    const cachedReportId = reportIdByDefinitionKey.get(definitionKey);
+    if (cachedReportId) {
+        return cachedReportId;
+    }
+    const collectionId = await (0, apiHelpers_1.createCollection)(request, {
+        name: await (0, randomName_1.randomNameAgregator)('ExporterFilters E2E'),
+        optimizeCookie,
+    });
+    createdCollectionIds.push(collectionId);
+    await (0, apiHelpers_1.updateCollectionScope)(request, {
+        optimizeCookie,
+        collectionId,
+        data: [
+            {
+                definitionKey,
+                definitionType: 'process',
+                tenants: ['<default>'],
+            },
+        ],
+    });
+    const reportResponse = await request.post(`${optimizeBaseUrl}/api/report/process/single`, {
+        headers: {
+            Cookie: optimizeCookie,
+            'Content-Type': 'application/json',
+        },
+        data: {
+            collectionId,
+            name: await (0, randomName_1.randomNameAgregator)('Raw Data'),
+            description: null,
+            data: {
+                definitions: [
+                    { key: definitionKey, versions: ['all'], tenantIds: ['<default>'] },
+                ],
+                view: { entity: null, properties: ['rawData'] },
+                groupBy: { type: 'none', value: null },
+                distributedBy: { type: 'none', value: null },
+                visualization: 'table',
+                filter: [],
+            },
+        },
+    });
+    (0, test_1.expect)(reportResponse.status()).toBe(200);
+    const reportId = (await reportResponse.json()).id;
+    reportIdByDefinitionKey.set(definitionKey, reportId);
+    return reportId;
+};
+const fetchImported = async (request, definitionKey) => {
+    const reportId = await getOrCreateReport(request, definitionKey);
+    const exportResponse = await request.get(`${optimizeBaseUrl}/api/public/export/report/${reportId}/result/json?paginationTimeout=60&limit=1000`, { headers: { Authorization: optimizeExportToken } });
+    const variableNames = new Set();
+    if (!exportResponse.ok()) {
+        const rawBody = await exportResponse.text().catch(() => '');
+        throw new Error(`Optimize export API returned ${exportResponse.status()} for report ${reportId}: ${rawBody.slice(0, 500)}`);
+    }
+    const body = (await exportResponse.json());
+    const result = (body.result ?? body);
+    const rows = (result.data ?? []);
+    for (const row of rows) {
+        const vars = row.variables;
+        if (Array.isArray(vars)) {
+            for (const entry of vars) {
+                if (typeof entry?.name === 'string') {
+                    variableNames.add(entry.name);
+                }
+            }
+        }
+        else if (vars && typeof vars === 'object') {
+            for (const name of Object.keys(vars)) {
+                variableNames.add(name);
+            }
+        }
+    }
+    const totalNumberOfRecords = typeof body.totalNumberOfRecords === 'number'
+        ? body.totalNumberOfRecords
+        : typeof result.totalNumberOfRecords === 'number'
+            ? result.totalNumberOfRecords
+            : rows.length;
+    return { instanceCount: totalNumberOfRecords, variableNames };
+};
+const waitForImportedInstance = async (request, definitionKey, predicate = (imported) => imported.instanceCount > 0) => {
+    const deadline = Date.now() + IMPORT_POLL_TIMEOUT_MS;
+    let latest = { instanceCount: 0, variableNames: new Set() };
+    while (Date.now() < deadline) {
+        latest = await fetchImported(request, definitionKey);
+        if (predicate(latest)) {
+            return latest;
+        }
+        await (0, sleep_1.sleep)(IMPORT_POLL_INTERVAL_MS);
+    }
+    throw new Error(`Timed out after ${IMPORT_POLL_TIMEOUT_MS}ms waiting for Optimize to import definition "${definitionKey}" (latest instanceCount=${latest.instanceCount}, variables=[${[...latest.variableNames].join(', ')}]).`);
+};
+_8_10_1.test.beforeAll(async ({ browser }) => {
+    try {
+        managementToken = await (0, apiHelpers_1.authConsoleManagementAPI)();
+        clusterUuid = (0, apiHelpers_1.getTestClusterUuid)();
+        const probe = await (0, apiHelpers_1.getClusterDataFilters)(managementToken, clusterUuid);
+        dataFiltersAvailable = probe.status() >= 200 && probe.status() < 300;
+        if (!dataFiltersAvailable) {
+            return;
+        }
+        try {
+            originalFilters = (await probe.json());
+        }
+        catch {
+            throw new Error(`Data Filters API probe returned ${probe.status()} but the response body was not valid JSON; refusing to mutate cluster filters without a restorable baseline.`);
+        }
+        zeebeToken = await (0, apiHelpers_1.authSaasAPI)();
+        optimizeExportToken = await (0, apiHelpers_1.authSaasAPI)(process.env.OPTIMIZE_API_TOKEN_AUDIENCE);
+        optimizeBaseUrl = process.env.CAMUNDA_OPTIMIZE_BASE_URL;
+        const page = await browser.newPage();
+        optimizeCookie = await (0, apiHelpers_1.getOptimizeCoockie)(page);
+        await page.close();
+    }
+    catch (error) {
+        if (dataFiltersAvailable) {
+            throw error;
+        }
+        console.warn(`Exporter filters E2E precheck failed before the Data Filters endpoint was confirmed reachable; skipping suite: ${error instanceof Error ? error.message : String(error)}`);
+    }
+});
+_8_10_1.test.afterAll(async ({ request }) => {
+    for (const collectionId of createdCollectionIds) {
+        try {
+            await request.delete(`${optimizeBaseUrl}/api/public/collection/${collectionId}`, { headers: { Authorization: optimizeExportToken } });
+        }
+        catch (error) {
+            console.warn(`Failed to delete Optimize collection ${collectionId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (dataFiltersAvailable && originalFilters) {
+        try {
+            await (0, apiHelpers_1.updateClusterDataFilters)(managementToken, clusterUuid, originalFilters);
+        }
+        catch (error) {
+            console.warn(`Failed to restore original data filters: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+});
+_8_10_1.test.describe('Optimize exporter filters — variable value type exclusion @optimize-exporter-filters-importer-e2e @8.10', () => {
+    _8_10_1.test.slow();
+    _8_10_1.test.beforeAll(async () => {
+        if (!dataFiltersAvailable) {
+            return;
+        }
+        const status = await setFilters({
+            variableFilter: { enabled: true },
+            [VALUE_TYPE_EXCLUSION_KEY]: ['Object'],
+        });
+        (0, test_1.expect)([200, 201, 204]).toContain(status);
+        await waitForFilterConfig((filters) => {
+            const exclusion = filters[VALUE_TYPE_EXCLUSION_KEY];
+            return Array.isArray(exclusion) && exclusion.includes('Object');
+        });
+    });
+    (0, _8_10_1.test)('string variable reaches Optimize', async ({ request }) => {
+        skipIfUnavailable();
+        await _8_10_1.test.step('start a process instance carrying a string variable and a positive control', async () => {
+            const processKey = await (0, apiHelpers_1.deployProcess)(VARIABLE_DEFINITION_FILE, zeebeToken);
+            (0, test_1.expect)(processKey).not.toBeNull();
+            await (0, apiHelpers_1.createProcessInstance)(String(processKey), zeebeToken, undefined, undefined, {
+                [TYPE_STRING_VARIABLE]: 'hello',
+                [TYPE_CONTROL_VARIABLE]: 'present',
+            });
+        });
+        await _8_10_1.test.step('assert the string variable appears in the exported data', async () => {
+            const imported = await waitForImportedInstance(request, VARIABLE_DEFINITION_KEY, (result) => result.variableNames.has(TYPE_STRING_VARIABLE));
+            (0, test_1.expect)(imported.variableNames).toContain(TYPE_STRING_VARIABLE);
+        });
+    });
+    (0, _8_10_1.test)('object variable is excluded while the positive control is kept', async ({ request, }) => {
+        skipIfUnavailable();
+        let baseline = 0;
+        await _8_10_1.test.step('capture the current imported instance count for the process definition', async () => {
+            baseline = (await fetchImported(request, VARIABLE_DEFINITION_KEY))
+                .instanceCount;
+        });
+        await _8_10_1.test.step('start a process instance carrying an object variable and a positive control', async () => {
+            const processKey = await (0, apiHelpers_1.deployProcess)(VARIABLE_DEFINITION_FILE, zeebeToken);
+            (0, test_1.expect)(processKey).not.toBeNull();
+            await (0, apiHelpers_1.createProcessInstance)(String(processKey), zeebeToken, undefined, undefined, {
+                [TYPE_OBJECT_VARIABLE]: { nested: true },
+                [TYPE_CONTROL_VARIABLE]: 'present',
+            });
+        });
+        await _8_10_1.test.step('wait until the new instance is imported to prove the import cycle ran past this point', async () => {
+            const imported = await waitForImportedInstance(request, VARIABLE_DEFINITION_KEY, (result) => result.instanceCount > baseline);
+            (0, test_1.expect)(imported.instanceCount).toBeGreaterThan(baseline);
+        });
+        await _8_10_1.test.step('assert the object variable is absent from the exported data', async () => {
+            const imported = await fetchImported(request, VARIABLE_DEFINITION_KEY);
+            (0, test_1.expect)(imported.variableNames).toContain(TYPE_CONTROL_VARIABLE);
+            (0, test_1.expect)(imported.variableNames.has(TYPE_OBJECT_VARIABLE)).toBe(false);
+        });
+    });
+});
+_8_10_1.test.describe('Optimize exporter filters — Optimize mode restricted record export @optimize-exporter-filters-importer-e2e @8.10', () => {
+    _8_10_1.test.slow();
+    _8_10_1.test.beforeAll(async () => {
+        if (!dataFiltersAvailable) {
+            return;
+        }
+        const status = await setFilters({
+            variableFilter: { enabled: true },
+            [OPTIMIZE_MODE_KEY]: true,
+        });
+        (0, test_1.expect)([200, 201, 204]).toContain(status);
+        await waitForFilterConfig((filters) => filters[OPTIMIZE_MODE_KEY] === true);
+    });
+    (0, _8_10_1.test)('assert process instance reached Optimize (implies Optimize mode passed required record types)', async ({ request, }) => {
+        skipIfUnavailable();
+        let baseline = 0;
+        await _8_10_1.test.step('capture the current imported instance count for the process definition', async () => {
+            baseline = (await fetchImported(request, OPTIMIZE_MODE_DEFINITION_KEY))
+                .instanceCount;
+        });
+        await _8_10_1.test.step('start a process instance', async () => {
+            const processKey = await (0, apiHelpers_1.deployProcess)(OPTIMIZE_MODE_DEFINITION_FILE, zeebeToken);
+            (0, test_1.expect)(processKey).not.toBeNull();
+            await (0, apiHelpers_1.createProcessInstance)(String(processKey), zeebeToken);
+        });
+        await _8_10_1.test.step('assert a new process instance reached Optimize (implies Optimize mode passed required record types)', async () => {
+            const imported = await waitForImportedInstance(request, OPTIMIZE_MODE_DEFINITION_KEY, (result) => result.instanceCount > baseline);
+            (0, test_1.expect)(imported.instanceCount).toBeGreaterThan(baseline);
+        });
+    });
+});

package/package.json

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