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

package/dist/utils/opaJourneyTypesUtils.js

@@ -0,0 +1,167 @@
+import { join } from 'node:path';
+import { t } from '../i18n.js';
+import { MAX_FILE_CONTENT_LENGTH, escapeRegex, findBracedBlock, insertAfterLastImport } from './fileWritingUtils.js';
+/** Relative path from the test output directory to OpaJourneyTypes.d.ts */
+const OPA_JOURNEY_TYPES_FILE = join('integration', 'types', 'OpaJourneyTypes.d.ts');
+/** Frameworks the splicer knows how to render entries for. */
+const SUPPORTED_FRAMEWORKS = new Set(['ListReport', 'ObjectPage']);
+/**
+ * Filter `pages` down to those whose generator-owned custom-actions/assertions import
+ * is not yet present (matched against `../pages/<fileName>` with the `.gen` suffix).
+ *
+ * @param fileContent - the existing OpaJourneyTypes.d.ts content
+ * @param pages - 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+"\.\./pages/${escapeRegex(page.fileName)}"`);
+        return !importPattern.test(fileContent);
+    });
+}
+/**
+ * Build the framework-import lines (ListReport / ObjectPage / TemplatePage) that need to be
+ * added to the file, skipping any already imported.
+ *
+ * @param fileContent - the existing OpaJourneyTypes.d.ts content
+ * @param pages - the new pages being added
+ * @returns the list of framework-import lines to insert
+ */
+function buildMissingFrameworkImports(fileContent, pages) {
+    const lines = [];
+    const templates = new Set(pages.map((page) => page.template).filter((template) => Boolean(template)));
+    if (templates.has('ListReport') && !fileContent.includes('from "sap/fe/test/ListReport"')) {
+        lines.push(`import type { actions as ListReportActions, assertions as ListReportAssertions } from "sap/fe/test/ListReport";`);
+    }
+    if (templates.has('ObjectPage') && !fileContent.includes('from "sap/fe/test/ObjectPage"')) {
+        lines.push(`import type { actions as ObjectPageActions, assertions as ObjectPageAssertions } from "sap/fe/test/ObjectPage";`);
+    }
+    if ((templates.has('ListReport') || templates.has('ObjectPage')) &&
+        !fileContent.includes('from "sap/fe/test/TemplatePage"')) {
+        lines.push(`import type { actions as TemplatePageActions, assertions as TemplatePageAssertions } from "sap/fe/test/TemplatePage";`);
+    }
+    return lines;
+}
+/**
+ * Build the per-page import line for a page's generator-owned custom actions/assertions.
+ *
+ * @param page - the page to render
+ * @returns the import line
+ */
+function buildPageCustomImportLine(page) {
+    return (`import type { actions as ${page.targetKey}GeneratedCustomActions, ` +
+        `assertions as ${page.targetKey}GeneratedCustomAssertions } from "../pages/${page.fileName}";`);
+}
+/**
+ * Build the new entry to insert into the `When`/`Then` type union for a single page.
+ *
+ * @param page - the page to render
+ * @param mode - whether to render the entry for the `When` (actions) or `Then` (assertions) union
+ * @param indent - leading whitespace for the new line
+ * @returns the source line, or undefined if the page's framework is not supported
+ */
+function buildPageUnionEntry(page, mode, indent) {
+    if (!page.template || !SUPPORTED_FRAMEWORKS.has(page.template)) {
+        return undefined;
+    }
+    const frameworkSuffix = mode === 'actions' ? 'Actions' : 'Assertions';
+    const customSuffix = mode === 'actions' ? 'CustomActions' : 'CustomAssertions';
+    return (`${indent}onThe${page.targetKey}Generated: Opa5 & ${page.template}${frameworkSuffix} & TemplatePage${frameworkSuffix} & ` +
+        `typeof ${page.targetKey}Generated${customSuffix};`);
+}
+/**
+ * Insert new `onThe<targetKey>Generated` member lines into the named exported type union,
+ * preserving the indentation of the first existing member.
+ *
+ * @param content - the file content
+ * @param exportName - the type union to update (`When` or `Then`)
+ * @param newEntries - the new union member lines to insert
+ * @returns the updated content (or unchanged if the type union or its closing brace can't be found)
+ */
+function insertIntoTypeUnion(content, exportName, newEntries) {
+    if (newEntries.length === 0) {
+        return content;
+    }
+    const block = findBracedBlock(content, new RegExp(String.raw `export\s+type\s+${exportName}\b[^=]*=\s*[^{]*\{`));
+    if (!block) {
+        return content;
+    }
+    const { openBraceIdx, closeBraceIdx } = block;
+    const body = content.slice(openBraceIdx + 1, closeBraceIdx);
+    const indentMatch = /^([ \t]+)\S/m.exec(body);
+    const indent = indentMatch ? indentMatch[1] : '    ';
+    const insertion = newEntries.map((line) => line.replace(/^\s*/, indent)).join('\n');
+    // Insert before the closing brace, with a leading newline so the new lines sit on their own.
+    const head = content.slice(0, closeBraceIdx);
+    const tail = content.slice(closeBraceIdx);
+    return `${head.trimEnd()}\n${insertion}\n${tail}`;
+}
+/**
+ * Splice new journey entries into an existing `OpaJourneyTypes.d.ts`: framework imports,
+ * per-page custom actions/assertions imports, and `onThe<targetKey>Generated` members in
+ * the `When` and `Then` unions. Pages already imported are skipped; all other content is preserved.
+ *
+ * @param fileContent - the full content of the OpaJourneyTypes.d.ts file
+ * @param pages - pages to add
+ * @returns the updated file content, or the original content unchanged if nothing was added
+ */
+export function spliceJourneysIntoOpaJourneyTypes(fileContent, pages) {
+    if (fileContent.length > MAX_FILE_CONTENT_LENGTH) {
+        return fileContent;
+    }
+    const toAdd = findPagesToAdd(fileContent, pages);
+    if (toAdd.length === 0) {
+        return fileContent;
+    }
+    const newImportLines = [
+        ...buildMissingFrameworkImports(fileContent, toAdd),
+        ...toAdd
+            .filter((page) => page.template && SUPPORTED_FRAMEWORKS.has(page.template))
+            .map((page) => buildPageCustomImportLine(page))
+    ];
+    const whenEntries = toAdd
+        .map((page) => buildPageUnionEntry(page, 'actions', ''))
+        .filter((entry) => entry !== undefined);
+    const thenEntries = toAdd
+        .map((page) => buildPageUnionEntry(page, 'assertions', ''))
+        .filter((entry) => entry !== undefined);
+    let result = insertAfterLastImport(fileContent, newImportLines);
+    result = insertIntoTypeUnion(result, 'When', whenEntries);
+    result = insertIntoTypeUnion(result, 'Then', thenEntries);
+    return result;
+}
+/**
+ * Read `OpaJourneyTypes.d.ts` from the project, splice entries for new pages, and write
+ * the result back. Pages already present are skipped. If the file does not exist or
+ * cannot be read, logs a warning and returns without writing.
+ *
+ * @param pages - pages whose journeys should be reflected in OpaJourneyTypes.d.ts
+ * @param testOutDirPath - 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 addJourneysToOpaJourneyTypes(pages, testOutDirPath, fs, log) {
+    if (pages.length === 0) {
+        return false;
+    }
+    try {
+        const filePath = join(testOutDirPath, OPA_JOURNEY_TYPES_FILE);
+        const content = fs.read(filePath);
+        if (content.length > MAX_FILE_CONTENT_LENGTH) {
+            log?.warn(t('warn.cannotUpdateOpaJourneyTypes'));
+            return false;
+        }
+        const updated = spliceJourneysIntoOpaJourneyTypes(content, pages);
+        if (updated !== content) {
+            fs.write(filePath, updated);
+            return true;
+        }
+    }
+    catch {
+        log?.warn(t('warn.cannotUpdateOpaJourneyTypes'));
+    }
+    return false;
+}
+//# sourceMappingURL=opaJourneyTypesUtils.js.map

package/dist/utils/opaQUnitUtils.d.ts

@@ -4,8 +4,7 @@
  * all other content (formatting, comments, whitespace) is preserved exactly.
  */
 import type { Editor } from 'mem-fs-editor';
-import { DotFileExtension } from '../types.js';
-import type { TestConfig as PreviewMiddlewareTestConfig } from '@sap-ux/preview-middleware';
+import type { Logger } from '@sap-ux/logger';
 /**
  * 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.
@@ -19,7 +18,7 @@ import type { TestConfig as PreviewMiddlewareTestConfig } from '@sap-ux/preview-
  */
 export declare function spliceModulesIntoQUnitContent(fileContent: string, moduleNames: string[]): string;
 /**
- * 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.
@@ -29,14 +28,6 @@ export declare function spliceModulesIntoQUnitContent(fileContent: string, modul
  * @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.
@@ -46,86 +37,9 @@ export declare function addIntegrationOldToGitignore(basePath: string, fs: Edito
  * @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 declare function addPathsToQUnitJs(filePaths: string[], projectPath: string, fs: Editor): void;
-/**
- * Page entry to splice into an existing JourneyRunner.js / JourneyRunner.ts.
- */
-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;
-    /** The framework page template (`'ListReport'` or `'ObjectPage'`); used by the TS splicer to construct `new <FW>(definition, Custom<Page>)`. */
-    template?: string;
-    /** The app id (sap.app.id from the manifest); only needed by the TS splicer. */
-    appID?: string;
-    /** The component id (defined in the target section); only needed by the TS splicer. */
-    componentID?: string;
-    /** The entity set name (if the page uses an entitySet rather than a contextPath); only needed by the TS splicer. */
-    entitySet?: string;
-    /** The context path (if the page uses a contextPath rather than an entitySet); only needed by the TS splicer. */
-    contextPath?: 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;
-/**
- * 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 declare function splicePageIntoJourneyRunnerTs(fileContent: string, pages: JourneyRunnerPage[]): string;
-/**
- * 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 declare function addPagesToJourneyRunner(pages: JourneyRunnerPage[], testOutDirPath: string, fs: Editor, dotFileExtension?: DotFileExtension): 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>;
-/**
- * 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>;
+export declare function addPathsToQUnitJs(filePaths: string[], projectPath: string, fs: Editor, log?: Logger): boolean;
 //# sourceMappingURL=opaQUnitUtils.d.ts.map