@camunda/e2e-test-suite 0.0.742 → 0.0.743

package/dist/tests/8.10/optimize-agentic-control-panel-api.spec.d.ts

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

package/dist/tests/8.10/optimize-agentic-control-panel-api.spec.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const test_1 = require("@playwright/test");
+const _8_10_1 = require("../../fixtures/8.10");
+const _setup_1 = require("../../test-setup.js");
+const UtilitiesPage_1 = require("../../pages/8.10/UtilitiesPage");
+const users_1 = require("../../utils/users");
+const agenticDashboardHelpers_1 = require("../../utils/agenticDashboardHelpers");
+const testUser = (0, users_1.getTestUser)('twentyFirstUser');
+const clusterName = 'Test Cluster';
+_8_10_1.test.describe.configure({ mode: 'serial' });
+_8_10_1.test.describe('Agentic Control Plane Dashboard API Tests @agentic-dashboard-api @8.10', () => {
+    _8_10_1.test.beforeEach(async ({ page, loginPage }, testInfo) => {
+        await (0, UtilitiesPage_1.loginWithRetry)(page, loginPage, testUser, (testInfo.workerIndex + 1) * 1000);
+    });
+    _8_10_1.test.afterEach(async ({ page }, testInfo) => {
+        await (0, _setup_1.captureScreenshot)(page, testInfo);
+        await (0, _setup_1.captureFailureVideo)(page, testInfo);
+    });
+    (0, _8_10_1.test)('Dashboard API responses load without server errors', async ({ page, appsPage, optimizeHomePage, }) => {
+        const responses = await (0, agenticDashboardHelpers_1.captureDashboardResponses)(page, async () => {
+            await (0, agenticDashboardHelpers_1.openAgenticControlPlane)(page, appsPage, optimizeHomePage, clusterName);
+        });
+        const dashboardResponses = responses.filter(agenticDashboardHelpers_1.isLikelyDashboardApiResponse);
+        (0, test_1.expect)(dashboardResponses.length).toBeGreaterThan(0);
+        (0, test_1.expect)(dashboardResponses.some(agenticDashboardHelpers_1.isAgenticDashboardDefinitionResponse)).toBe(true);
+        for (const response of dashboardResponses) {
+            (0, test_1.expect)(response.status).toBe(200);
+        }
+    });
+    (0, _8_10_1.test)('Dashboard payload exposes execution count and comparison data', async ({ page, appsPage, optimizeHomePage, }) => {
+        const responses = await (0, agenticDashboardHelpers_1.captureDashboardResponses)(page, async () => {
+            await (0, agenticDashboardHelpers_1.openAgenticControlPlane)(page, appsPage, optimizeHomePage, clusterName);
+        });
+        const definitionBodies = (0, agenticDashboardHelpers_1.parseJsonResponseBodies)(responses.filter(agenticDashboardHelpers_1.isAgenticDashboardDefinitionResponse));
+        (0, test_1.expect)(definitionBodies.length).toBeGreaterThan(0);
+        (0, test_1.expect)(definitionBodies.some(agenticDashboardHelpers_1.dashboardHasComparisonTile)).toBe(true);
+        const reportBodies = (0, agenticDashboardHelpers_1.parseJsonResponseBodies)(responses.filter(agenticDashboardHelpers_1.isReportEvaluateResponse));
+        (0, test_1.expect)(reportBodies.length).toBeGreaterThan(0);
+        const executionReport = (0, agenticDashboardHelpers_1.findReportByName)(reportBodies, agenticDashboardHelpers_1.EXECUTION_REPORT_NAME);
+        (0, test_1.expect)(executionReport).toBeDefined();
+        const executionCount = (0, agenticDashboardHelpers_1.getReportNumericResult)(executionReport);
+        (0, test_1.expect)(typeof executionCount).toBe('number');
+        (0, test_1.expect)(Number.isFinite(executionCount)).toBe(true);
+    });
+    (0, _8_10_1.test)('Dashboard API uses current terminology and not legacy wording', async ({ page, appsPage, optimizeHomePage, }) => {
+        const responses = await (0, agenticDashboardHelpers_1.captureDashboardResponses)(page, async () => {
+            await (0, agenticDashboardHelpers_1.openAgenticControlPlane)(page, appsPage, optimizeHomePage, clusterName);
+        });
+        const dashboardResponses = responses.filter(agenticDashboardHelpers_1.isLikelyDashboardApiResponse);
+        (0, test_1.expect)(dashboardResponses.length).toBeGreaterThan(0);
+        const joined = dashboardResponses
+            .map((r) => r.bodyText)
+            .join('\n')
+            .toLowerCase();
+        (0, test_1.expect)(joined.includes(agenticDashboardHelpers_1.CURRENT_TERMINOLOGY)).toBeTruthy();
+        (0, test_1.expect)(joined.includes(agenticDashboardHelpers_1.LEGACY_TERMINOLOGY)).toBeFalsy();
+    });
+    (0, _8_10_1.test)('Changing the date range triggers refreshed report API calls', async ({ page, appsPage, optimizeHomePage, }) => {
+        await (0, agenticDashboardHelpers_1.openAgenticControlPlane)(page, appsPage, optimizeHomePage, clusterName);
+        let dateRangeChanged = false;
+        const responses = await (0, agenticDashboardHelpers_1.captureDashboardResponses)(page, async () => {
+            dateRangeChanged = await (0, agenticDashboardHelpers_1.changeDashboardDateRange)(page);
+        });
+        (0, test_1.expect)(dateRangeChanged).toBe(true);
+        const reportResponses = responses.filter(agenticDashboardHelpers_1.isReportEvaluateResponse);
+        (0, test_1.expect)(reportResponses.length).toBeGreaterThan(0);
+        for (const response of reportResponses) {
+            (0, test_1.expect)(response.status).toBe(200);
+        }
+    });
+    (0, _8_10_1.test)('Report payloads do not expose Phase 1 out-of-scope details', async ({ page, appsPage, optimizeHomePage, }) => {
+        const responses = await (0, agenticDashboardHelpers_1.captureDashboardResponses)(page, async () => {
+            await (0, agenticDashboardHelpers_1.openAgenticControlPlane)(page, appsPage, optimizeHomePage, clusterName);
+        });
+        const dashboardResponses = responses.filter(agenticDashboardHelpers_1.isLikelyDashboardApiResponse);
+        (0, test_1.expect)(dashboardResponses.length).toBeGreaterThan(0);
+        const joined = dashboardResponses
+            .map((r) => r.bodyText)
+            .join('\n')
+            .toLowerCase();
+        (0, test_1.expect)(joined.includes('reasoning token')).toBeFalsy();
+        (0, test_1.expect)(joined.includes('tool_name')).toBeFalsy();
+        (0, test_1.expect)(joined.includes('per-tool')).toBeFalsy();
+    });
+});

package/dist/utils/agenticDashboardHelpers.d.ts

@@ -0,0 +1,37 @@
+import { type Page } from '@playwright/test';
+export type CapturedResponse = {
+    url: string;
+    method: string;
+    status: number;
+    bodyText: string;
+    contentType: string;
+};
+type AppsPage = {
+    clickCamundaApps: () => Promise<void>;
+    clickOptimize: (clusterName: string) => Promise<void>;
+};
+type OptimizeHomePage = {
+    optimizeBanner: {
+        isVisible: (opts?: {
+            timeout?: number;
+        }) => Promise<boolean>;
+    };
+};
+type RoleName = 'link' | 'button' | 'option' | 'menuitem' | 'tab';
+export declare const AGENTIC_DASHBOARD_DEFINITION_PATH = "/api/dashboard/agentic";
+export declare const REPORT_EVALUATE_PATH_PATTERN: RegExp;
+export declare const EXECUTION_REPORT_NAME = "total executions";
+export declare const CURRENT_TERMINOLOGY = "total executions";
+export declare const LEGACY_TERMINOLOGY = "completed agent runs";
+export declare function clickFirstVisibleByName(page: Page, role: RoleName, names: string[]): Promise<boolean>;
+export declare function openAgenticControlPlane(page: Page, appsPage: AppsPage, optimizeHomePage: OptimizeHomePage, clusterName: string): Promise<void>;
+export declare function changeDashboardDateRange(page: Page): Promise<boolean>;
+export declare function isAgenticDashboardDefinitionResponse(response: CapturedResponse): boolean;
+export declare function isReportEvaluateResponse(response: CapturedResponse): boolean;
+export declare function isLikelyDashboardApiResponse(response: CapturedResponse): boolean;
+export declare function captureDashboardResponses(page: Page, action: () => Promise<void>): Promise<CapturedResponse[]>;
+export declare function parseJsonResponseBodies(responses: CapturedResponse[]): unknown[];
+export declare function findReportByName(bodies: unknown[], name: string): unknown;
+export declare function getReportNumericResult(body: unknown): number | undefined;
+export declare function dashboardHasComparisonTile(definition: unknown): boolean;
+export {};

package/dist/utils/agenticDashboardHelpers.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardHasComparisonTile = exports.getReportNumericResult = exports.findReportByName = exports.parseJsonResponseBodies = exports.captureDashboardResponses = exports.isLikelyDashboardApiResponse = exports.isReportEvaluateResponse = exports.isAgenticDashboardDefinitionResponse = exports.changeDashboardDateRange = exports.openAgenticControlPlane = exports.clickFirstVisibleByName = exports.LEGACY_TERMINOLOGY = exports.CURRENT_TERMINOLOGY = exports.EXECUTION_REPORT_NAME = exports.REPORT_EVALUATE_PATH_PATTERN = exports.AGENTIC_DASHBOARD_DEFINITION_PATH = void 0;
+const test_1 = require("@playwright/test");
+exports.AGENTIC_DASHBOARD_DEFINITION_PATH = '/api/dashboard/agentic';
+exports.REPORT_EVALUATE_PATH_PATTERN = /\/api\/report\/[^/]+\/evaluate/;
+exports.EXECUTION_REPORT_NAME = 'total executions';
+exports.CURRENT_TERMINOLOGY = 'total executions';
+exports.LEGACY_TERMINOLOGY = 'completed agent runs';
+const candidateDashboardLabels = [
+    'Agentic Control Plane',
+    'Control Plane',
+    'Agentic Dashboard',
+];
+async function clickFirstVisibleByName(page, role, names) {
+    for (const name of names) {
+        const locator = page.getByRole(role, { name, exact: false });
+        if (await locator
+            .first()
+            .isVisible({ timeout: 3000 })
+            .catch(() => false)) {
+            await locator.first().click({ timeout: 20000 });
+            return true;
+        }
+    }
+    return false;
+}
+exports.clickFirstVisibleByName = clickFirstVisibleByName;
+async function openAgenticControlPlane(page, appsPage, optimizeHomePage, clusterName) {
+    await appsPage.clickCamundaApps();
+    await appsPage.clickOptimize(clusterName);
+    await test_1.expect
+        .poll(async () => optimizeHomePage.optimizeBanner.isVisible({ timeout: 5000 }), {
+        timeout: 120000,
+    })
+        .toBe(true);
+    const clickedLink = await clickFirstVisibleByName(page, 'link', candidateDashboardLabels);
+    if (!clickedLink) {
+        const clickedButton = await clickFirstVisibleByName(page, 'button', candidateDashboardLabels);
+        (0, test_1.expect)(clickedButton).toBeTruthy();
+    }
+}
+exports.openAgenticControlPlane = openAgenticControlPlane;
+async function changeDashboardDateRange(page) {
+    const dateRange = page.locator('.dateRange').first();
+    const trigger = dateRange.locator('button.cds--list-box__field').first();
+    const triggerReady = await trigger
+        .waitFor({ state: 'visible', timeout: 30000 })
+        .then(() => true)
+        .catch(() => false);
+    if (!triggerReady) {
+        return false;
+    }
+    await trigger.click({ timeout: 20000 });
+    const menu = page.locator('ul[role="menu"].cds--menu--shown').last();
+    const menuReady = await menu
+        .waitFor({ state: 'visible', timeout: 10000 })
+        .then(() => true)
+        .catch(() => false);
+    if (!menuReady) {
+        return false;
+    }
+    const options = menu.locator('[role="menuitemcheckbox"]');
+    await test_1.expect
+        .poll(async () => options.count(), { timeout: 10000 })
+        .toBeGreaterThan(0);
+    const optionCount = await options.count();
+    for (let index = 0; index < optionCount; index += 1) {
+        const option = options.nth(index);
+        const isChecked = (await option.getAttribute('aria-checked')) === 'true';
+        if (!isChecked) {
+            await option.click({ timeout: 15000 });
+            return true;
+        }
+    }
+    await page.keyboard.press('Escape').catch(() => false);
+    return false;
+}
+exports.changeDashboardDateRange = changeDashboardDateRange;
+function isAgenticDashboardDefinitionResponse(response) {
+    return response.url.toLowerCase().includes(exports.AGENTIC_DASHBOARD_DEFINITION_PATH);
+}
+exports.isAgenticDashboardDefinitionResponse = isAgenticDashboardDefinitionResponse;
+function isReportEvaluateResponse(response) {
+    return exports.REPORT_EVALUATE_PATH_PATTERN.test(response.url.toLowerCase());
+}
+exports.isReportEvaluateResponse = isReportEvaluateResponse;
+function isLikelyDashboardApiResponse(response) {
+    return (isAgenticDashboardDefinitionResponse(response) ||
+        isReportEvaluateResponse(response));
+}
+exports.isLikelyDashboardApiResponse = isLikelyDashboardApiResponse;
+async function captureDashboardResponses(page, action) {
+    const captured = [];
+    const listener = async (response) => {
+        try {
+            const request = response.request();
+            const method = request.method();
+            if (method !== 'GET' && method !== 'POST')
+                return;
+            const contentType = response.headers()['content-type'] || '';
+            if (!contentType.includes('application/json'))
+                return;
+            const bodyText = await response.text();
+            captured.push({
+                url: response.url(),
+                method,
+                status: response.status(),
+                bodyText,
+                contentType,
+            });
+        }
+        catch {
+            return;
+        }
+    };
+    page.on('response', listener);
+    await action();
+    await page.waitForLoadState('networkidle', { timeout: 30000 }).catch(() => { });
+    await page.waitForTimeout(5000);
+    page.off('response', listener);
+    return captured;
+}
+exports.captureDashboardResponses = captureDashboardResponses;
+function parseJsonResponseBodies(responses) {
+    const parsed = [];
+    for (const response of responses) {
+        try {
+            parsed.push(JSON.parse(response.bodyText));
+        }
+        catch {
+            continue;
+        }
+    }
+    return parsed;
+}
+exports.parseJsonResponseBodies = parseJsonResponseBodies;
+function findReportByName(bodies, name) {
+    const target = name.toLowerCase();
+    for (const body of bodies) {
+        if (body !== null &&
+            typeof body === 'object' &&
+            typeof body.name === 'string' &&
+            (body.name.toLowerCase() === target ||
+                body.name.toLowerCase().includes(target))) {
+            return body;
+        }
+    }
+    return undefined;
+}
+exports.findReportByName = findReportByName;
+function getReportNumericResult(body) {
+    if (body === null || typeof body !== 'object')
+        return undefined;
+    const result = body.result;
+    if (result === null || typeof result !== 'object')
+        return undefined;
+    const measures = result.measures;
+    if (Array.isArray(measures)) {
+        for (const measure of measures) {
+            const data = measure?.data;
+            if (typeof data === 'number' && Number.isFinite(data))
+                return data;
+        }
+    }
+    const instanceCount = result.instanceCount;
+    if (typeof instanceCount === 'number' && Number.isFinite(instanceCount)) {
+        return instanceCount;
+    }
+    return undefined;
+}
+exports.getReportNumericResult = getReportNumericResult;
+function dashboardHasComparisonTile(definition) {
+    if (definition === null || typeof definition !== 'object')
+        return false;
+    const tiles = definition.tiles;
+    if (!Array.isArray(tiles))
+        return false;
+    return tiles.some((tile) => {
+        const configuration = tile?.configuration;
+        return (configuration !== null &&
+            typeof configuration === 'object' &&
+            configuration.comparisonPeriod === true);
+    });
+}
+exports.dashboardHasComparisonTile = dashboardHasComparisonTile;

package/package.json

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