feat: add abstractions for flow builder create test

src/page-objects/AdministrationPages.ts

@@ -138,16 +138,16 @@ export const test = base.extend<FixtureTypes>({
         await use(new FirstRunWizard(AdminPage, InstanceMeta));
     },
 
-    AdminFlowBuilderCreate: async ({ AdminPage }, use) => {
-        await use(new FlowBuilderCreate(AdminPage));
+    AdminFlowBuilderCreate: async ({ AdminPage, InstanceMeta }, use) => {
+        await use(new FlowBuilderCreate(AdminPage, InstanceMeta));
     },
 
-    AdminFlowBuilderListing: async ({ AdminPage }, use) => {
-        await use(new FlowBuilderListing(AdminPage));
+    AdminFlowBuilderListing: async ({ AdminPage, InstanceMeta }, use) => {
+        await use(new FlowBuilderListing(AdminPage, InstanceMeta));
     },
 
-    AdminFlowBuilderDetail: async ({ AdminPage }, use) => {
-        await use(new FlowBuilderDetail(AdminPage));
+    AdminFlowBuilderDetail: async ({ AdminPage, InstanceMeta }, use) => {
+        await use(new FlowBuilderDetail(AdminPage, InstanceMeta));
     },
 
     AdminDataSharing: async ({ AdminPage }, use) => {

src/page-objects/administration/FlowBuilderCreate.ts

@@ -1,14 +1,64 @@
 import type { Page, Locator } from '@playwright/test';
 import type { PageObject } from '../../types/PageObject';
+import { satisfies } from 'compare-versions';
+import { HelperFixtureTypes } from '../../fixtures/HelperFixtures';
 
 export class FlowBuilderCreate implements PageObject {
 
+    /**
+     * Header
+     */
     public readonly saveButton: Locator;
     public readonly header: Locator;
+    public readonly smartBarHeader: Locator;
+    /**
+     * Tabs
+     */
+    public readonly generalTab: Locator;
+    public readonly flowTab: Locator;
+    /**
+     * General
+     */
+    public readonly nameField: Locator;
+    public readonly descriptionField: Locator;
+    public readonly priorityField: Locator;
+    public readonly activeSwitch: Locator;
+    /**
+     * Flow
+     */
+    public readonly triggerSelectField: Locator;
+    public readonly addActionField: Locator;
+    public readonly modalAddButton: Locator;
 
-    constructor(public readonly page: Page) {
+
+    constructor(public readonly page: Page, public readonly instanceMeta: HelperFixtureTypes['InstanceMeta']) {
         this.saveButton = page.locator('.sw-flow-detail__save');
         this.header = page.locator('h2');
+        this.smartBarHeader = page.locator('.smart-bar__header');
+
+        this.generalTab = page.locator('.sw-flow-detail__tab-general');
+        if (satisfies(instanceMeta.version, '<6.6.9999999')) {
+            this.flowTab = page.locator('.sw-tabs__content').locator('.sw-flow-detail__tab-flow');
+        } else {
+            this.flowTab = page.locator('.mt-tabs').locator('.mt-tabs__item').getByText('Flow');
+        }
+
+        this.nameField = page.locator('.sw-flow-detail-general__general-name').getByLabel('Name');
+        this.descriptionField = page.locator('.sw-flow-detail-general__general-description').getByLabel('Description');
+        this.priorityField = page.locator('.sw-flow-detail-general__general-priority').getByLabel('Priority');
+        this.activeSwitch = page.locator('.sw-flow-detail-general__general-active').getByLabel('Active');
+
+        if (satisfies(instanceMeta.version, '<6.6.9999999')) {
+            this.triggerSelectField = page.locator('.sw-flow-detail-flow__trigger-card').getByRole('textbox');
+        } else {
+            this.triggerSelectField = page.locator('.sw-flow-detail-flow__trigger-card').getByRole('textbox');
+        }
+        this.addActionField = page.locator('.sw-flow-sequence-action__content').locator('.sw-single-select__selection');
+        if (satisfies(instanceMeta.version, '<6.6.9999999')) {
+            this.modalAddButton = page.locator('.sw-button--primary').getByText('Add action');
+        } else {
+            this.modalAddButton = page.locator('.mt-button--primary').getByText('Add action');
+        }
     }
 
     url() {

src/page-objects/administration/FlowBuilderDetail.ts

@@ -1,19 +1,25 @@
 import type { Page, Locator } from '@playwright/test';
 import type { PageObject } from '../../types/PageObject';
+import { FlowBuilderCreate } from './FlowBuilderCreate';
+import { satisfies } from 'compare-versions';
+import { HelperFixtureTypes } from '../../fixtures/HelperFixtures';
 
-export class FlowBuilderDetail implements PageObject {
+export class FlowBuilderDetail extends FlowBuilderCreate implements PageObject {
+
+    public readonly successMessage: Locator;
+
+    constructor(public readonly page: Page, public readonly instanceMeta: HelperFixtureTypes['InstanceMeta']) {
+        super(page, instanceMeta);
+        if (satisfies(instanceMeta.version, '<6.6.9999999')) {
+            this.successMessage = page.locator('.sw-alert__title');
+        } else {
+            this.successMessage = page.locator('.mt-banner__title');
+        }
 
-    public readonly saveButton: Locator;
-    public readonly generalTab: Locator;
-    public readonly flowTab: Locator;
 
-    constructor(public readonly page: Page) {
-        this.saveButton = page.locator('.sw-flow-detail__save');
-        this.generalTab = page.locator('.sw-flow-detail__tab-general');
-        this.flowTab = page.locator('.sw-flow-detail__tab-flow');
     }
 
-    url(flowId: string, tabName = 'general') {
+    url(flowId?: string, tabName = 'general') {
         return `#/sw/flow/detail/${flowId}/${tabName}`
     }
 }

src/page-objects/administration/FlowBuilderListing.ts

@@ -1,5 +1,7 @@
 import type { Page, Locator } from '@playwright/test';
 import type { PageObject } from '../../types/PageObject';
+import { satisfies } from 'compare-versions';
+import { HelperFixtureTypes } from '../../fixtures/HelperFixtures';
 
 export class FlowBuilderListing implements PageObject {
 
@@ -17,7 +19,7 @@ export class FlowBuilderListing implements PageObject {
     public readonly successAlert: Locator;
     public readonly successAlertMessage: Locator;
 
-    constructor(public readonly page: Page) {
+    constructor(public readonly page: Page, public readonly instanceMeta: HelperFixtureTypes['InstanceMeta']) {
         this.createFlowButton = page.locator('.sw-flow-list__create');
         this.firstFlowName = page.locator('.sw-data-grid__cell--name a').first();
         this.firstFlowContextButton = page.locator('.sw-data-grid__actions-menu').first();
@@ -42,7 +44,13 @@ export class FlowBuilderListing implements PageObject {
     async getLineItemByFlowName(flowName: string): Promise<Record<string, Locator>> {
         const lineItem = this.page.locator('.sw-data-grid__row').filter({ hasText: flowName });
         const flowSelectionCheckbox = lineItem.locator('.sw-data-grid__cell--selection').locator('.sw-field__checkbox');
-        const flowActiveCheckmark = lineItem.locator('.sw-data-grid__cell--active').locator('.icon--regular-checkmark-xs');
+        let flowActiveCheckmark
+        if (satisfies(this.instanceMeta.version, '<6.6.9999999')) {
+            flowActiveCheckmark = lineItem.locator('.sw-data-grid__cell--active').locator('.icon--regular-checkmark-xs');
+        } else {
+            flowActiveCheckmark = lineItem.locator('.sw-data-grid__cell--active').getByTestId('mt-icon__regular-checkmark-xs');
+        }
+        //const flowActiveCheckmark = lineItem.locator('.sw-data-grid__cell--active').locator('.icon--regular-checkmark-xs');
         const flowDisabledCheckmark = lineItem.locator('.sw-data-grid__cell--active').locator('.icon--regular-times-s');
         const flowNameText = lineItem.locator('.sw-data-grid__cell--name');
         const flowEventNameText = lineItem.locator('.sw-data-grid__cell--eventName');

src/tasks/shop-admin-tasks.ts

@@ -6,6 +6,8 @@ import { CreateLinkTypeCategory } from './shop-admin/Category/CreateLinkTypeCate
 import { BulkEditProducts } from './shop-admin/Product/BulkEditProducts';
 import { BulkEditCustomers } from './shop-admin/Customers/BulkEditCustomers';
 import { AssignEntitiesToRule } from './shop-admin/Rule/AssignEntitiesToRule';
+import { CreateFlow } from './shop-admin/Flow/CreateFlow';
+import { CheckFlow } from './shop-admin/Flow/CheckFlow';
 
 export const test = mergeTests(
     SaveProduct,
@@ -14,4 +16,6 @@ export const test = mergeTests(
     BulkEditProducts,
     BulkEditCustomers,
     AssignEntitiesToRule,
+    CreateFlow,
+    CheckFlow,
 );

src/tasks/shop-admin/Flow/CheckFlow.ts

@@ -0,0 +1,39 @@
+import { test as base } from '@playwright/test';
+import type { Task } from '../../../types/Task';
+import type { FixtureTypes } from '../../../types/FixtureTypes';
+import { FlowConfig } from '../../../types/ShopwareTypes';
+
+export const CheckFlow = base.extend<{ CheckFlow: Task }, FixtureTypes>({
+    CheckFlow: async ({ AdminFlowBuilderDetail, AdminFlowBuilderListing, ShopAdmin }, use ) => {
+        const task = (flowConfig: FlowConfig) => {
+            return async function checkFlow() {
+                const flowListingRow = await AdminFlowBuilderListing.getLineItemByFlowName(`${flowConfig.name}`);
+                await ShopAdmin.expects(flowListingRow.flowActiveCheckmark).toBeVisible();
+                await flowListingRow.flowContextMenuButton.click();
+                await AdminFlowBuilderListing.contextMenuEdit.click();
+                // Confirm that general tab has the correct values
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-detail-general__general-name').getByLabel('Name')).toHaveValue(`${flowConfig.name}`);
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-detail-general__general-description').getByLabel('Description')).toHaveValue(`${flowConfig.description}`);
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-detail-general__general-priority').getByLabel('Priority')).toHaveValue(`${flowConfig.priority}`);
+                // Confirm the flow's structure
+                await AdminFlowBuilderDetail.flowTab.click();
+                // Check trigger by assessing the tooltip that appears on hover
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-detail-flow__trigger-card').getByRole('textbox')).toBeVisible();
+                await AdminFlowBuilderDetail.page.locator('.sw-flow-detail-flow__trigger-card').getByRole('textbox').hover();
+                const tooltip = await AdminFlowBuilderDetail.page.waitForSelector('.sw-tooltip');
+                const tooltipText = await tooltip.innerText();
+                ShopAdmin.expects(tooltipText).toEqual(`${flowConfig.triggerLabel}`);
+                // Make sure there is only one condition
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-sequence-condition__rule-header')).toHaveText(`${flowConfig.condition}`);
+                // Make sure there are no delays
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-delay-action__delay_card')).not.toBeVisible();
+                // Make sure there is only one section
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-detail-flow__position-connection')).toBeVisible();
+                // Make sure there are only desired actions present after the condition
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-sequence__true-block').locator('.sw-flow-sequence-action__action-description')).toContainText(`${flowConfig.trueActionIdentifier}`);
+                await ShopAdmin.expects(AdminFlowBuilderDetail.page.locator('.sw-flow-sequence__false-block').locator('.sw-flow-sequence-action__action-description')).toContainText(`${flowConfig.falseActionIdentifier}`);
+            }
+        };
+        await use(task);
+    },
+});

src/tasks/shop-admin/Flow/CreateFlow.ts

@@ -0,0 +1,59 @@
+import { test as base } from '@playwright/test';
+import type { Task } from '../../../types/Task';
+import type { FixtureTypes } from '../../../types/FixtureTypes';
+import { FlowConfig } from '../../../types/ShopwareTypes';
+
+export const CreateFlow = base.extend<{ CreateFlow: Task }, FixtureTypes>({
+    CreateFlow: async ({ AdminFlowBuilderCreate, AdminFlowBuilderDetail, AdminFlowBuilderListing, ShopAdmin }, use ) => {
+        const task = (flowConfig: FlowConfig) => {
+            return async function createFlow() {
+                await AdminFlowBuilderListing.createFlowButton.click();
+                // Fill out fields on general tab
+                await ShopAdmin.expects(AdminFlowBuilderCreate.smartBarHeader).toHaveText('New flow');
+                await AdminFlowBuilderCreate.nameField.fill(`${flowConfig.name}`);
+                await AdminFlowBuilderCreate.descriptionField.fill(`${flowConfig.description}`);
+                await AdminFlowBuilderCreate.priorityField.fill(`${flowConfig.priority}`);
+                if (flowConfig.active){
+                    await AdminFlowBuilderCreate.activeSwitch.click();
+                }
+                // Switch to flow tab
+                await AdminFlowBuilderCreate.flowTab.click();
+                // Select trigger
+                await AdminFlowBuilderCreate.triggerSelectField.fill(flowConfig.triggerSearchTerm);
+                await AdminFlowBuilderCreate.triggerSelectField.press('Enter');
+                // Add condition
+                await AdminFlowBuilderCreate.page.locator('.sw-flow-sequence').getByText('Add condition (IF)').click();
+                await AdminFlowBuilderCreate.page.locator('.sw-entity-single-select').getByRole('textbox').click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-select-result-list__item-list')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-select-result-list__content').getByRole('listitem').filter({ hasText: `${flowConfig.condition}` }).click();
+                // Add action to condition true block
+                await AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__true-block').getByText('Add action (THEN)').click();
+                await AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__true-block').locator('.sw-single-select').click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-select-result-list__item-list')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-select-result-list__content').getByRole('listitem').filter({ hasText: `${flowConfig.trueAction}` }).click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-flow-mail-send-modal')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-entity-single-select__selection').click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-select-result-list__item-list')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-select-result-list__content').getByRole('listitem').filter({ hasText: `${flowConfig.trueActionIdentifier}` }).click();
+                await AdminFlowBuilderCreate.modalAddButton.click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__true-block').locator('.sw-flow-sequence-action__action-description')).toContainText(`${flowConfig.trueActionIdentifier}`);
+                // Add action to condition false block
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__false-block')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__false-block').getByText('Add action (THEN)').click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__false-block').locator('.sw-flow-sequence-action__select')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__false-block').locator('.sw-single-select').click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-select-result-list__item-list')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-select-result-list__content').getByRole('listitem').filter({ hasText: `${flowConfig.falseAction}` }).click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-modal__title')).toHaveText('Add tag');
+                await AdminFlowBuilderCreate.page.locator('.sw-select__selection').getByLabel('Tags').click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-select-result-list__item-list')).toBeVisible();
+                await AdminFlowBuilderCreate.page.locator('.sw-select-result-list__content').getByRole('listitem').filter({ hasText: `${flowConfig.falseActionIdentifier}` }).click();
+                await AdminFlowBuilderCreate.modalAddButton.click();
+                await ShopAdmin.expects(AdminFlowBuilderCreate.page.locator('.sw-flow-sequence__false-block').locator('.sw-flow-sequence-action__actions')).toContainText(`Tag: ${flowConfig.falseActionIdentifier}`);
+                await AdminFlowBuilderCreate.saveButton.click();
+                await ShopAdmin.expects(AdminFlowBuilderDetail.successMessage).toHaveText('Success');
+            }
+        };
+        await use(task);
+    },
+});

src/types/ShopwareTypes.ts

@@ -257,6 +257,20 @@ export interface RuleAssignmentEntity {
     ruleType: RuleType
 }
 
+export interface FlowConfig {
+    name: string;
+    description: string;
+    priority: string;
+    active: boolean;
+    triggerSearchTerm: string
+    triggerLabel: string;
+    condition: string;
+    trueAction: string;
+    trueActionIdentifier: string;
+    falseAction: string;
+    falseActionIdentifier: string;
+}
+
 export interface CategoryData {
     name: string;
     categoryType: 'Link' | 'Page / List' | 'Structuring element / Entry point';