@sap-ux/ui5-test-writer 1.1.13 → 1.2.1

package/dist/utils/opaQUnitUtils.js

@@ -5,34 +5,15 @@
  */
 import { join } from 'node:path';
 import { readHashFromFlpSandbox } from './flpSandboxUtils.js';
-import { getAllUi5YamlFileNames, readUi5Yaml, FileName } from '@sap-ux/project-access';
-import { DotFileExtension } from '../types.js';
+import { MAX_FILE_CONTENT_LENGTH } from './fileWritingUtils.js';
+import { t } from '../i18n.js';
 /** Relative path from the test output directory to opaTests.qunit.js */
 const OPA_QUNIT_FILE = 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.
+ * Captures the body of the `sap.ui.require([...], function ...)` array (group 1).
+ * The `d` flag exposes `match.indices` for precise splice positions.
  */
 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;
-/**
- * Escapes regex metacharacters in a string so it can be safely embedded in a `RegExp` pattern.
- *
- * @param value - the string to escape
- * @returns the escaped string
- */
-const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`);
 /**
  * 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.
@@ -80,7 +61,8 @@ export function spliceModulesIntoQUnitContent(fileContent, moduleNames) {
     const commaFix = needsComma ? ',' : '';
     const trailingWhitespace = fileContent.slice(trimmedBefore.length, insertPosition);
     const after = fileContent.slice(insertPosition);
-    return `${trimmedBefore}${commaFix}\n${newLines}\n${trailingWhitespace}${after}`;
+    const separator = trailingWhitespace.length > 0 ? '' : '\n';
+    return `${trimmedBefore}${commaFix}\n${newLines}${separator}${trailingWhitespace}${after}`;
 }
 /**
  * Regex to extract the html launch target from a `launchUrl` line of the form:
@@ -89,7 +71,7 @@ export function spliceModulesIntoQUnitContent(fileContent, moduleNames) {
  */
 const LAUNCH_URL_REGEX = /\.toUrl\s*\([^)]+\)\s*\+\s*'([^']+)'/;
 /**
- * Reads opaTests.qunit.js from webapp/test/integration_old and extracts the html
+ * Reads opaTests.qunit.js from webapp/test/integration 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.
@@ -100,10 +82,10 @@ const LAUNCH_URL_REGEX = /\.toUrl\s*\([^)]+\)\s*\+\s*'([^']+)'/;
  */
 export function readHtmlTargetFromQUnitJs(testPath, fs) {
     try {
-        const integrationOldDir = join(testPath, 'integration_old');
-        let filePath = join(integrationOldDir, 'opaTests.qunit.js');
+        const integrationDir = join(testPath, 'integration');
+        let filePath = join(integrationDir, 'opaTests.qunit.js');
         if (!fs.exists(filePath)) {
-            filePath = join(integrationOldDir, 'Opa.qunit.js');
+            filePath = join(integrationDir, 'Opa.qunit.js');
         }
         const content = fs.read(filePath);
         const match = LAUNCH_URL_REGEX.exec(content);
@@ -125,27 +107,6 @@ export function readHtmlTargetFromQUnitJs(testPath, fs) {
         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
- */
-export async function addIntegrationOldToGitignore(basePath, fs) {
-    const filePath = 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.
@@ -155,342 +116,27 @@ export async function addIntegrationOldToGitignore(basePath, fs) {
  * @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
+ * @param log - optional logger instance used to surface warnings when the file
+ *   cannot be read or updated
+ * @returns true if the file was written, false otherwise
  */
-export function addPathsToQUnitJs(filePaths, projectPath, fs) {
+export function addPathsToQUnitJs(filePaths, projectPath, fs, log) {
     try {
         const filePath = 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
-    }
-}
-/**
- * Builds the relative path from the test output directory to the JourneyRunner file.
- *
- * @param dotFileExtension - file extension ('.ts' or '.js')
- * @returns the relative path
- */
-const getJourneyRunnerFilePath = (dotFileExtension) => join('integration', 'pages', `JourneyRunner${dotFileExtension}`);
-/**
- * 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 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;
-}
-/**
- * Filters the input page list down to those whose `Custom<targetKey>` import line is not yet
- * present in the existing JourneyRunner.ts content.
- *
- * @param fileContent - the existing JourneyRunner.ts content
- * @param pages - the candidate pages to splice in
- * @returns the subset of pages that need to be added
- */
-function findPagesToAdd(fileContent, pages) {
-    return pages.filter((page) => {
-        const importPattern = new RegExp(String.raw `from\s+"\./${escapeRegex(page.targetKey)}"`);
-        return !importPattern.test(fileContent);
-    });
-}
-/**
- * Returns the offset of the character immediately after the last `import ... from "..."` line in
- * the given content, or -1 if no import line is found.
- *
- * Uses `\b` word boundaries (zero-width) around `import` and `from` so the `[^\n]*?` middle
- * quantifier doesn't sit next to another quantifier that could match the same characters. This
- * avoids the consecutive-overlapping-quantifier shape that triggers catastrophic backtracking.
- *
- * @param content - the file content to scan
- * @returns the index immediately after the last import line, or -1 if none found
- */
-function findLastImportEnd(content) {
-    const importLineRegex = /^import\b[^\n]*?\bfrom[ \t]+["'][^"']+["'];?[ \t]*$/gm;
-    let lastImportEnd = -1;
-    let importMatch;
-    while ((importMatch = importLineRegex.exec(content)) !== null) {
-        lastImportEnd = importMatch.index + importMatch[0].length;
-    }
-    return lastImportEnd;
-}
-/**
- * Walks forward from the opening `{` of a `pages: { ... }` object literal, counting braces, and
- * returns the index of the matching closing `}`. The pages object now contains nested `{}` (the
- * page-definition object) so a regex with `[^}]*` would stop at the first inner closing brace.
- *
- * @param content - the file content
- * @param openBraceIdx - the index of the `{` that opens the pages object
- * @returns the index of the matching closing `}` (or `content.length` if not found)
- */
-function findMatchingClosingBrace(content, openBraceIdx) {
-    let depth = 1;
-    let i = openBraceIdx + 1;
-    while (i < content.length && depth > 0) {
-        const ch = content[i];
-        if (ch === '{') {
-            depth++;
-        }
-        else if (ch === '}') {
-            depth--;
-        }
-        if (depth === 0) {
-            break;
+        if (content.length > MAX_FILE_CONTENT_LENGTH) {
+            log?.warn(t('warn.cannotUpdateOpaTestsQunit'));
+            return false;
         }
-        i++;
-    }
-    return i;
-}
-/**
- * Builds the source-code block for a single new entry in the `pages: { ... }` object literal.
- *
- * @param page - the page to render
- * @param pageIndent - leading whitespace for the entry's outer line
- * @param innerIndent - leading whitespace for the entry's nested lines
- * @returns the multi-line source block
- */
-function buildPageEntry(page, pageIndent, innerIndent) {
-    const fw = page.template ?? 'ListReport';
-    return [
-        `${pageIndent}onThe${page.targetKey}: new ${fw}(`,
-        `${innerIndent}{`,
-        `${innerIndent}    appId: "${page.appID ?? ''}",`,
-        `${innerIndent}    componentId: "${page.componentID ?? ''}",`,
-        `${innerIndent}    entitySet: "${page.entitySet ?? ''}",`,
-        `${innerIndent}    contextPath: "${page.contextPath ?? ''}"`,
-        `${innerIndent}},`,
-        `${innerIndent}Custom${page.targetKey}`,
-        `${pageIndent})`
-    ].join('\n');
-}
-/**
- * Inserts the given import lines after the last existing `import` line in `content`. If `content`
- * has no `import` lines, returns it unchanged.
- *
- * @param content - the file content
- * @param newImportLines - the import lines to insert (each should NOT include a leading newline)
- * @returns the updated content
- */
-function insertAfterLastImport(content, newImportLines) {
-    if (newImportLines.length === 0) {
-        return content;
-    }
-    const lastImportEnd = findLastImportEnd(content);
-    if (lastImportEnd < 0) {
-        return content;
-    }
-    const newImports = newImportLines.map((line) => `\n${line}`).join('');
-    return `${content.slice(0, lastImportEnd)}${newImports}${content.slice(lastImportEnd)}`;
-}
-/**
- * Inserts the given new page entries inside the `pages: { ... }` object literal of `content`. If
- * `content` has no `pages: {` block, returns it unchanged.
- *
- * @param content - the file content
- * @param toAdd - the pages to add
- * @returns the updated content
- */
-function insertIntoPagesObject(content, toAdd) {
-    const pagesStartMatch = /pages\s*:\s*\{/.exec(content);
-    if (!pagesStartMatch) {
-        return content;
-    }
-    const openBraceIdx = content.indexOf('{', pagesStartMatch.index);
-    const pagesBodyEnd = findMatchingClosingBrace(content, openBraceIdx);
-    const pagesBody = content.slice(openBraceIdx + 1, pagesBodyEnd);
-    // Detect indentation from the first existing page entry
-    const pageIndentMatch = /^([ \t]+)on/m.exec(pagesBody);
-    const pageIndent = pageIndentMatch ? pageIndentMatch[1] : '        ';
-    const innerIndent = pageIndent + '    ';
-    const newPageEntries = toAdd.map((page) => buildPageEntry(page, pageIndent, innerIndent)).join(',\n');
-    // Ensure the last existing entry ends with a comma before we insert after it.
-    const trimmedPagesEnd = content.slice(0, pagesBodyEnd).trimEnd();
-    const needsComma = !trimmedPagesEnd.endsWith(',') && !trimmedPagesEnd.endsWith('{');
-    const commaFix = needsComma ? ',' : '';
-    const trailingWhitespace = content.slice(trimmedPagesEnd.length, pagesBodyEnd);
-    return `${trimmedPagesEnd}${commaFix}\n${newPageEntries}${trailingWhitespace}${content.slice(pagesBodyEnd)}`;
-}
-/**
- * Splices new page entries into an existing TypeScript JourneyRunner.ts:
- * - adds a default-import line after the last existing page import
- * - adds an entry inside the `pages: { ... }` object literal
- *
- * Pages already present (detected by their import line) 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.ts file
- * @param pages - pages to add
- * @returns the updated file content, or the original content unchanged if nothing was added
- */
-export function splicePageIntoJourneyRunnerTs(fileContent, pages) {
-    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
-        return fileContent;
-    }
-    const toAdd = findPagesToAdd(fileContent, pages);
-    if (toAdd.length === 0) {
-        return fileContent;
-    }
-    // Determine which framework imports (ListReport / ObjectPage) are missing and need to be added.
-    const frameworkTemplates = Array.from(new Set(toAdd.map((page) => page.template).filter((t) => Boolean(t))));
-    const missingFrameworkImports = frameworkTemplates.filter((tpl) => !fileContent.includes(`from "sap/fe/test/${tpl}"`));
-    const newImportLines = [
-        ...missingFrameworkImports.map((tpl) => `import ${tpl} from "sap/fe/test/${tpl}";`),
-        ...toAdd.map((page) => `import Custom${page.targetKey} from "./${page.targetKey}";`)
-    ];
-    const withImports = insertAfterLastImport(fileContent, newImportLines);
-    return insertIntoPagesObject(withImports, toAdd);
-}
-/**
- * Reads JourneyRunner from the project, adds new page entries, and writes the updated
- * content back. Pages already present are skipped. Both AMD (`.js`) and ES module
- * (`.ts`) variants are supported and dispatched on `dotFileExtension`.
- *
- * @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
- * @param dotFileExtension - file extension of the JourneyRunner ('.ts' or '.js'); defaults to '.js'
- */
-export function addPagesToJourneyRunner(pages, testOutDirPath, fs, dotFileExtension = DotFileExtension.JS) {
-    if (pages.length === 0) {
-        return;
-    }
-    try {
-        const filePath = join(testOutDirPath, getJourneyRunnerFilePath(dotFileExtension));
-        const content = fs.read(filePath);
-        const splice = dotFileExtension === DotFileExtension.TS ? splicePageIntoJourneyRunnerTs : splicePageIntoJourneyRunner;
-        const updated = splice(content, pages);
+        const updated = spliceModulesIntoQUnitContent(content, filePaths);
         if (updated !== content) {
             fs.write(filePath, updated);
+            return true;
         }
     }
     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
- */
-export async function hasVirtualOPA5(basePath) {
-    const yamlFileNames = await getAllUi5YamlFileNames(basePath);
-    for (const fileName of yamlFileNames) {
-        try {
-            const ui5Config = await 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
-        }
+        log?.warn(t('warn.cannotUpdateOpaTestsQunit'));
     }
     return false;
 }
-/**
- * Updates the fiori-tools-preview middleware in ui5-mock.yaml to support virtual OPA test endpoints.
- * Adds test framework entries to ui5-mock.yaml.
- *
- * @param basePath - the absolute target path of the application
- * @param testFrameworks - the test framework entries to add to ui5-mock.yaml
- * @param fs - the memfs editor instance
- */
-export async function addVirtualTestConfig(basePath, testFrameworks, fs) {
-    const yamlPath = join(basePath, FileName.Ui5MockYaml);
-    if (!fs.exists(yamlPath)) {
-        return;
-    }
-    const yamlConfig = await readUi5Yaml(basePath, FileName.Ui5MockYaml, fs);
-    const previewMiddleware = yamlConfig.findCustomMiddleware('fiori-tools-preview');
-    if (previewMiddleware?.configuration && !previewMiddleware.configuration.test?.length) {
-        previewMiddleware.configuration.test = [...testFrameworks];
-        yamlConfig.updateCustomMiddleware(previewMiddleware);
-        fs.write(yamlPath, yamlConfig.toString());
-    }
-}
 //# sourceMappingURL=opaQUnitUtils.js.map

package/dist/utils/virtualOpaUtils.d.ts

@@ -0,0 +1,21 @@
+import type { Editor } from 'mem-fs-editor';
+import type { TestConfig as PreviewMiddlewareTestConfig } from '@sap-ux/preview-middleware';
+/**
+ * Returns true if any UI5 yaml file in the project has a preview middleware
+ * (`fiori-tools-preview` or `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>;
+/**
+ * Updates the fiori-tools-preview middleware in ui5-mock.yaml to support virtual OPA test endpoints.
+ * Adds test framework entries to ui5-mock.yaml.
+ *
+ * @param basePath - the absolute target path of the application
+ * @param testFrameworks - the test framework entries to add to ui5-mock.yaml
+ * @param fs - the memfs editor instance
+ */
+export declare function addVirtualTestConfig(basePath: string, testFrameworks: PreviewMiddlewareTestConfig[], fs: Editor): Promise<void>;
+//# sourceMappingURL=virtualOpaUtils.d.ts.map

package/dist/utils/virtualOpaUtils.js

@@ -0,0 +1,51 @@
+import { join } from 'node:path';
+import { getAllUi5YamlFileNames, readUi5Yaml, FileName } from '@sap-ux/project-access';
+/** Custom middleware names that may carry a virtual-test config. */
+const PREVIEW_MIDDLEWARE_NAMES = ['fiori-tools-preview', 'preview-middleware'];
+/**
+ * Returns true if any UI5 yaml file in the project has a preview middleware
+ * (`fiori-tools-preview` or `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 async function hasVirtualOPA5(basePath) {
+    const yamlFileNames = await getAllUi5YamlFileNames(basePath);
+    for (const fileName of yamlFileNames) {
+        try {
+            const ui5Config = await readUi5Yaml(basePath, fileName);
+            const previewMiddleware = PREVIEW_MIDDLEWARE_NAMES.map((name) => ui5Config.findCustomMiddleware(name)).find((middleware) => middleware !== undefined);
+            const testEntries = previewMiddleware?.configuration?.test;
+            if (testEntries?.some((entry) => entry.framework === 'OPA5')) {
+                return true;
+            }
+        }
+        catch {
+            // Skip yaml files that cannot be read
+        }
+    }
+    return false;
+}
+/**
+ * Updates the fiori-tools-preview middleware in ui5-mock.yaml to support virtual OPA test endpoints.
+ * Adds test framework entries to ui5-mock.yaml.
+ *
+ * @param basePath - the absolute target path of the application
+ * @param testFrameworks - the test framework entries to add to ui5-mock.yaml
+ * @param fs - the memfs editor instance
+ */
+export async function addVirtualTestConfig(basePath, testFrameworks, fs) {
+    const yamlPath = join(basePath, FileName.Ui5MockYaml);
+    if (!fs.exists(yamlPath)) {
+        return;
+    }
+    const yamlConfig = await readUi5Yaml(basePath, FileName.Ui5MockYaml, fs);
+    const previewMiddleware = yamlConfig.findCustomMiddleware('fiori-tools-preview');
+    if (previewMiddleware?.configuration && !previewMiddleware.configuration.test?.length) {
+        previewMiddleware.configuration.test = [...testFrameworks];
+        yamlConfig.updateCustomMiddleware(previewMiddleware);
+        fs.write(yamlPath, yamlConfig.toString());
+    }
+}
+//# sourceMappingURL=virtualOpaUtils.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sap-ux/ui5-test-writer",
   "description": "SAP UI5 tests writer",
-  "version": "1.1.13",
+  "version": "1.2.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/SAP/open-ux-tools.git",
@@ -57,6 +57,7 @@
     "lint:fix": "eslint --fix",
     "test": "cross-env NODE_OPTIONS='--experimental-vm-modules' jest --ci --forceExit --detectOpenHandles --colors",
     "test-u": "cross-env NODE_OPTIONS='--experimental-vm-modules' jest --ci --forceExit --detectOpenHandles --colors -u",
+    "run-generator": "npm run build && npx ts-node --esm test/manual/run-generator.ts",
     "link": "pnpm link --global",
     "unlink": "pnpm unlink --global"
   }

package/templates/v4/integration/FPMJourney.js

@@ -27,14 +27,14 @@ sap.ui.define([
         opaTest("Start application", function (Given, When, Then) {
             Given.iStartMyApp();
             <%_ startPages.forEach(function(pageName) { %>
-            Then.onThe<%- pageName %>.iSeeThisPage();
+            Then.onThe<%- pageName %>Generated.iSeeThisPage();
             <%_ if (filterBarItems && filterBarItems.length > 0) { -%>
                 <%_ filterBarItems.forEach(function(item) { _%>
-            Then.onThe<%- pageName%>.onFilterBar().iCheckFilterField("<%- item %>");
+            Then.onThe<%- pageName%>Generated.onFilterBar().iCheckFilterField("<%- item %>");
                 <%_ }); -%>
             <%_ } -%>
             <%_ if (tableColumns && Object.keys(tableColumns).length > 0) { _%>
-            Then.onThe<%- pageName %>.onTable().iCheckColumns(<%- Object.keys(tableColumns).length %>, <%- JSON.stringify(tableColumns) %>);
+            Then.onThe<%- pageName %>Generated.onTable().iCheckColumns(<%- Object.keys(tableColumns).length %>, <%- JSON.stringify(tableColumns) %>);
             <%_ } %>
             <%_ }); -%>
         });

package/templates/v4/integration/FirstJourney.ts

@@ -7,19 +7,19 @@ function journey() {
 
     opaTest("Start application", function (Given: Given, _When: When<% if (startLR) { %>, Then: Then<% } else { %>, _Then: Then<% } %>) {
         Given.iStartMyApp();
-        <% if (startLR) { %>Then.onThe<%- startLR %>.iSeeThisPage();<%} %>
+        <% if (startLR) { %>Then.onThe<%- startLR %>Generated.iSeeThisPage();<%} %>
     });
 
 <% if (startLR) { %>
     opaTest("Navigate to ObjectPage", function (_Given: Given, When: When, Then: Then) {
         // Note: this test will fail if the ListReport page doesn't show any data
         <% if (!hideFilterBar) { %>
-        When.onThe<%- startLR%>.onFilterBar().iExecuteSearch();
+        When.onThe<%- startLR%>Generated.onFilterBar().iExecuteSearch();
         <%} %>
-        Then.onThe<%- startLR%>.onTable("").iCheckRows();
+        Then.onThe<%- startLR%>Generated.onTable("").iCheckRows();
 <% if (navigatedOP) { %>
-        When.onThe<%- startLR%>.onTable("").iPressRow(0);
-        Then.onThe<%- navigatedOP%>.iSeeThisPage();
+        When.onThe<%- startLR%>Generated.onTable("").iPressRow(0);
+        Then.onThe<%- navigatedOP%>Generated.iSeeThisPage();
 <%} %>
     });
 <%} %>