@sap-ux/ui5-test-writer 0.7.102 → 0.7.104

package/dist/fiori-elements-opa-writer.d.ts

@@ -1,14 +1,6 @@
 import type { Editor } from 'mem-fs-editor';
 import type { Manifest } from '@sap-ux/project-access';
 import type { Logger } from '@sap-ux/logger';
-/**
- * Reads the manifest for an app.
- *
- * @param fs - a reference to a mem-fs editor
- * @param basePath - the root folder of the app
- * @returns the manifest object. An exception is thrown if the manifest cannot be read.
- */
-export declare function readManifest(fs: Editor, basePath: string): Manifest;
 /**
  * Generate OPA test files for a Fiori elements for OData V4 application.
  * Note: this can potentially overwrite existing files in the webapp/test folder.
@@ -21,13 +13,22 @@ export declare function readManifest(fs: Editor, basePath: string): Manifest;
  * @param metadata - optional metadata for the OPA test generation
  * @param fs - an optional reference to a mem-fs editor
  * @param log - optional logger instance
+ * @param standalone - opa test generation run standalone, not during app generation
  * @returns Reference to a mem-fs-editor
  */
 export declare function generateOPAFiles(basePath: string, opaConfig: {
     scriptName?: string;
     appID?: string;
     htmlTarget?: string;
-}, metadata?: string, fs?: Editor, log?: Logger): Promise<Editor>;
+}, metadata?: string, fs?: Editor, log?: Logger, standalone?: boolean): Promise<Editor>;
+/**
+ * Reads the manifest for an app.
+ *
+ * @param fs - a reference to a mem-fs editor
+ * @param basePath - the root folder of the app
+ * @returns the manifest object. An exception is thrown if the manifest cannot be read.
+ */
+export declare function readManifest(fs: Editor, basePath: string): Manifest;
 /**
  * Generate a page object file for a Fiori elements for OData V4 application.
  * Note: this doesn't modify other existing files in the webapp/test folder.
@@ -42,5 +43,5 @@ export declare function generateOPAFiles(basePath: string, opaConfig: {
 export declare function generatePageObjectFile(basePath: string, pageObjectParameters: {
     targetKey: string;
     appID?: string;
-}, fs?: Editor): Editor;
+}, fs?: Editor): Promise<Editor>;
 //# sourceMappingURL=fiori-elements-opa-writer.d.ts.map

package/dist/fiori-elements-opa-writer.js

@@ -1,15 +1,76 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readManifest = readManifest;
 exports.generateOPAFiles = generateOPAFiles;
+exports.readManifest = readManifest;
 exports.generatePageObjectFile = generatePageObjectFile;
 const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 const mem_fs_1 = require("mem-fs");
 const mem_fs_editor_1 = require("mem-fs-editor");
 const types_1 = require("./types");
 const i18n_1 = require("./i18n");
 const project_access_1 = require("@sap-ux/project-access");
 const modelUtils_1 = require("./utils/modelUtils");
+const opaQUnitUtils_1 = require("./utils/opaQUnitUtils");
+/**
+ * Generate OPA test files for a Fiori elements for OData V4 application.
+ * Note: this can potentially overwrite existing files in the webapp/test folder.
+ *
+ * @param basePath - the absolute target path where the application will be generated
+ * @param opaConfig - parameters for the generation
+ * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
+ * @param opaConfig.htmlTarget - the name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used
+ * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
+ * @param metadata - optional metadata for the OPA test generation
+ * @param fs - an optional reference to a mem-fs editor
+ * @param log - optional logger instance
+ * @param standalone - opa test generation run standalone, not during app generation
+ * @returns Reference to a mem-fs-editor
+ */
+async function generateOPAFiles(basePath, opaConfig, metadata, fs, log, standalone = false) {
+    const editor = fs ?? (0, mem_fs_editor_1.create)((0, mem_fs_1.create)());
+    const manifest = readManifest(editor, basePath);
+    const { applicationType, hideFilterBar } = getAppTypeAndHideFilterBarFromManifest(manifest);
+    const config = createConfig(manifest, opaConfig, hideFilterBar);
+    const rootCommonTemplateDirPath = (0, node_path_1.join)(__dirname, '../templates/common');
+    const rootV4TemplateDirPath = (0, node_path_1.join)(__dirname, `../templates/${applicationType}`); // Only v4 is supported for the time being
+    const testOutDirPath = (0, node_path_1.join)(await (0, project_access_1.getWebappPath)(basePath), 'test');
+    // Access ux-specification to get feature data for OPA test generation
+    const appFeatures = await (0, modelUtils_1.getAppFeatures)(basePath, editor, log, metadata, manifest);
+    // OPA Journey file
+    const startPages = config.pages.filter((page) => page.isStartup).map((page) => page.targetKey);
+    const LROP = findLROP(config.pages, manifest);
+    const journeyParams = {
+        startPages,
+        startLR: LROP.pageLR?.targetKey,
+        navigatedOP: LROP.pageOP?.targetKey,
+        hideFilterBar: config.hideFilterBar
+    };
+    const writeContext = { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams };
+    if (standalone) {
+        const hasJourneyRunner = (0, node_fs_1.existsSync)((0, node_path_1.join)(testOutDirPath, 'integration', 'pages', 'JourneyRunner.js'));
+        const virtualOPA5Configured = await (0, opaQUnitUtils_1.hasVirtualOPA5)(basePath);
+        if (hasJourneyRunner) {
+            writeJourneyFiles(appFeatures, writeContext, true, true, virtualOPA5Configured);
+        }
+        else {
+            editor.move((0, node_path_1.join)(testOutDirPath, 'integration', '**'), (0, node_path_1.join)(testOutDirPath, 'integration_old'));
+            await (0, opaQUnitUtils_1.addIntegrationOldToGitignore)(basePath, editor);
+            const htmlTarget = (0, opaQUnitUtils_1.readHtmlTargetFromQUnitJs)(testOutDirPath, editor) ?? config.htmlTarget;
+            const standaloneConfig = { ...config, htmlTarget };
+            const standaloneWriteContext = { ...writeContext, config: standaloneConfig };
+            if (!virtualOPA5Configured) {
+                writeCommonAndPageFiles(standaloneWriteContext, rootCommonTemplateDirPath);
+            }
+            writeJourneyFiles(appFeatures, standaloneWriteContext, true, hasJourneyRunner, virtualOPA5Configured);
+        }
+    }
+    else {
+        writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath);
+        writeJourneyFiles(appFeatures, writeContext, false);
+    }
+    return editor;
+}
 /**
  * Reads the manifest for an app.
  *
@@ -193,103 +254,138 @@ function findLROP(pages, manifest) {
     return { pageLR, pageOP };
 }
 /**
- * Writes a page object in a mem-fs-editor.
+ * Writes common test files, page objects, and the first journey file.
  *
- * @param pageConfig - the page configuration object
- * @param rootTemplateDirPath - template root directory
- * @param testOutDirPath - output test directory (.../webapp/test)
- * @param fs - a reference to a mem-fs editor
- */
-function writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, fs) {
-    fs.copyTpl((0, node_path_1.join)(rootTemplateDirPath, `integration/pages/${pageConfig.template}.js`), (0, node_path_1.join)(testOutDirPath, `integration/pages/${pageConfig.targetKey}.js`), pageConfig, undefined, {
-        globOptions: { dot: true }
-    });
-}
-/**
- * Generate OPA test files for a Fiori elements for OData V4 application.
- * Note: this can potentially overwrite existing files in the webapp/test folder.
- *
- * @param basePath - the absolute target path where the application will be generated
- * @param opaConfig - parameters for the generation
- * @param opaConfig.scriptName - the name of the OPA journey file. If not specified, 'FirstJourney' will be used
- * @param opaConfig.htmlTarget - the name of the html that will be used in OPA journey file. If not specified, 'index.html' will be used
- * @param opaConfig.appID - the appID. If not specified, will be read from the manifest in sap.app/id
- * @param metadata - optional metadata for the OPA test generation
- * @param fs - an optional reference to a mem-fs editor
- * @param log - optional logger instance
- * @returns Reference to a mem-fs-editor
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param rootCommonTemplateDirPath - template root directory for common files
  */
-async function generateOPAFiles(basePath, opaConfig, metadata, fs, log) {
-    const editor = fs ?? (0, mem_fs_editor_1.create)((0, mem_fs_1.create)());
-    const manifest = readManifest(editor, basePath);
-    const { applicationType, hideFilterBar } = getAppTypeAndHideFilterBarFromManifest(manifest);
-    const config = createConfig(manifest, opaConfig, hideFilterBar);
-    const rootCommonTemplateDirPath = (0, node_path_1.join)(__dirname, '../templates/common');
-    const rootV4TemplateDirPath = (0, node_path_1.join)(__dirname, `../templates/${applicationType}`); // Only v4 is supported for the time being
-    const testOutDirPath = (0, node_path_1.join)(basePath, 'webapp/test');
+function writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath) {
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams } = writeContext;
     // Common test files
     editor.copyTpl((0, node_path_1.join)(rootCommonTemplateDirPath), testOutDirPath, 
     // unit tests are not added for Fiori elements app
     { appId: config.appID }, undefined, {
         globOptions: { dot: true }
     });
-    // Pages files (one for each page in the app)
     config.pages.forEach((page) => {
         writePageObject(page, rootV4TemplateDirPath, testOutDirPath, editor);
     });
-    // OPA Journey file
-    const startPages = config.pages.filter((page) => page.isStartup).map((page) => page.targetKey);
-    const LROP = findLROP(config.pages, manifest);
-    // Access ux-specification to get feature data for OPA test generation
-    const { listReport, objectPages, fpm } = await (0, modelUtils_1.getAppFeatures)(basePath, editor, log, metadata);
-    const journeyParams = {
-        startPages,
-        startLR: LROP.pageLR?.targetKey,
-        navigatedOP: LROP.pageOP?.targetKey,
-        hideFilterBar: config.hideFilterBar
-    };
-    const generatedJourneyPages = [];
-    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/FirstJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${config.opaJourneyFileName}.js`), journeyParams, undefined, {
+    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'FirstJourney.js'), (0, node_path_1.join)(testOutDirPath, 'integration', `${config.opaJourneyFileName}.js`), journeyParams, undefined, {
+        globOptions: { dot: true }
+    });
+    // Journey Runner
+    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'pages', 'JourneyRunner.js'), (0, node_path_1.join)(testOutDirPath, 'integration', 'pages', 'JourneyRunner.js'), config, undefined, {
         globOptions: { dot: true }
     });
-    if (listReport) {
-        editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/ListReportJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${listReport.name}Journey.js`), {
+}
+/**
+ * Checks whether a page object file already exists for the given feature name.
+ * If it doesn't exist, finds the matching page config and writes the file.
+ *
+ * @param featureName - the feature/page name (equals the manifest targetKey)
+ * @param config - the OPA config containing all page configurations
+ * @param rootV4TemplateDirPath - template root directory for v4 templates
+ * @param testOutDirPath - output test directory (.../webapp/test)
+ * @param editor - a reference to a mem-fs editor
+ * @returns JourneyRunnerPage if the page was newly created, undefined otherwise
+ */
+function ensurePageExists(featureName, config, rootV4TemplateDirPath, testOutDirPath, editor) {
+    const pageFilePath = (0, node_path_1.join)(testOutDirPath, 'integration', 'pages', `${featureName}.js`);
+    if (editor.exists(pageFilePath)) {
+        return undefined;
+    }
+    const pageConfig = config.pages.find((p) => p.targetKey === featureName);
+    if (pageConfig) {
+        writePageObject(pageConfig, rootV4TemplateDirPath, testOutDirPath, editor);
+        return { targetKey: featureName, appPath: config.appPath };
+    }
+    return undefined;
+}
+/**
+ * Writes journey files for list report, object pages and FPM pages.
+ *
+ * @param appFeatures - object containing feature data for list report, object pages, and FPM
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param isStandalone - whether the generation is run in standalone mode (not during app generation)
+ * @param hasJourneyRunner - whether a JourneyRunner.js already exists (standalone upgrade path)
+ * @param virtualOPA5Configured - whether virtual OPA5 is configured
+ */
+function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRunner = false, virtualOPA5Configured = false) {
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams } = writeContext;
+    const generatedJourneyPages = [];
+    const newPages = [];
+    if (appFeatures.listReport?.name) {
+        editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'ListReportJourney.js'), (0, node_path_1.join)(testOutDirPath, 'integration', `${appFeatures.listReport.name}Journey.js`), {
             ...journeyParams,
-            ...listReport
+            ...appFeatures.listReport
         }, undefined, {
             globOptions: { dot: true }
         });
-        generatedJourneyPages.push(listReport.name);
+        generatedJourneyPages.push(appFeatures.listReport.name);
+        const lrPage = ensurePageExists(appFeatures.listReport.name, config, rootV4TemplateDirPath, testOutDirPath, editor);
+        if (lrPage) {
+            newPages.push(lrPage);
+        }
     }
-    if (objectPages && objectPages.length > 0) {
-        objectPages.forEach((objectPage) => {
-            editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/ObjectPageJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${objectPage.name}Journey.js`), {
-                ...journeyParams,
-                ...objectPage
-            }, undefined, {
-                globOptions: { dot: true }
-            });
-            generatedJourneyPages.push(objectPage.name);
+    if (appFeatures.objectPages && appFeatures.objectPages.length > 0) {
+        appFeatures.objectPages.forEach((objectPage) => {
+            if (objectPage.name) {
+                editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'ObjectPageJourney.js'), (0, node_path_1.join)(testOutDirPath, 'integration', `${objectPage.name}Journey.js`), {
+                    ...journeyParams,
+                    ...objectPage,
+                    isStandalone
+                }, undefined, {
+                    globOptions: { dot: true }
+                });
+                generatedJourneyPages.push(objectPage.name);
+                const opPage = ensurePageExists(objectPage.name, config, rootV4TemplateDirPath, testOutDirPath, editor);
+                if (opPage) {
+                    newPages.push(opPage);
+                }
+            }
         });
     }
-    if (fpm) {
-        editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration/FPMJourney.js'), (0, node_path_1.join)(testOutDirPath, `integration/${fpm.name}Journey.js`), {
+    if (appFeatures.fpm?.name) {
+        editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'FPMJourney.js'), (0, node_path_1.join)(testOutDirPath, 'integration', `${appFeatures.fpm.name}Journey.js`), {
             ...journeyParams,
-            ...fpm
+            ...appFeatures.fpm
         }, undefined, {
             globOptions: { dot: true }
         });
-        generatedJourneyPages.push(fpm.name);
+        generatedJourneyPages.push(appFeatures.fpm.name);
+        const fpmPage = ensurePageExists(appFeatures.fpm.name, config, rootV4TemplateDirPath, testOutDirPath, editor);
+        if (fpmPage) {
+            newPages.push(fpmPage);
+        }
     }
-    // Integration (OPA) test files - version-specific
-    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'opaTests.*.*'), (0, node_path_1.join)(testOutDirPath, 'integration'), { ...config, generatedJourneyPages }, undefined, {
-        globOptions: { dot: true }
-    });
-    // Journey Runner
-    editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'pages', 'JourneyRunner.js'), (0, node_path_1.join)(testOutDirPath, 'integration', 'pages', 'JourneyRunner.js'), config, undefined, {
+    if (newPages.length > 0) {
+        (0, opaQUnitUtils_1.addPagesToJourneyRunner)(newPages, testOutDirPath, editor);
+    }
+    if (!virtualOPA5Configured) {
+        if (hasJourneyRunner) {
+            (0, opaQUnitUtils_1.addPathsToQUnitJs)(generatedJourneyPages.map((page) => {
+                return `${config.appPath}/test/integration/${page}Journey`;
+            }), testOutDirPath, editor);
+        }
+        else {
+            editor.copyTpl((0, node_path_1.join)(rootV4TemplateDirPath, 'integration', 'opaTests.*.*'), (0, node_path_1.join)(testOutDirPath, 'integration'), { ...config, generatedJourneyPages }, undefined, {
+                globOptions: { dot: true }
+            });
+        }
+    }
+}
+/**
+ * Writes a page object in a mem-fs-editor.
+ *
+ * @param pageConfig - the page configuration object
+ * @param rootTemplateDirPath - template root directory
+ * @param testOutDirPath - output test directory (.../webapp/test)
+ * @param fs - a reference to a mem-fs editor
+ */
+function writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, fs) {
+    fs.copyTpl((0, node_path_1.join)(rootTemplateDirPath, 'integration', 'pages', `${pageConfig.template}.js`), (0, node_path_1.join)(testOutDirPath, 'integration', 'pages', `${pageConfig.targetKey}.js`), pageConfig, undefined, {
         globOptions: { dot: true }
     });
-    return editor;
 }
 /**
  * Generate a page object file for a Fiori elements for OData V4 application.
@@ -302,14 +398,14 @@ async function generateOPAFiles(basePath, opaConfig, metadata, fs, log) {
  * @param fs - an optional reference to a mem-fs editor
  * @returns Reference to a mem-fs-editor
  */
-function generatePageObjectFile(basePath, pageObjectParameters, fs) {
-    const editor = fs || (0, mem_fs_editor_1.create)((0, mem_fs_1.create)());
+async function generatePageObjectFile(basePath, pageObjectParameters, fs) {
+    const editor = fs ?? (0, mem_fs_editor_1.create)((0, mem_fs_1.create)());
     const manifest = readManifest(editor, basePath);
     const { applicationType } = getAppTypeAndHideFilterBarFromManifest(manifest);
     const pageConfig = createPageConfig(manifest, pageObjectParameters.targetKey, pageObjectParameters.appID);
     if (pageConfig) {
         const rootTemplateDirPath = (0, node_path_1.join)(__dirname, `../templates/${applicationType}`); // Only v4 is supported for the time being
-        const testOutDirPath = (0, node_path_1.join)(basePath, 'webapp/test');
+        const testOutDirPath = (0, node_path_1.join)(await (0, project_access_1.getWebappPath)(basePath), 'test');
         writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, editor);
     }
     else {

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { Editor } from 'mem-fs-editor';
 export declare const SupportedPageTypes: {
     [id: string]: string;
 };
@@ -20,6 +21,12 @@ export type FEV4OPAConfig = {
     hideFilterBar: boolean;
     filterBarItems?: string[];
 };
+export type JourneyParams = {
+    startPages: string[];
+    startLR: string | undefined;
+    navigatedOP: string | undefined;
+    hideFilterBar: boolean;
+};
 export type FEV4ManifestTarget = {
     type?: string;
     name?: string;
@@ -36,6 +43,13 @@ export type FEV4ManifestTarget = {
                     };
                 };
             };
+            views?: {
+                paths?: Array<{
+                    primary?: unknown[];
+                    secondary?: unknown[];
+                    defaultPath?: string;
+                }>;
+            };
         };
     };
 };
@@ -103,6 +117,7 @@ export type ListReportFeatures = {
     filterBarItems?: string[];
     tableColumns?: Record<string, Record<string, string | number | boolean>>;
     toolBarActions?: ActionButtonState[];
+    isALP?: boolean;
 };
 export interface ActionButtonState {
     label: string;
@@ -135,6 +150,13 @@ export type AppFeatures = {
     objectPages?: ObjectPageFeatures[];
     fpm?: FPMFeatures;
 };
+export type WriteContext = {
+    config: FEV4OPAConfig;
+    rootV4TemplateDirPath: string;
+    testOutDirPath: string;
+    editor: Editor;
+    journeyParams: JourneyParams;
+};
 export type FormField = {
     fieldGroupQualifier?: string;
     field?: string;

package/dist/utils/flpSandboxUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utility for reading the FLP sandbox HTML file and extracting the
+ * application hash (intent) from the sap-ushell-config applications object.
+ */
+import type { Editor } from 'mem-fs-editor';
+/**
+ * Reads an FLP sandbox HTML file and extracts the first application key
+ * from the `sap-ushell-config` `applications` object.
+ *
+ * @param htmlRelativePath - path to the HTML file relative to `webapp/`
+ *   (e.g. `test/flpSandbox.html`)
+ * @param webappPath - path to the webapp directory
+ * @param fs - mem-fs-editor instance used to read the file
+ * @returns the application key (e.g. `fincashbankmanage-tile`), or undefined
+ */
+export declare function readHashFromFlpSandbox(htmlRelativePath: string, webappPath: string, fs: Editor): string | undefined;
+//# sourceMappingURL=flpSandboxUtils.d.ts.map

package/dist/utils/flpSandboxUtils.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Utility for reading the FLP sandbox HTML file and extracting the
+ * application hash (intent) from the sap-ushell-config applications object.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readHashFromFlpSandbox = readHashFromFlpSandbox;
+const node_path_1 = require("node:path");
+/**
+ * Regex to extract the first application key from the sap-ushell-config
+ * `applications` block.  Matches patterns like:
+ *
+ *   applications: {
+ *       "fincashbankmanage-tile": {
+ *
+ * Captures the quoted key (e.g. `fincashbankmanage-tile`).
+ */
+const APPLICATIONS_KEY_REGEX = /applications\s*:\s*\{[^"]*"([^"]+)"\s*:/;
+/**
+ * Reads an FLP sandbox HTML file and extracts the first application key
+ * from the `sap-ushell-config` `applications` object.
+ *
+ * @param htmlRelativePath - path to the HTML file relative to `webapp/`
+ *   (e.g. `test/flpSandbox.html`)
+ * @param webappPath - path to the webapp directory
+ * @param fs - mem-fs-editor instance used to read the file
+ * @returns the application key (e.g. `fincashbankmanage-tile`), or undefined
+ */
+function readHashFromFlpSandbox(htmlRelativePath, webappPath, fs) {
+    try {
+        const filePath = (0, node_path_1.join)(webappPath, htmlRelativePath);
+        const content = fs.read(filePath);
+        const match = APPLICATIONS_KEY_REGEX.exec(content);
+        return match?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=flpSandboxUtils.js.map

package/dist/utils/listReportUtils.d.ts

@@ -1,7 +1,8 @@
 import type { Logger } from '@sap-ux/logger';
 import type { TreeAggregations, TreeModel } from '@sap/ux-specification/dist/types/src/parser';
-import type { ActionButtonsResult, ActionButtonState, ButtonState, ButtonVisibilityResult, ListReportFeatures } from '../types';
+import type { ActionButtonsResult, ActionButtonState, ButtonState, ButtonVisibilityResult, FEV4ManifestTarget, ListReportFeatures } from '../types';
 import type { PageWithModelV4 } from '@sap/ux-specification/dist/types/src/parser/application';
+import type { Manifest } from '@sap-ux/project-access';
 /**
  * Builds a button state object from button visibility result.
  *
@@ -32,15 +33,33 @@ export declare function safeCheckButtonVisibility(metadata: string, entitySetNam
  * @returns Array of action button states or empty array if error occurs
  */
 export declare function safeCheckActionButtonStates(metadata: string, entitySetName: string, actionNames: string[], log?: Logger): ActionButtonState[];
+/**
+ * Returns true when a ListReport manifest target is configured as an Analytical List Page.
+ * ALP targets have a `views.paths` array where at least one entry contains a `primary` array,
+ * indicating the dual-view (chart + table) layout used by ALP.
+ *
+ * @param target - the manifest routing target to inspect
+ * @returns true if the target represents an ALP configuration
+ */
+export declare function isALPManifestTarget(target: FEV4ManifestTarget): boolean;
+/**
+ * Returns true if any ListReport target in the manifest is configured as an Analytical List Page.
+ *
+ * @param manifest - the application manifest
+ * @param targetKey - optional specific target key to check; if omitted all ListReport targets are checked
+ * @returns true if the target (or any ListReport target) is an ALP
+ */
+export declare function isALPFromManifest(manifest: Manifest, targetKey?: string): boolean;
 /**
  * Gets List Report features from the page model using ux-specification.
  *
  * @param listReportPage - the List Report page containing the tree model with feature definitions
  * @param log - optional logger instance
  * @param metadata - optional metadata for the OPA test generation
+ * @param manifest - optional application manifest, used to detect ALP configuration
  * @returns feature data extracted from the List Report page model
  */
-export declare function getListReportFeatures(listReportPage: PageWithModelV4, log?: Logger, metadata?: string): ListReportFeatures;
+export declare function getListReportFeatures(listReportPage: PageWithModelV4, log?: Logger, metadata?: string, manifest?: Manifest): ListReportFeatures;
 /**
  * Retrieves toolbar action definitions from the given tree model.
  *

package/dist/utils/listReportUtils.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildButtonState = buildButtonState;
 exports.safeCheckButtonVisibility = safeCheckButtonVisibility;
 exports.safeCheckActionButtonStates = safeCheckActionButtonStates;
+exports.isALPManifestTarget = isALPManifestTarget;
+exports.isALPFromManifest = isALPFromManifest;
 exports.getListReportFeatures = getListReportFeatures;
 exports.getToolBarActions = getToolBarActions;
 exports.checkButtonVisibility = checkButtonVisibility;
@@ -61,15 +63,45 @@ function safeCheckActionButtonStates(metadata, entitySetName, actionNames, log)
         return [];
     }
 }
+/**
+ * Returns true when a ListReport manifest target is configured as an Analytical List Page.
+ * ALP targets have a `views.paths` array where at least one entry contains a `primary` array,
+ * indicating the dual-view (chart + table) layout used by ALP.
+ *
+ * @param target - the manifest routing target to inspect
+ * @returns true if the target represents an ALP configuration
+ */
+function isALPManifestTarget(target) {
+    return (target.options?.settings?.views?.paths?.some((path) => Array.isArray(path.primary) && path.primary.length > 0) ?? false);
+}
+/**
+ * Returns true if any ListReport target in the manifest is configured as an Analytical List Page.
+ *
+ * @param manifest - the application manifest
+ * @param targetKey - optional specific target key to check; if omitted all ListReport targets are checked
+ * @returns true if the target (or any ListReport target) is an ALP
+ */
+function isALPFromManifest(manifest, targetKey) {
+    const targets = manifest['sap.ui5']?.routing?.targets;
+    if (!targets) {
+        return false;
+    }
+    const keysToCheck = targetKey ? [targetKey] : Object.keys(targets);
+    return keysToCheck.some((key) => {
+        const target = targets[key];
+        return target?.name === 'sap.fe.templates.ListReport' && isALPManifestTarget(target);
+    });
+}
 /**
  * Gets List Report features from the page model using ux-specification.
  *
  * @param listReportPage - the List Report page containing the tree model with feature definitions
  * @param log - optional logger instance
  * @param metadata - optional metadata for the OPA test generation
+ * @param manifest - optional application manifest, used to detect ALP configuration
  * @returns feature data extracted from the List Report page model
  */
-function getListReportFeatures(listReportPage, log, metadata) {
+function getListReportFeatures(listReportPage, log, metadata, manifest) {
     const buttonVisibility = metadata && listReportPage.entitySet
         ? safeCheckButtonVisibility(metadata, listReportPage.entitySet, log)
         : undefined;
@@ -82,7 +114,8 @@ function getListReportFeatures(listReportPage, log, metadata) {
         tableColumns: (0, modelUtils_1.getTableColumnData)(listReportPage.model, log),
         toolBarActions: metadata && listReportPage.entitySet
             ? safeCheckActionButtonStates(metadata, listReportPage.entitySet, toolbarActions, log)
-            : []
+            : [],
+        isALP: manifest ? isALPFromManifest(manifest, listReportPage.name) : false
     };
 }
 /**

package/dist/utils/modelUtils.d.ts

@@ -1,4 +1,5 @@
 import type { Editor } from 'mem-fs-editor';
+import type { Manifest } from '@sap-ux/project-access';
 import type { Logger } from '@sap-ux/logger';
 import type { PageWithModelV4 } from '@sap/ux-specification/dist/types/src/parser/application';
 import type { TreeAggregation, TreeAggregations, TreeModel, ApplicationModel } from '@sap/ux-specification/dist/types/src/parser';
@@ -49,9 +50,10 @@ export interface PageWithModelV4WithProperties extends PageWithModelV4 {
  * @param fs - optional mem-fs editor instance
  * @param log - optional logger instance
  * @param metadata - optional metadata for the OPA test generation
+ * @param manifest - optional application manifest, used to detect ALP configuration
  * @returns feature data extracted from the application model
  */
-export declare function getAppFeatures(basePath: string, fs?: Editor, log?: Logger, metadata?: string): Promise<AppFeatures>;
+export declare function getAppFeatures(basePath: string, fs?: Editor, log?: Logger, metadata?: string, manifest?: Manifest): Promise<AppFeatures>;
 /**
  * Retrieves table column data from the page model using ux-specification.
  *

package/dist/utils/modelUtils.js

@@ -20,9 +20,10 @@ const listReportUtils_1 = require("./listReportUtils");
  * @param fs - optional mem-fs editor instance
  * @param log - optional logger instance
  * @param metadata - optional metadata for the OPA test generation
+ * @param manifest - optional application manifest, used to detect ALP configuration
  * @returns feature data extracted from the application model
  */
-async function getAppFeatures(basePath, fs, log, metadata) {
+async function getAppFeatures(basePath, fs, log, metadata, manifest) {
     const featureData = {};
     let listReportPage = null;
     let objectPages = null;
@@ -57,7 +58,7 @@ async function getAppFeatures(basePath, fs, log, metadata) {
     // attempt to get individual feature data
     try {
         if (listReportPage) {
-            featureData.listReport = (0, listReportUtils_1.getListReportFeatures)(listReportPage, log, projectMetadata);
+            featureData.listReport = (0, listReportUtils_1.getListReportFeatures)(listReportPage, log, projectMetadata, manifest);
         }
         if (objectPages) {
             log?.warn('Extracting Object Page features from application model');

package/dist/utils/opaQUnitUtils.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Utility for reading and updating a generated opaTests.qunit.js file.
+ * The file is modified in-place: only the sap.ui.require array is changed;
+ * all other content (formatting, comments, whitespace) is preserved exactly.
+ */
+import type { Editor } from 'mem-fs-editor';
+/**
+ * Splices new module paths into the sap.ui.require array of the content string.
+ * Entries that are already present are skipped. All other content is preserved exactly.
+ *
+ * Note: files exceeding MAX_FILE_CONTENT_LENGTH characters are returned unchanged to prevent
+ * ReDoS on crafted inputs. Valid generated files are well within this limit.
+ *
+ * @param fileContent - the full content of the opaTests.qunit.js file
+ * @param moduleNames - module paths to add (e.g. ["myApp/test/integration/SomeJourney"])
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export declare function spliceModulesIntoQUnitContent(fileContent: string, moduleNames: string[]): string;
+/**
+ * Reads opaTests.qunit.js from webapp/test/integration_old and extracts the html
+ * launch target (path, query parameters, and hash fragment) from the launchUrl
+ * line, e.g. `test/flpSandbox.html?sap-ui-xx-viewCache=false#myApp-tile`.
+ * Returns undefined if the file cannot be read or the pattern is not found.
+ *
+ * @param testPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read the file
+ * @returns the html target string, or undefined if not found
+ */
+export declare function readHtmlTargetFromQUnitJs(testPath: string, fs: Editor): string | undefined;
+/**
+ * Appends `/webapp/test/integration_old` to the project's `.gitignore`.
+ * Creates the file if it does not exist. Skips if the entry is already present.
+ *
+ * @param basePath - project root (contains .gitignore)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ */
+export declare function addIntegrationOldToGitignore(basePath: string, fs: Editor): Promise<void>;
+/**
+ * Reads opaTests.qunit.js from the project, adds module paths to the
+ * sap.ui.require array, and writes the updated content back.
+ * Entries that are already present are skipped.
+ * All other file content is preserved exactly.
+ *
+ * @param filePaths - module paths to add (e.g. ["myApp/test/integration/SomeJourney"])
+ * @param projectPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ */
+export declare function addPathsToQUnitJs(filePaths: string[], projectPath: string, fs: Editor): void;
+/**
+ * Page entry to splice into an existing JourneyRunner.js.
+ */
+export interface JourneyRunnerPage {
+    /** The page's targetKey, used as both the variable name and `onThe<targetKey>` key */
+    targetKey: string;
+    /** The app module path prefix (e.g. "project1/test/integration/pages") */
+    appPath: string;
+}
+/**
+ * Splices new page entries into the three locations of an existing JourneyRunner.js:
+ * - the sap.ui.define dependency array
+ * - the function parameter list
+ * - the pages object literal
+ *
+ * Pages already present (detected by their module path in the define array) are skipped.
+ * All other content — formatting, comments, whitespace — is preserved exactly.
+ *
+ * Note: files exceeding MAX_FILE_CONTENT_LENGTH characters are returned unchanged to prevent
+ * ReDoS on crafted inputs. Valid generated files are well within this limit.
+ *
+ * @param fileContent - the full content of the JourneyRunner.js file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export declare function splicePageIntoJourneyRunner(fileContent: string, pages: JourneyRunnerPage[]): string;
+/**
+ * Reads JourneyRunner.js from the project, adds new page entries to all three
+ * locations (define array, function params, pages object), and writes the updated
+ * content back. Pages already present are skipped.
+ *
+ * @param pages - pages to add
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ */
+export declare function addPagesToJourneyRunner(pages: JourneyRunnerPage[], testOutDirPath: string, fs: Editor): void;
+/**
+ * Returns true if any UI5 yaml file in the project contains a `fiori-tools-preview`
+ * middleware whose `test` array includes an entry with `framework: OPA5`.
+ *
+ * @param basePath - project root directory
+ * @returns true when OPA5 is configured in a preview middleware, false otherwise
+ */
+export declare function hasVirtualOPA5(basePath: string): Promise<boolean>;
+//# sourceMappingURL=opaQUnitUtils.d.ts.map

package/dist/utils/opaQUnitUtils.js

@@ -0,0 +1,303 @@
+"use strict";
+/**
+ * Utility for reading and updating a generated opaTests.qunit.js file.
+ * The file is modified in-place: only the sap.ui.require array is changed;
+ * all other content (formatting, comments, whitespace) is preserved exactly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spliceModulesIntoQUnitContent = spliceModulesIntoQUnitContent;
+exports.readHtmlTargetFromQUnitJs = readHtmlTargetFromQUnitJs;
+exports.addIntegrationOldToGitignore = addIntegrationOldToGitignore;
+exports.addPathsToQUnitJs = addPathsToQUnitJs;
+exports.splicePageIntoJourneyRunner = splicePageIntoJourneyRunner;
+exports.addPagesToJourneyRunner = addPagesToJourneyRunner;
+exports.hasVirtualOPA5 = hasVirtualOPA5;
+const node_path_1 = require("node:path");
+const flpSandboxUtils_1 = require("./flpSandboxUtils");
+const project_access_1 = require("@sap-ux/project-access");
+/** Relative path from the test output directory to opaTests.qunit.js */
+const OPA_QUNIT_FILE = (0, node_path_1.join)('integration', 'opaTests.qunit.js');
+/**
+ * The regex matches the opening bracket of the sap.ui.require array and
+ * captures everything up to (but not including) the closing bracket followed
+ * by `], function`.  This lets us splice new entries in without disturbing
+ * any other part of the file.
+ *
+ * Matches:
+ *   sap.ui.require(\n  [\n    "a",\n    "b",\n  ], function
+ *                           ^^^^^^^^^^^^^^^^^
+ *                           captured as group 1
+ *
+ * The `d` flag enables `match.indices` so we can read the capture group's
+ * exact start/end positions without fragile string searching.
+ */
+const SAP_UI_REQUIRE_ARRAY_REGEX = /sap\.ui\.require\s*\(\s*\[([^\]]*)\]\s*,\s*function/d;
+/** ReDoS mitigation: files larger than this are returned unchanged rather than matched with regex. */
+const MAX_FILE_CONTENT_LENGTH = 10000;
+/**
+ * Splices new module paths into the sap.ui.require array of the content string.
+ * Entries that are already present are skipped. All other content is preserved exactly.
+ *
+ * Note: files exceeding MAX_FILE_CONTENT_LENGTH characters are returned unchanged to prevent
+ * ReDoS on crafted inputs. Valid generated files are well within this limit.
+ *
+ * @param fileContent - the full content of the opaTests.qunit.js file
+ * @param moduleNames - module paths to add (e.g. ["myApp/test/integration/SomeJourney"])
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+function spliceModulesIntoQUnitContent(fileContent, moduleNames) {
+    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
+        return fileContent;
+    }
+    const match = SAP_UI_REQUIRE_ARRAY_REGEX.exec(fileContent);
+    if (!match) {
+        return fileContent;
+    }
+    const arrayBody = match[1]; // everything between `[` and `]`
+    // Collect existing quoted entries so we don't add duplicates
+    const existingEntries = new Set();
+    const entryRegex = /"([^"]+)"/g;
+    let entryMatch;
+    while ((entryMatch = entryRegex.exec(arrayBody)) !== null) {
+        existingEntries.add(entryMatch[1]);
+    }
+    const toAdd = moduleNames.filter((name) => !existingEntries.has(name));
+    if (toAdd.length === 0) {
+        return fileContent;
+    }
+    // Detect the indentation used by the existing entries (e.g. four spaces)
+    const indentMatch = /^([ \t]+)"/m.exec(arrayBody);
+    const indent = indentMatch ? indentMatch[1] : '    ';
+    // Build the lines to insert, each terminated with a trailing comma
+    const newLines = toAdd.map((name) => `${indent}"${name}",`).join('\n');
+    // Insert just before the closing `]` using the capture group's end index.
+    const insertPosition = match.indices?.[1]?.[1];
+    if (insertPosition === undefined) {
+        return fileContent;
+    }
+    // Ensure the last existing entry ends with a comma before inserting after it.
+    const trimmedBefore = fileContent.slice(0, insertPosition).trimEnd();
+    const needsComma = !trimmedBefore.endsWith(',');
+    const commaFix = needsComma ? ',' : '';
+    const trailingWhitespace = fileContent.slice(trimmedBefore.length, insertPosition);
+    const after = fileContent.slice(insertPosition);
+    return `${trimmedBefore}${commaFix}\n${newLines}\n${trailingWhitespace}${after}`;
+}
+/**
+ * Regex to extract the html launch target from a `launchUrl` line of the form:
+ *   sap.ui.require.toUrl('...') + '/some/path.html?params#hash'
+ * Captures the path/query/hash portion after the closing `') + '`.
+ */
+const LAUNCH_URL_REGEX = /\.toUrl\s*\([^)]+\)\s*\+\s*'([^']+)'/;
+/**
+ * Reads opaTests.qunit.js from webapp/test/integration_old and extracts the html
+ * launch target (path, query parameters, and hash fragment) from the launchUrl
+ * line, e.g. `test/flpSandbox.html?sap-ui-xx-viewCache=false#myApp-tile`.
+ * Returns undefined if the file cannot be read or the pattern is not found.
+ *
+ * @param testPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read the file
+ * @returns the html target string, or undefined if not found
+ */
+function readHtmlTargetFromQUnitJs(testPath, fs) {
+    try {
+        const integrationOldDir = (0, node_path_1.join)(testPath, 'integration_old');
+        let filePath = (0, node_path_1.join)(integrationOldDir, 'opaTests.qunit.js');
+        if (!fs.exists(filePath)) {
+            filePath = (0, node_path_1.join)(integrationOldDir, 'Opa.qunit.js');
+        }
+        const content = fs.read(filePath);
+        const match = LAUNCH_URL_REGEX.exec(content);
+        const launchUrl = match?.[1].replace(/^\//, '');
+        if (!launchUrl) {
+            return undefined;
+        }
+        // If the launch URL already contains a hash fragment, use it as-is
+        if (launchUrl.includes('#')) {
+            return launchUrl;
+        }
+        // No hash fragment — read the referenced HTML file to extract the
+        // application key from the sap-ushell-config applications object
+        const htmlPath = launchUrl.split('?')[0];
+        const hash = (0, flpSandboxUtils_1.readHashFromFlpSandbox)(htmlPath, (0, node_path_1.join)(testPath, '..'), fs);
+        return hash ? `${launchUrl}#${hash}` : launchUrl;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The gitignore entry added for the moved integration test folder */
+const INTEGRATION_OLD_GITIGNORE_ENTRY = '/webapp/test/integration_old';
+/**
+ * Appends `/webapp/test/integration_old` to the project's `.gitignore`.
+ * Creates the file if it does not exist. Skips if the entry is already present.
+ *
+ * @param basePath - project root (contains .gitignore)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ */
+async function addIntegrationOldToGitignore(basePath, fs) {
+    const filePath = (0, node_path_1.join)(basePath, '.gitignore');
+    const existing = fs.exists(filePath) ? fs.read(filePath) : '';
+    const lines = existing.split('\n');
+    if (lines.some((line) => line.trim() === INTEGRATION_OLD_GITIGNORE_ENTRY)) {
+        return;
+    }
+    const updated = existing.endsWith('\n') || existing === ''
+        ? `${existing}${INTEGRATION_OLD_GITIGNORE_ENTRY}\n`
+        : `${existing}\n${INTEGRATION_OLD_GITIGNORE_ENTRY}\n`;
+    fs.write(filePath, updated);
+}
+/**
+ * Reads opaTests.qunit.js from the project, adds module paths to the
+ * sap.ui.require array, and writes the updated content back.
+ * Entries that are already present are skipped.
+ * All other file content is preserved exactly.
+ *
+ * @param filePaths - module paths to add (e.g. ["myApp/test/integration/SomeJourney"])
+ * @param projectPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ */
+function addPathsToQUnitJs(filePaths, projectPath, fs) {
+    try {
+        const filePath = (0, node_path_1.join)(projectPath, OPA_QUNIT_FILE);
+        const content = fs.read(filePath);
+        const updated = spliceModulesIntoQUnitContent(content, filePaths);
+        if (updated !== content) {
+            fs.write(filePath, updated);
+        }
+    }
+    catch {
+        // If the file doesn't exist or can't be read, do nothing
+    }
+}
+/** Relative path from the test output directory to JourneyRunner.js */
+const JOURNEY_RUNNER_FILE = (0, node_path_1.join)('integration', 'pages', 'JourneyRunner.js');
+/**
+ * Splices new page entries into the three locations of an existing JourneyRunner.js:
+ * - the sap.ui.define dependency array
+ * - the function parameter list
+ * - the pages object literal
+ *
+ * Pages already present (detected by their module path in the define array) are skipped.
+ * All other content — formatting, comments, whitespace — is preserved exactly.
+ *
+ * Note: files exceeding MAX_FILE_CONTENT_LENGTH characters are returned unchanged to prevent
+ * ReDoS on crafted inputs. Valid generated files are well within this limit.
+ *
+ * @param fileContent - the full content of the JourneyRunner.js file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+function splicePageIntoJourneyRunner(fileContent, pages) {
+    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
+        return fileContent;
+    }
+    // Determine which pages are not yet present by checking the define array
+    const toAdd = pages.filter((page) => {
+        const modulePath = `${page.appPath}/test/integration/pages/${page.targetKey}`;
+        return !fileContent.includes(`"${modulePath}"`);
+    });
+    if (toAdd.length === 0) {
+        return fileContent;
+    }
+    let result = fileContent;
+    // 1. Splice into the sap.ui.define([...]) array.
+    //    Captures everything between the opening `[` and the closing `]` before `, function`.
+    const defineArrayRegex = /sap\.ui\.define\s*\(\s*\[([^\]]*)\]\s*,\s*function/d;
+    const defineMatch = defineArrayRegex.exec(result);
+    if (defineMatch?.indices?.[1]) {
+        const [bodyStart, bodyEnd] = defineMatch.indices[1];
+        const arrayBody = result.slice(bodyStart, bodyEnd);
+        // Detect indentation from the first existing module entry line
+        const indentMatch = /^([ \t]+)"/m.exec(arrayBody);
+        const indent = indentMatch ? indentMatch[1] : '\t';
+        const newEntries = toAdd
+            .map((page) => `${indent}"${page.appPath}/test/integration/pages/${page.targetKey}",`)
+            .join('\n');
+        // Ensure the last existing entry ends with a comma before we insert after it.
+        // The trimmed body ends at bodyEnd; look back from there for the last non-whitespace char.
+        const trimmedEnd = result.slice(0, bodyEnd).trimEnd();
+        const needsComma = !trimmedEnd.endsWith(',');
+        const commaFix = needsComma ? ',' : '';
+        const trailingWhitespace = result.slice(trimmedEnd.length, bodyEnd);
+        result = `${trimmedEnd}${commaFix}\n${newEntries}` + `${trailingWhitespace}${result.slice(bodyEnd)}`;
+    }
+    // 2. Splice into the function parameter list: `function (JourneyRunner, A, B)`.
+    //    Captures everything between `(` and `)` of the function signature.
+    const funcParamRegex = /\]\s*,\s*function\s*\(([^)]*)\)\s*\{/d;
+    const funcMatch = funcParamRegex.exec(result);
+    if (funcMatch?.indices?.[1]) {
+        const [, paramEnd] = funcMatch.indices[1];
+        const newParams = toAdd.map((page) => `, ${page.targetKey}`).join('');
+        result = `${result.slice(0, paramEnd)}${newParams}${result.slice(paramEnd)}`;
+    }
+    // 3. Splice into the pages object: `pages: { onTheFoo: Foo, ... }`.
+    //    Captures everything between `pages: {` and the closing `}`.
+    const pagesObjectRegex = /pages\s*:\s*\{([^}]*)\}/d;
+    const pagesMatch = pagesObjectRegex.exec(result);
+    if (pagesMatch?.indices?.[1]) {
+        const [, pagesBodyEnd] = pagesMatch.indices[1];
+        const pagesBody = result.slice(pagesMatch.indices[1][0], pagesBodyEnd);
+        // Detect indentation from the first existing page entry
+        const pageIndentMatch = /^([ \t]+)on/m.exec(pagesBody);
+        const pageIndent = pageIndentMatch ? pageIndentMatch[1] : '\t\t\t';
+        const newPageEntries = toAdd
+            .map((page) => `${pageIndent}onThe${page.targetKey}: ${page.targetKey},`)
+            .join('\n');
+        // Ensure the last existing entry ends with a comma before we insert after it.
+        const trimmedPagesEnd = result.slice(0, pagesBodyEnd).trimEnd();
+        const needsComma = !trimmedPagesEnd.endsWith(',');
+        const commaFix = needsComma ? ',' : '';
+        const trailingWhitespace = result.slice(trimmedPagesEnd.length, pagesBodyEnd);
+        result =
+            `${trimmedPagesEnd}${commaFix}\n${newPageEntries}` + `${trailingWhitespace}${result.slice(pagesBodyEnd)}`;
+    }
+    return result;
+}
+/**
+ * Reads JourneyRunner.js from the project, adds new page entries to all three
+ * locations (define array, function params, pages object), and writes the updated
+ * content back. Pages already present are skipped.
+ *
+ * @param pages - pages to add
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @param fs - mem-fs-editor instance used to read and write the file
+ */
+function addPagesToJourneyRunner(pages, testOutDirPath, fs) {
+    try {
+        const filePath = (0, node_path_1.join)(testOutDirPath, JOURNEY_RUNNER_FILE);
+        const content = fs.read(filePath);
+        const updated = splicePageIntoJourneyRunner(content, pages);
+        if (updated !== content) {
+            fs.write(filePath, updated);
+        }
+    }
+    catch {
+        // If the file doesn't exist or can't be read, do nothing
+    }
+}
+/**
+ * Returns true if any UI5 yaml file in the project contains a `fiori-tools-preview`
+ * middleware whose `test` array includes an entry with `framework: OPA5`.
+ *
+ * @param basePath - project root directory
+ * @returns true when OPA5 is configured in a preview middleware, false otherwise
+ */
+async function hasVirtualOPA5(basePath) {
+    const yamlFileNames = await (0, project_access_1.getAllUi5YamlFileNames)(basePath);
+    for (const fileName of yamlFileNames) {
+        try {
+            const ui5Config = await (0, project_access_1.readUi5Yaml)(basePath, fileName);
+            const previewMiddleware = ui5Config.findCustomMiddleware('fiori-tools-preview');
+            const testEntries = previewMiddleware?.configuration?.test;
+            if (testEntries?.some((entry) => entry.framework === 'OPA5')) {
+                return true;
+            }
+        }
+        catch {
+            // Skip yaml files that cannot be read
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=opaQUnitUtils.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sap-ux/ui5-test-writer",
   "description": "SAP UI5 tests writer",
-  "version": "0.7.102",
+  "version": "0.7.104",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",
@@ -27,8 +27,8 @@
     "@sap/ux-specification": "1.144.0",
     "@sap-ux/edmx-parser": "0.10.0",
     "@sap-ux/annotation-converter": "0.10.21",
-    "@sap-ux/project-access": "1.35.20",
     "@sap-ux/ui5-application-writer": "1.8.5",
+    "@sap-ux/project-access": "1.35.20",
     "@sap-ux/logger": "0.8.5"
   },
   "devDependencies": {

package/templates/v4/integration/ListReportJourney.js

@@ -41,7 +41,7 @@ sap.ui.define([
 
         opaTest("Check table columns and actions", function (Given, When, Then) {
             <%_ if (toolBarActions && toolBarActions.length > 0) { -%>
-            <%_ if (createButton.visible) { _%>
+            <%_ if (createButton.visible && !isALP) { _%>
             Then.onThe<%- startLR%>.onTable().iCheckCreate({ visible: true });
             // Then.onthe<%- startLR%>.onTable().iPressCreate();
             <%_ } _%>

package/templates/v4/integration/ObjectPageJourney.js

@@ -60,13 +60,15 @@ sap.ui.define([
         });
 <% } -%>
 
-<% if (bodySections?.length > 0) { -%>
+<% if (bodySections?.length > 0 && !isStandalone) { -%>
         opaTest("Check body sections of the Object Page", function (Given, When, Then) {
 <% if (bodySections?.length > 1) { -%>
             Then.onThe<%- name%>.iCheckNumberOfSections(<%- bodySections.length %>);
 <% } -%>
 <% bodySections.forEach(function(section) { -%>
+<% if (bodySections.length > 1) { -%>
             When.onThe<%- name%>.iPressSectionIconTabFilterButton("<%- section.id %>");
+<% } -%>
             Then.onThe<%- name%>.iCheckSection({ section: "<%- section.id %>" });
 <% if (section?.subSections?.length > 0) { -%>
 <% section.subSections.forEach(function(subSection) { -%>