@camunda/e2e-test-suite 0.0.136 → 0.0.138

package/dist/fixtures/SM-8.8.d.ts

@@ -35,6 +35,7 @@ import { KeycloakLoginPage } from '../pages/SM-8.8/KeycloakLoginPage';
 import { OCIdentityAuthorizationsPage } from '../pages/SM-8.8/OCIdentityAuthorizationsPage';
 import { OCIdentityGroupsPage } from '../pages/SM-8.8/OCIdentityGroupsPage';
 import { OCTenantPage } from '../pages/SM-8.8/OCTenantPage';
+import { IdpCreatePage } from '../pages/SM-8.8/IdpCreatePage';
 type PlaywrightFixtures = {
     makeAxeBuilder: () => AxeBuilder;
     loginPage: LoginPage;
@@ -73,6 +74,7 @@ type PlaywrightFixtures = {
     connectorTemplatePage: ConnectorTemplatePage;
     ocIdentityGroupsPage: OCIdentityGroupsPage;
     ocTenantPage: OCTenantPage;
+    idpCreatePage: IdpCreatePage;
     overrideTrackingScripts: void;
 };
 declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & PlaywrightFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/dist/fixtures/SM-8.8.js

@@ -42,6 +42,7 @@ const KeycloakLoginPage_1 = require("../pages/SM-8.8/KeycloakLoginPage");
 const OCIdentityAuthorizationsPage_1 = require("../pages/SM-8.8/OCIdentityAuthorizationsPage");
 const OCIdentityGroupsPage_1 = require("../pages/SM-8.8/OCIdentityGroupsPage");
 const OCTenantPage_1 = require("../pages/SM-8.8/OCTenantPage");
+const IdpCreatePage_1 = require("../pages/SM-8.8/IdpCreatePage");
 const test = test_1.test.extend({
     makeAxeBuilder: async ({ page }, use) => {
         const makeAxeBuilder = () => new playwright_1.default({ page }).withTags([
@@ -161,6 +162,9 @@ const test = test_1.test.extend({
     ocTenantPage: async ({ page }, use) => {
         await use(new OCTenantPage_1.OCTenantPage(page));
     },
+    idpCreatePage: async ({ page }, use) => {
+        await use(new IdpCreatePage_1.IdpCreatePage(page));
+    },
     overrideTrackingScripts: [
         async ({ context }, use) => {
             await context.route('https://cmp.osano.com/16CVvwSNKHi9t1grQ/9403708a-488b-4f3b-aea6-613825dec79f/osano.js', (route) => route.fulfill({

package/dist/pages/SM-8.8/IdpCreatePage.d.ts

@@ -0,0 +1,83 @@
+import { Page, Locator } from '@playwright/test';
+declare class IdpCreatePage {
+    private page;
+    readonly createIdpTemplateButton: Locator;
+    readonly idpExtractionTemplateName: Locator;
+    readonly idpDescriptionField: Locator;
+    readonly providerDropdown: Locator;
+    readonly createIdpExtractionTemplateButton: Locator;
+    readonly unstructured_UploadFilesButton: Locator;
+    readonly extractButton: Locator;
+    readonly closeNotificationButton: Locator;
+    readonly unstructured_extractFieldName: Locator;
+    readonly unstructured_extractFieldPrompt: Locator;
+    readonly unstructured_addExtractionFieldButton: Locator;
+    readonly unstructured_extractionModelDropdown: Locator;
+    readonly unstructured_extractDocumentButton: Locator;
+    readonly unstructured_saveAsTestCaseButton: Locator;
+    readonly unstructured_testCaseSavedNotification: Locator;
+    readonly unstructured_validateExtractionTab: Locator;
+    readonly unstructured_expandAllRowsButton: Locator;
+    readonly unstructured_passTestCaseResultsRows: Locator;
+    readonly unstructured_publishButton: Locator;
+    readonly unstructured_publishToProjectOption: Locator;
+    readonly unstructured_versionFieldName: Locator;
+    readonly unstructured_versionFieldDescription: Locator;
+    readonly unstructured_publishButtonModal: Locator;
+    readonly unstructured_idpSuccessfulPublishNotification: Locator;
+    readonly selectUnstructuredDataExtraction: Locator;
+    readonly selectStructuredDataExtraction: Locator;
+    readonly extractionInProgressNotification: Locator;
+    readonly structured_FieldsTab: Locator;
+    readonly structured_TablesTab: Locator;
+    readonly structured_CheckboxSelectAllFields: Locator;
+    readonly structured_CheckboxSelectAllTables: Locator;
+    readonly structured_uploadFilesButton: Locator;
+    readonly structured_SelectedFieldsTablesMessage: Locator;
+    readonly structured_TestTemplateTab: Locator;
+    readonly structured_TestExtractionTemplateButton: Locator;
+    readonly structured_ExtractDocumentsLoader: Locator;
+    readonly structured_TestSummaryResult: Locator;
+    readonly structured_DetailsResult: Locator;
+    readonly structured_PublishTemplateButton: Locator;
+    readonly structured_PublishTemplateToProjectButton: Locator;
+    readonly structured_SuccessfulPublishNotification: Locator;
+    constructor(page: Page);
+    clickCreateIdpTemplateButton(): Promise<void>;
+    fillIdpExtractionTemplateName(name: string): Promise<void>;
+    clickCreateIdpExtractionTemplateButton(): Promise<void>;
+    clickUnstructuredUploadFilesButton(): Promise<void>;
+    clickExtractButton(): Promise<void>;
+    fillExtractFieldName(name: string): Promise<void>;
+    fillPromptField(): Promise<void>;
+    clickAddExtractionFieldButton(): Promise<void>;
+    selectExtractionModelOption(option: string): Promise<void>;
+    clickExtractDocumentButton(): Promise<void>;
+    clickSaveAsTestCaseButton(): Promise<void>;
+    clickValidateExtractionTab(): Promise<void>;
+    clickExpandAllRowsButton(): Promise<void>;
+    assertPassTestCaseResultsRow(retries?: number): Promise<void>;
+    clickPublishButton(): Promise<void>;
+    clickPublishToProjectOption(): Promise<void>;
+    fillVersionFieldName(name: string): Promise<void>;
+    fillVersionFieldDescription(description: string): Promise<void>;
+    clickPublishButtonModal(): Promise<void>;
+    assertIdpSuccessPublishNotification(): Promise<void>;
+    clickCloseToastNotification(): Promise<void>;
+    selectStructuredDataExtractionMethod(): Promise<void>;
+    clickStructuredUploadFilesButton(): Promise<void>;
+    assertMultipleFilesUploaded(): Promise<void>;
+    selectAllExtractionFields(): Promise<void>;
+    clickTablesTab(): Promise<void>;
+    selectAllExtractedTables(): Promise<void>;
+    assertFieldsAndTablesSelection(): Promise<void>;
+    clickTestTemplateTab(): Promise<void>;
+    clickTestExtractionTemplateButton(): Promise<void>;
+    extractionResultsAreVisible(): Promise<void>;
+    clickPublishTemplateButton(): Promise<void>;
+    clickPublishTemplateToProjectButton(): Promise<void>;
+    assertStructuredTemplateSuccessNotification(): Promise<void>;
+    fillIdpDescriptionField(description: string): Promise<void>;
+    selectProvider(provider: string): Promise<void>;
+}
+export { IdpCreatePage };

package/dist/pages/SM-8.8/IdpCreatePage.js

@@ -0,0 +1,352 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdpCreatePage = void 0;
+const test_1 = require("@playwright/test");
+const sleep_1 = require("../../utils/sleep");
+class IdpCreatePage {
+    page;
+    createIdpTemplateButton;
+    idpExtractionTemplateName;
+    idpDescriptionField;
+    providerDropdown;
+    createIdpExtractionTemplateButton;
+    unstructured_UploadFilesButton;
+    extractButton;
+    closeNotificationButton;
+    unstructured_extractFieldName;
+    unstructured_extractFieldPrompt;
+    unstructured_addExtractionFieldButton;
+    unstructured_extractionModelDropdown;
+    unstructured_extractDocumentButton;
+    unstructured_saveAsTestCaseButton;
+    unstructured_testCaseSavedNotification;
+    unstructured_validateExtractionTab;
+    unstructured_expandAllRowsButton;
+    unstructured_passTestCaseResultsRows;
+    unstructured_publishButton;
+    unstructured_publishToProjectOption;
+    unstructured_versionFieldName;
+    unstructured_versionFieldDescription;
+    unstructured_publishButtonModal;
+    unstructured_idpSuccessfulPublishNotification;
+    selectUnstructuredDataExtraction;
+    selectStructuredDataExtraction;
+    extractionInProgressNotification;
+    structured_FieldsTab;
+    structured_TablesTab;
+    structured_CheckboxSelectAllFields;
+    structured_CheckboxSelectAllTables;
+    structured_uploadFilesButton;
+    structured_SelectedFieldsTablesMessage;
+    structured_TestTemplateTab;
+    structured_TestExtractionTemplateButton;
+    structured_ExtractDocumentsLoader;
+    structured_TestSummaryResult;
+    structured_DetailsResult;
+    structured_PublishTemplateButton;
+    structured_PublishTemplateToProjectButton;
+    structured_SuccessfulPublishNotification;
+    constructor(page) {
+        this.page = page;
+        this.createIdpTemplateButton = page.getByRole('button', {
+            name: 'Create extraction template',
+            exact: true,
+        });
+        this.idpExtractionTemplateName = page.getByLabel('Name');
+        this.idpDescriptionField = page.getByLabel('Description');
+        this.createIdpExtractionTemplateButton = page.getByRole('button', {
+            name: 'Create template',
+            exact: true,
+        });
+        this.unstructured_UploadFilesButton = page
+            .getByRole('button', {
+            name: 'Upload documents',
+        })
+            .first();
+        this.extractButton = page.getByRole('button', {
+            name: 'Extract',
+            exact: true,
+        });
+        this.unstructured_extractFieldName = page.locator('#new-extraction-field-name');
+        this.unstructured_extractFieldPrompt = page.locator('#new-extraction-field-prompt');
+        this.unstructured_addExtractionFieldButton = page.getByRole('button', {
+            name: 'Add',
+            exact: true,
+        });
+        this.unstructured_extractionModelDropdown =
+            page.locator('#extraction-model');
+        this.unstructured_extractDocumentButton = page.getByRole('button', {
+            name: 'Extract document',
+        });
+        this.unstructured_saveAsTestCaseButton = page.getByRole('button', {
+            name: 'Save as test case',
+        });
+        this.unstructured_validateExtractionTab = page.getByRole('tab', {
+            name: 'Validate extraction',
+        });
+        this.unstructured_testCaseSavedNotification = page.getByText('NotificationTest case');
+        this.unstructured_expandAllRowsButton = page.getByLabel('Expand all rows');
+        this.unstructured_passTestCaseResultsRows = page.locator('[data-test="pass-test-case-results"]');
+        this.unstructured_publishButton = page.getByRole('button', {
+            name: 'Publish',
+        });
+        this.unstructured_publishToProjectOption = page.getByRole('menuitem', {
+            name: 'Publish to project',
+        });
+        this.unstructured_versionFieldName = page.locator('#version-name');
+        this.unstructured_versionFieldDescription = page.locator('#version-description');
+        this.unstructured_publishButtonModal = page
+            .getByLabel('Publish Extraction Project')
+            .getByRole('button', { name: 'Publish' });
+        this.unstructured_idpSuccessfulPublishNotification = page.getByText('NotificationSuccessIDP');
+        this.selectUnstructuredDataExtraction = page.getByText('Unstructured data extraction');
+        this.selectStructuredDataExtraction = page.getByText('Structured form extraction');
+        this.extractionInProgressNotification = page.getByText('Extracting document...');
+        this.structured_uploadFilesButton = page
+            .getByRole('button', {
+            name: /Drag and drop.*PDF.*upload/i,
+        })
+            .first();
+        this.structured_FieldsTab = page.getByRole('tab', {
+            name: 'Fields',
+        });
+        this.structured_TablesTab = page.getByRole('tab', {
+            name: 'Tables',
+        });
+        this.structured_TestTemplateTab = page.getByRole('tab', {
+            name: 'Test template',
+        });
+        this.structured_CheckboxSelectAllFields = page.getByRole('columnheader', {
+            name: 'Activate all rows',
+        });
+        this.structured_CheckboxSelectAllTables =
+            page.getByText('Select all tables');
+        this.structured_SelectedFieldsTablesMessage = page.getByText(/^\s*\d+\s+fields\s*&\s*\d+\s+table(?:s)?\s+selected$/);
+        this.structured_TestExtractionTemplateButton = page.getByRole('button', {
+            name: 'Test extraction template',
+        });
+        this.structured_TestSummaryResult = page.getByRole('heading', {
+            name: 'Test Summary Results',
+        });
+        this.structured_DetailsResult = page.getByRole('heading', {
+            name: 'Detailed Results',
+        });
+        this.structured_PublishTemplateButton = page.getByRole('button', {
+            name: 'Publish Template',
+        });
+        this.structured_PublishTemplateToProjectButton = page.getByRole('button', {
+            name: 'Publish',
+            exact: true,
+        });
+        this.structured_SuccessfulPublishNotification =
+            page.getByText('Template published');
+        this.providerDropdown = page.getByRole('combobox', { name: 'Provider' });
+        this.structured_ExtractDocumentsLoader = page.getByText('Extracting documents...');
+        this.closeNotificationButton = page
+            .getByLabel('Close notification')
+            .first();
+    }
+    async clickCreateIdpTemplateButton() {
+        await this.createIdpTemplateButton.click({ timeout: 60000 });
+    }
+    async fillIdpExtractionTemplateName(name) {
+        await this.idpExtractionTemplateName.fill(name);
+    }
+    async clickCreateIdpExtractionTemplateButton() {
+        await this.createIdpExtractionTemplateButton.click({
+            timeout: 60000,
+        });
+    }
+    async clickUnstructuredUploadFilesButton() {
+        await this.unstructured_UploadFilesButton.click({ timeout: 60000 });
+        await (0, sleep_1.sleep)(6000);
+    }
+    async clickExtractButton() {
+        await (0, test_1.expect)(this.extractButton).toBeEnabled({
+            timeout: 80000,
+        });
+        await this.extractButton.click({ timeout: 60000 });
+        await (0, sleep_1.sleep)(6000);
+    }
+    async fillExtractFieldName(name) {
+        await this.unstructured_extractFieldName.fill(name);
+    }
+    async fillPromptField() {
+        await this.unstructured_extractFieldPrompt.fill('Provide me the account number from this document');
+    }
+    async clickAddExtractionFieldButton() {
+        await this.unstructured_addExtractionFieldButton.click({ timeout: 60000 });
+    }
+    async selectExtractionModelOption(option) {
+        const comboboxOption = this.page.getByRole('option', { name: option });
+        if (await comboboxOption.isVisible()) {
+            console.log(`Option ${option} is already visible, no need to click dropdown`);
+        }
+        else {
+            await this.unstructured_extractionModelDropdown.click({
+                timeout: 60000,
+            });
+            await comboboxOption.click({ timeout: 120000 });
+        }
+    }
+    async clickExtractDocumentButton() {
+        await (0, test_1.expect)(this.unstructured_extractDocumentButton).toBeVisible({
+            timeout: 90000,
+        });
+        await this.unstructured_extractDocumentButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.unstructured_saveAsTestCaseButton).toBeEnabled({
+            timeout: 180000,
+        });
+        await (0, test_1.expect)(this.unstructured_saveAsTestCaseButton).toBeEnabled({
+            timeout: 120000,
+        });
+    }
+    async clickSaveAsTestCaseButton() {
+        await this.unstructured_saveAsTestCaseButton.click({ timeout: 60000 });
+        await (0, test_1.expect)(this.unstructured_testCaseSavedNotification).toBeVisible({
+            timeout: 120000,
+        });
+        await this.closeNotificationButton.click({ timeout: 60000 });
+    }
+    async clickValidateExtractionTab() {
+        await this.unstructured_validateExtractionTab.click({ timeout: 60000 });
+    }
+    async clickExpandAllRowsButton() {
+        await (0, test_1.expect)(this.unstructured_expandAllRowsButton).toBeVisible({
+            timeout: 120000,
+        });
+        await this.unstructured_expandAllRowsButton.click({ timeout: 60000 });
+        await (0, sleep_1.sleep)(1000);
+    }
+    async assertPassTestCaseResultsRow(retries = 3) {
+        for (let i = 0; i < retries; i++) {
+            try {
+                await (0, test_1.expect)(this.unstructured_passTestCaseResultsRows).toBeVisible({
+                    timeout: 60000,
+                });
+                return; // Click succeeded, exit the loop
+            }
+            catch (error) {
+                console.error(`Attempt ${i + 1} to assert pass test case failed: ${error}`);
+                await this.page.reload();
+                await this.clickValidateExtractionTab();
+                await this.clickExpandAllRowsButton();
+            }
+        }
+        throw new Error(`Failed to assert pass test case after ${retries} retries`);
+    }
+    async clickPublishButton() {
+        await this.unstructured_publishButton.click({ timeout: 60000 });
+    }
+    async clickPublishToProjectOption() {
+        await this.unstructured_publishToProjectOption.click({ timeout: 60000 });
+    }
+    async fillVersionFieldName(name) {
+        await this.unstructured_versionFieldName.fill(name);
+    }
+    async fillVersionFieldDescription(description) {
+        await this.unstructured_versionFieldDescription.fill(description);
+    }
+    async clickPublishButtonModal() {
+        await this.unstructured_publishButtonModal.click({ timeout: 60000 });
+    }
+    async assertIdpSuccessPublishNotification() {
+        await (0, test_1.expect)(this.unstructured_idpSuccessfulPublishNotification).toBeVisible({
+            timeout: 120000,
+        });
+    }
+    async clickCloseToastNotification() {
+        await this.closeNotificationButton.click({
+            timeout: 60000,
+        });
+    }
+    async selectStructuredDataExtractionMethod() {
+        await this.selectStructuredDataExtraction.click();
+    }
+    async clickStructuredUploadFilesButton() {
+        await (0, test_1.expect)(this.structured_uploadFilesButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_uploadFilesButton.click({ timeout: 60000 });
+        await (0, sleep_1.sleep)(6000);
+    }
+    async assertMultipleFilesUploaded() {
+        await (0, test_1.expect)(this.structured_ExtractDocumentsLoader).not.toBeVisible({
+            timeout: 180000,
+        });
+    }
+    async selectAllExtractionFields() {
+        await (0, test_1.expect)(this.structured_CheckboxSelectAllFields).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_CheckboxSelectAllFields.click({ timeout: 60000 });
+    }
+    async clickTablesTab() {
+        await (0, test_1.expect)(this.structured_TablesTab).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_TablesTab.click({ timeout: 60000 });
+    }
+    async selectAllExtractedTables() {
+        await (0, test_1.expect)(this.structured_CheckboxSelectAllTables).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_CheckboxSelectAllTables.click({ timeout: 60000 });
+    }
+    async assertFieldsAndTablesSelection() {
+        await (0, test_1.expect)(this.structured_SelectedFieldsTablesMessage).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickTestTemplateTab() {
+        await (0, test_1.expect)(this.structured_TestTemplateTab).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_TestTemplateTab.click({ timeout: 60000 });
+    }
+    async clickTestExtractionTemplateButton() {
+        await (0, test_1.expect)(this.structured_TestExtractionTemplateButton).toBeEnabled({
+            timeout: 120000,
+        });
+        await this.structured_TestExtractionTemplateButton.click({ timeout: 120000 });
+    }
+    async extractionResultsAreVisible() {
+        await (0, test_1.expect)(this.structured_TestSummaryResult).toBeVisible({
+            timeout: 60000,
+        });
+        await (0, test_1.expect)(this.structured_DetailsResult).toBeVisible({
+            timeout: 60000,
+        });
+    }
+    async clickPublishTemplateButton() {
+        await (0, test_1.expect)(this.structured_PublishTemplateButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_PublishTemplateButton.click({ timeout: 60000 });
+    }
+    async clickPublishTemplateToProjectButton() {
+        await (0, test_1.expect)(this.structured_PublishTemplateToProjectButton).toBeVisible({
+            timeout: 60000,
+        });
+        await this.structured_PublishTemplateToProjectButton.click({
+            timeout: 60000,
+        });
+    }
+    async assertStructuredTemplateSuccessNotification() {
+        await (0, test_1.expect)(this.structured_SuccessfulPublishNotification).toBeVisible({
+            timeout: 120000,
+        });
+    }
+    async fillIdpDescriptionField(description) {
+        await this.idpDescriptionField.fill(description);
+    }
+    async selectProvider(provider) {
+        await this.providerDropdown.click({ timeout: 60000 });
+        const providerOption = this.page
+            .getByRole('option', { name: provider })
+            .getByText(provider);
+        await (0, test_1.expect)(providerOption).toBeVisible({ timeout: 120000 });
+        await providerOption.click({ timeout: 120000 });
+    }
+}
+exports.IdpCreatePage = IdpCreatePage;

package/dist/pages/SM-8.8/ModelerHomePage.d.ts

@@ -23,6 +23,10 @@ declare class ModelerHomePage {
     readonly uploadFilesButton: Locator;
     readonly messageBanner: Locator;
     readonly closeButton: Locator;
+    readonly idpTemplateOption: Locator;
+    readonly idpApplicationNameInput: Locator;
+    readonly dialog: Locator;
+    readonly createIdpApplicationButton: Locator;
     constructor(page: Page);
     clickCreateNewProjectButton(): Promise<void>;
     enterNewProjectName(name: string): Promise<void>;
@@ -40,5 +44,9 @@ declare class ModelerHomePage {
     clickManageButton(): Promise<void>;
     clickUploadFilesButton(): Promise<void>;
     clickMessageBanner(): Promise<void>;
+    clickIdpApplicationTemplateOption(): Promise<void>;
+    enterIdpApplicationName(name: string): Promise<void>;
+    selectCluster(clusterName: string): Promise<void>;
+    clickCreateIdpApplicationButton(): Promise<void>;
 }
 export { ModelerHomePage };

package/dist/pages/SM-8.8/ModelerHomePage.js

@@ -27,6 +27,10 @@ class ModelerHomePage {
     uploadFilesButton;
     messageBanner;
     closeButton;
+    idpTemplateOption;
+    idpApplicationNameInput;
+    dialog;
+    createIdpApplicationButton;
     constructor(page) {
         this.page = page;
         this.modelerPageBanner = page
@@ -66,6 +70,15 @@ class ModelerHomePage {
         this.uploadFilesButton = page.getByRole('menuitem', { name: 'Upload files' });
         this.messageBanner = page.locator('[data-test="close-top-banner"]');
         this.closeButton = page.getByRole('button', { name: 'Got it - Dismiss' });
+        this.idpTemplateOption = page
+            .locator('[data-test="create-idp-application"]')
+            .getByText('IDP Application');
+        this.idpApplicationNameInput = page.getByPlaceholder('New IDP Application');
+        this.dialog = page.getByRole('dialog');
+        this.createIdpApplicationButton = page.getByRole('button', {
+            name: 'Create',
+            exact: true,
+        });
     }
     async clickCreateNewProjectButton() {
         await this.createNewProjectButton.click({ timeout: 60000 });
@@ -167,5 +180,30 @@ class ModelerHomePage {
             console.log('No banner or close button found to click');
         }
     }
+    async clickIdpApplicationTemplateOption() {
+        await this.idpTemplateOption.click({ timeout: 120000 });
+    }
+    async enterIdpApplicationName(name) {
+        await this.idpApplicationNameInput.click({ timeout: 60000 });
+        await this.idpApplicationNameInput.fill(name);
+    }
+    async selectCluster(clusterName) {
+        //Select the correct cluster if multiple exist
+        const baseClusterName = clusterName.split('(')[0].trim();
+        const cluster = this.dialog.getByText(baseClusterName, { exact: false });
+        await (0, test_1.expect)(cluster).toBeVisible({
+            timeout: 30000,
+        });
+        await cluster.click();
+        await (0, test_1.expect)(this.dialog
+            .locator('label')
+            .filter({
+            hasText: clusterName,
+        })
+            .getByRole('switch')).toBeChecked({ timeout: 30000 });
+    }
+    async clickCreateIdpApplicationButton() {
+        await this.createIdpApplicationButton.click();
+    }
 }
 exports.ModelerHomePage = ModelerHomePage;

package/dist/tests/SM-8.8/idp-user-flows.spec.d.ts

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

package/dist/tests/SM-8.8/idp-user-flows.spec.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SM_8_8_1 = require("../../fixtures/SM-8.8");
+const _setup_1 = require("../../test-setup.js");
+const randomName_1 = require("../../utils/randomName");
+const fileUpload_1 = require("../../utils/fileUpload");
+let idpApplicationName;
+let idpDocumentExtractionTemplateName;
+const unstructuredTestCases = [
+    {
+        provider: 'AWS',
+        model: 'Claude 3.5 Sonnet',
+        uploadFiles: ['idp/idp_sample_bank_statement.pdf'],
+    },
+];
+const structuredTestCases = [
+    {
+        provider: 'AWS',
+        model: '',
+        uploadFiles: ['idp/structured_invoice_test.pdf'],
+        extractionFiles: ['idp/structured_invoice_1.pdf'],
+    },
+]; /* For structured documents, the model is empty since it is not necessary */
+if (process.env.IS_DS === 'true') {
+    SM_8_8_1.test.describe('IDP User Flow Tests', () => {
+        SM_8_8_1.test.afterEach(async ({ page }, testInfo) => {
+            await (0, _setup_1.captureScreenshot)(page, testInfo);
+            await (0, _setup_1.captureFailureVideo)(page, testInfo);
+        });
+        SM_8_8_1.test.beforeEach(async ({ navigationPage }, testInfo) => {
+            await navigationPage.goToModeler((testInfo.workerIndex + 1) * 1000);
+        });
+        SM_8_8_1.test.describe('Unstructured Extraction', () => {
+            for (const params of unstructuredTestCases) {
+                (0, SM_8_8_1.test)(`${params.provider} unstructured (${params.model}) - User creates an idp application with a document extraction template`, async ({ page, idpCreatePage, modelerHomePage, }) => {
+                    SM_8_8_1.test.slow();
+                    idpApplicationName = await (0, randomName_1.randomNameAgregator)(`${params.provider} unstructured` + ' - IDP_Application_Name');
+                    idpDocumentExtractionTemplateName = await (0, randomName_1.randomNameAgregator)(`${params.provider} unstructured` +
+                        ' - IDP_Extraction_Template_Name');
+                    await SM_8_8_1.test.step('Navigate to Cross Component Test Project', async () => {
+                        await modelerHomePage.clickMessageBanner();
+                        await modelerHomePage.clickCrossComponentProjectFolder();
+                    });
+                    await SM_8_8_1.test.step('Add an IDP application to the project', async () => {
+                        await modelerHomePage.clickDiagramTypeDropdown();
+                        await modelerHomePage.clickIdpApplicationTemplateOption();
+                    });
+                    await SM_8_8_1.test.step('Creates a document extraction template', async () => {
+                        await modelerHomePage.enterIdpApplicationName(idpApplicationName);
+                        await modelerHomePage.clickCreateIdpApplicationButton();
+                        await idpCreatePage.clickCreateIdpTemplateButton();
+                        await idpCreatePage.fillIdpExtractionTemplateName(`${idpDocumentExtractionTemplateName}`);
+                        await idpCreatePage.fillIdpDescriptionField(`${idpDocumentExtractionTemplateName} description`);
+                        await idpCreatePage.selectProvider(params.provider);
+                        await idpCreatePage.clickCreateIdpExtractionTemplateButton();
+                    });
+                    await SM_8_8_1.test.step('Upload a file for extraction', async () => {
+                        await idpCreatePage.clickUnstructuredUploadFilesButton();
+                        await (0, fileUpload_1.uploadFile)(page, params.uploadFiles);
+                        await idpCreatePage.clickExtractButton();
+                    });
+                    await SM_8_8_1.test.step('Add a field for extraction and extract the data', async () => {
+                        await idpCreatePage.fillExtractFieldName('bank_account_number');
+                        await idpCreatePage.fillPromptField();
+                        await idpCreatePage.clickAddExtractionFieldButton();
+                        await idpCreatePage.selectExtractionModelOption(params.model);
+                        await idpCreatePage.clickExtractDocumentButton();
+                    });
+                    await SM_8_8_1.test.step('Save extracted data as a test case', async () => {
+                        await idpCreatePage.clickSaveAsTestCaseButton();
+                        await idpCreatePage.clickCloseToastNotification();
+                    });
+                    await SM_8_8_1.test.step('Validate extraction', async () => {
+                        await idpCreatePage.clickValidateExtractionTab();
+                        await idpCreatePage.clickExpandAllRowsButton();
+                        await idpCreatePage.assertPassTestCaseResultsRow();
+                    });
+                    await SM_8_8_1.test.step('Publish the IDP application to project', async () => {
+                        await idpCreatePage.clickPublishButton();
+                        await idpCreatePage.clickPublishToProjectOption();
+                        await idpCreatePage.fillVersionFieldName(idpApplicationName);
+                        await idpCreatePage.fillVersionFieldDescription(idpApplicationName);
+                        await idpCreatePage.clickPublishButtonModal();
+                        await idpCreatePage.assertIdpSuccessPublishNotification();
+                    });
+                });
+            }
+        });
+        SM_8_8_1.test.describe('Structured Extraction', () => {
+            for (const params of structuredTestCases) {
+                (0, SM_8_8_1.test)(`${params.provider} structured - User creates an idp application with a document extraction template`, async ({ page, idpCreatePage, modelerHomePage, }) => {
+                    SM_8_8_1.test.slow();
+                    idpApplicationName = await (0, randomName_1.randomNameAgregator)(`${params.provider} structured` + ' - IDP_Application_Name');
+                    idpDocumentExtractionTemplateName = await (0, randomName_1.randomNameAgregator)(`${params.provider} structured` + ' - IDP_Extraction_Template_Name');
+                    await SM_8_8_1.test.step('Navigate to Cross Component Test Project', async () => {
+                        await modelerHomePage.clickMessageBanner();
+                        await modelerHomePage.clickCrossComponentProjectFolder();
+                    });
+                    await SM_8_8_1.test.step('Add an IDP application to the project', async () => {
+                        await modelerHomePage.clickDiagramTypeDropdown();
+                        await modelerHomePage.clickIdpApplicationTemplateOption();
+                    });
+                    await SM_8_8_1.test.step('Creates a document extraction template', async () => {
+                        await modelerHomePage.enterIdpApplicationName(idpApplicationName);
+                        await modelerHomePage.clickCreateIdpApplicationButton();
+                        await idpCreatePage.clickCreateIdpTemplateButton();
+                        await idpCreatePage.selectStructuredDataExtractionMethod();
+                        await idpCreatePage.fillIdpExtractionTemplateName(`${idpDocumentExtractionTemplateName}`);
+                        await idpCreatePage.fillIdpDescriptionField(`${idpDocumentExtractionTemplateName} - description`);
+                        await idpCreatePage.selectProvider(params.provider);
+                        await idpCreatePage.clickCreateIdpExtractionTemplateButton();
+                    });
+                    await SM_8_8_1.test.step('Upload a file for extraction', async () => {
+                        await idpCreatePage.clickStructuredUploadFilesButton();
+                        await (0, fileUpload_1.uploadFile)(page, params.uploadFiles);
+                    });
+                    await SM_8_8_1.test.step('Select all the fields extracted rows', async () => {
+                        await idpCreatePage.selectAllExtractionFields();
+                    });
+                    await SM_8_8_1.test.step('Switch to the tables tab', async () => {
+                        await idpCreatePage.clickTablesTab();
+                    });
+                    await SM_8_8_1.test.step('Select all the extracted tables', async () => {
+                        await idpCreatePage.selectAllExtractedTables();
+                    });
+                    await SM_8_8_1.test.step('Confirm selection of fields and tables', async () => {
+                        await idpCreatePage.assertFieldsAndTablesSelection();
+                    });
+                    await SM_8_8_1.test.step('Click on the Test Template tab', async () => {
+                        await idpCreatePage.clickTestTemplateTab();
+                    });
+                    await SM_8_8_1.test.step('Upload multiple files for testing the extraction', async () => {
+                        await idpCreatePage.clickStructuredUploadFilesButton();
+                        await (0, fileUpload_1.uploadFile)(page, params.extractionFiles);
+                        await idpCreatePage.assertMultipleFilesUploaded();
+                        await idpCreatePage.clickTestExtractionTemplateButton();
+                    });
+                    await SM_8_8_1.test.step('Test Summary Results and Details Results sections are visible ', async () => {
+                        await idpCreatePage.extractionResultsAreVisible();
+                    });
+                    await SM_8_8_1.test.step('Publish the IDP application to project', async () => {
+                        await idpCreatePage.clickPublishTemplateButton();
+                        await idpCreatePage.clickPublishToProjectOption();
+                        await idpCreatePage.fillVersionFieldName(idpApplicationName);
+                        await idpCreatePage.fillVersionFieldDescription(idpApplicationName);
+                        await idpCreatePage.clickPublishTemplateToProjectButton();
+                        await idpCreatePage.assertStructuredTemplateSuccessNotification();
+                    });
+                });
+            }
+        });
+    });
+}

package/package.json

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