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

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

@@ -7,7 +7,10 @@ import { SupportedPageTypes, ValidationError, DotFileExtension } from './types.j
 import { t } from './i18n.js';
 import { FileName, DirName, getWebappPath, updatePackageScript } from '@sap-ux/project-access';
 import { getAppFeatures } from './utils/modelUtils.js';
-import { addIntegrationOldToGitignore, addPathsToQUnitJs, addPagesToJourneyRunner, hasVirtualOPA5, readHtmlTargetFromQUnitJs, addVirtualTestConfig } from './utils/opaQUnitUtils.js';
+import { addPathsToQUnitJs, readHtmlTargetFromQUnitJs } from './utils/opaQUnitUtils.js';
+import { addPagesToJourneyRunner } from './utils/journeyRunnerUtils.js';
+import { hasVirtualOPA5, addVirtualTestConfig } from './utils/virtualOpaUtils.js';
+import { addJourneysToOpaJourneyTypes } from './utils/opaJourneyTypesUtils.js';
 import { getPackageScripts } from '@sap-ux/fiori-generator-shared';
 import { readHashFromFlpSandbox } from './utils/flpSandboxUtils.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -51,77 +54,203 @@ export async function generateOPAFiles(basePath, options, metadata, fs, log, sta
     };
     const writeContext = {
         config,
+        basePath,
+        rootCommonTemplateDirPath,
         rootV4TemplateDirPath,
         testOutDirPath,
         editor,
+        log,
         journeyParams,
-        dotFileExtension
+        dotFileExtension,
+        modifiedFiles: []
     };
-    // The active context is the one used to actually emit files. In standalone mode without an
-    // existing JourneyRunner it is replaced with the resolved standalone context (which may
-    // override fields like `htmlTarget`); otherwise it stays as the original `writeContext`.
-    let activeContext = writeContext;
     if (standalone) {
-        const hasJourneyRunner = existsSync(join(testOutDirPath, 'integration', 'pages', `JourneyRunner${dotFileExtension}`));
-        const virtualOPA5Configured = await hasVirtualOPA5(basePath);
-        if (hasJourneyRunner) {
-            writeJourneyFiles(appFeatures, writeContext, true, true, virtualOPA5Configured);
-        }
-        else {
-            activeContext = await resolveStandaloneWriteContext(basePath, testOutDirPath, writeContext, editor);
-            if (!virtualOPA5Configured) {
-                writeCommonAndPageFiles(activeContext, rootCommonTemplateDirPath);
-            }
-            writeJourneyFiles(appFeatures, activeContext, true, hasJourneyRunner, virtualOPA5Configured);
-        }
+        await generateOPAFilesForExistingApp(writeContext, appFeatures);
     }
     else {
-        const useVirtualPreviewEndpoints = options.useVirtualPreviewEndpoints ?? false;
-        writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, useVirtualPreviewEndpoints);
-        writeJourneyFiles(appFeatures, writeContext, false, false, useVirtualPreviewEndpoints);
-        if (useVirtualPreviewEndpoints) {
-            await addVirtualTestConfig(basePath, [{ framework: 'OPA5', path: '/test/integration/opaTests.qunit.html' }, { framework: 'Testsuite' }], editor);
-        }
-    }
-    if (enableTypeScript) {
-        writeOpaJourneyTypes(activeContext);
+        await generateOPAFilesForNewApp(writeContext, appFeatures);
     }
     return editor;
 }
 /**
- * Resolves the write context for standalone mode when no JourneyRunner.js exists yet.
- * Moves any existing integration folder to integration_old, or adds the int-test script
- * and resolves the htmlTarget from flpSandbox.html if present.
+ * Generate OPA test files for an existing Fiori elements for OData V4 application.
  *
- * @param basePath - the absolute target path of the application
- * @param testOutDirPath - output test directory (.../webapp/test)
- * @param writeContext - shared write context to base the resolved context on
- * @param editor - a reference to a mem-fs editor
- * @returns a new WriteContext with the resolved htmlTarget
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param appFeatures - object containing feature data for list report, object pages, and FPM, used for generating the journey files
  */
-async function resolveStandaloneWriteContext(basePath, testOutDirPath, writeContext, editor) {
-    const { config } = writeContext;
-    let htmlTarget = readHtmlTargetFromQUnitJs(testOutDirPath, editor) ?? config.htmlTarget;
-    if (existsSync(join(testOutDirPath, 'integration'))) {
-        editor.move(join(testOutDirPath, 'integration', '**'), join(testOutDirPath, 'integration_old'));
-        await addIntegrationOldToGitignore(basePath, editor);
+async function generateOPAFilesForExistingApp(writeContext, appFeatures) {
+    const virtualOPA5Configured = await hasVirtualOPA5(writeContext.basePath);
+    const standaloneWriteContext = await resolveStandaloneWriteContext(writeContext);
+    const generatedPages = writePageFiles(standaloneWriteContext);
+    const generatedJourneys = writeJourneyFiles(appFeatures, standaloneWriteContext);
+    handleJourneyRunner(standaloneWriteContext, generatedPages);
+    if (virtualOPA5Configured) {
+        await addVirtualOpa5Config(standaloneWriteContext);
     }
     else {
-        const hasIntTestScript = checkScriptInPackageJson(editor, basePath, 'int-test');
-        if (!hasIntTestScript) {
-            const script = getPackageScripts({ localOnly: false, addTest: true })['int-test'];
-            if (script) {
-                await updatePackageScript(basePath, 'int-test', script, editor);
+        handleOpaTestsStartupFiles(standaloneWriteContext, generatedJourneys);
+    }
+    if (standaloneWriteContext.dotFileExtension === DotFileExtension.TS) {
+        handleOPAJourneyTypes(standaloneWriteContext, generatedPages);
+    }
+    logGeneratedAndModifiedFiles(standaloneWriteContext, generatedJourneys, generatedPages);
+}
+/**
+ * Generate OPA test files for a newly generated Fiori elements for OData V4 application.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param appFeatures - object containing feature data for list report, object pages, and FPM, used for generating the journey files
+ */
+async function generateOPAFilesForNewApp(writeContext, appFeatures) {
+    const generatedPages = writePageFiles(writeContext);
+    writeJourneyRunner(writeContext);
+    const generatedJourneys = writeJourneyFiles(appFeatures, writeContext);
+    if (writeContext.config.useVirtualPreviewEndpoints) {
+        await addVirtualOpa5Config(writeContext);
+    }
+    else {
+        handleOpaTestsStartupFiles(writeContext, generatedJourneys);
+    }
+    if (writeContext.dotFileExtension === DotFileExtension.TS) {
+        writeOpaJourneyTypes(writeContext);
+    }
+    logGeneratedAndModifiedFiles(writeContext, generatedJourneys, generatedPages);
+}
+/**
+ * Log a summary of all files the generator produced or updated, grouped into journeys, pages,
+ * and other modified files (JourneyRunner, qunit harness, type definitions, etc.).
+ *
+ * @param writeContext - shared write context (provides logger, file extension, and modifiedFiles accumulator)
+ * @param generatedJourneys - feature names for which a `<name>Journey.gen.<ext>` file was written
+ * @param generatedPages - page objects written under `pages/`
+ */
+function logGeneratedAndModifiedFiles(writeContext, generatedJourneys, generatedPages) {
+    const { log, dotFileExtension, modifiedFiles, incompatibleTestSetup } = writeContext;
+    if (!log?.info) {
+        return;
+    }
+    logGeneratedJourneyFiles(log, generatedJourneys, dotFileExtension);
+    logGeneratedPageFiles(log, generatedPages, dotFileExtension);
+    logModifiedFiles(log, modifiedFiles);
+    // In an incompatible existing setup, the qunit/testsuite files are not touched, so the
+    // generated `.gen` Journeys/Pages must be wired in by the app owner.
+    if (incompatibleTestSetup && (generatedJourneys.length > 0 || generatedPages.length > 0)) {
+        log.info(t('info.manualIntegrationRequired'));
+    }
+}
+/**
+ * Log the generated journey files (one per line) under a "Generated Journeys:" heading.
+ *
+ * @param log - logger instance to use for logging
+ * @param generatedJourneys - feature names for which a `<name>Journey.gen.<ext>` file was written
+ * @param dotFileExtension - the journey file extension (`.js` or `.ts`)
+ */
+function logGeneratedJourneyFiles(log, generatedJourneys, dotFileExtension) {
+    if (generatedJourneys.length === 0) {
+        return;
+    }
+    const lines = generatedJourneys.map((journey) => `  ${journey}Journey.gen${dotFileExtension}`);
+    log.info?.(['Generated Journeys:', ...lines].join('\n'));
+}
+/**
+ * Log the generated page files (one per line) under a "Generated Pages:" heading.
+ *
+ * @param log - logger instance to use for logging
+ * @param generatedPages - page objects written under `pages/`
+ * @param dotFileExtension - the page file extension (`.js` or `.ts`)
+ */
+function logGeneratedPageFiles(log, generatedPages, dotFileExtension) {
+    if (generatedPages.length === 0) {
+        return;
+    }
+    const lines = generatedPages.map((page) => `  pages/${page.fileName}${dotFileExtension}`);
+    log.info?.(['Generated Pages:', ...lines].join('\n'));
+}
+/**
+ * Log the additional files updated during generation (one per line) under a "Modified files:" heading.
+ *
+ * @param log - logger instance to use for logging
+ * @param modifiedFiles - paths (relative to the test output dir) of files that were written or spliced
+ */
+function logModifiedFiles(log, modifiedFiles) {
+    if (modifiedFiles.length === 0) {
+        return;
+    }
+    const lines = modifiedFiles.map((file) => `  ${file}`);
+    log.info?.(['Modified files:', ...lines].join('\n'));
+}
+/**
+ * Resolve the standalone-mode write context: detect preexisting integration tests and an
+ * incompatible legacy setup, and resolve the htmlTarget from flpSandbox.html if present.
+ *
+ * @param writeContext - shared write context to base the resolved context on
+ * @returns a new WriteContext with the resolved values for the standalone generation
+ */
+async function resolveStandaloneWriteContext(writeContext) {
+    const hasPreexistingTests = existsSync(join(writeContext.testOutDirPath, 'integration'));
+    if (hasPreexistingTests) {
+        return {
+            ...writeContext,
+            hasPreexistingTests: true,
+            incompatibleTestSetup: hasIncompatibleTestSetup(writeContext.testOutDirPath),
+            config: {
+                ...writeContext.config,
+                htmlTarget: readHtmlTargetFromQUnitJs(writeContext.testOutDirPath, writeContext.editor) ??
+                    writeContext.config.htmlTarget
             }
+        };
+    }
+    // app has no integration tests yet
+    return await resolveWriteContextForMissingIntegrationFolder(writeContext);
+}
+/**
+ * Resolve the standalone-mode write context for the case where the integration folder is
+ * missing entirely: there are no OPA tests yet, the int-test package script may need to be
+ * added, and the htmlTarget is resolved from flpSandbox.html if present.
+ *
+ * @param writeContext - shared write context to base the resolved context on
+ * @returns a new WriteContext with the resolved values for the standalone generation
+ */
+async function resolveWriteContextForMissingIntegrationFolder(writeContext) {
+    const hasIntTestScript = checkScriptInPackageJson(writeContext.editor, writeContext.basePath, 'int-test');
+    if (!hasIntTestScript) {
+        const script = getPackageScripts({ localOnly: false, addTest: true })['int-test'];
+        if (script) {
+            await updatePackageScript(writeContext.basePath, 'int-test', script, writeContext.editor);
+            writeContext.modifiedFiles.push('package.json');
         }
-        if (existsSync(join(testOutDirPath, 'flpSandbox.html'))) {
-            const hashFromFlpSandbox = readHashFromFlpSandbox(join('test', 'flpSandbox.html'), await getWebappPath(basePath), editor);
-            if (hashFromFlpSandbox) {
-                htmlTarget = `test/flpSandbox.html#${hashFromFlpSandbox}`;
-            }
+    }
+    let htmlTarget = writeContext.config.htmlTarget;
+    if (existsSync(join(writeContext.testOutDirPath, 'flpSandbox.html'))) {
+        const hashFromFlpSandbox = readHashFromFlpSandbox(join('test', 'flpSandbox.html'), await getWebappPath(writeContext.basePath), writeContext.editor);
+        if (hashFromFlpSandbox) {
+            htmlTarget = `test/flpSandbox.html#${hashFromFlpSandbox}`;
         }
     }
-    return { ...writeContext, config: { ...config, htmlTarget } };
+    return {
+        ...writeContext,
+        hasPreexistingTests: false,
+        config: { ...writeContext.config, htmlTarget }
+    };
+}
+/**
+ * Checks for incompatible test setup — the integration folder exists but no own JourneyRunner.js / .ts file is present.
+ *
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @returns true if the test setup is incompatible, false otherwise
+ */
+function hasIncompatibleTestSetup(testOutDirPath) {
+    return !hasJourneyRunnerFile(testOutDirPath);
+}
+/**
+ * Checks whether the existing test setup contains its own JourneyRunner.js or JourneyRunner.ts file.
+ *
+ * @param testOutDirPath - path to the test output directory (`.../webapp/test`)
+ * @returns true if the JourneyRunner.js or JourneyRunner.ts file exists, false otherwise
+ */
+function hasJourneyRunnerFile(testOutDirPath) {
+    const pagesDir = join(testOutDirPath, 'integration', 'pages');
+    return existsSync(join(pagesDir, 'JourneyRunner.js')) || existsSync(join(pagesDir, 'JourneyRunner.ts'));
 }
 /**
  * Checks whether a script with the given name exists in the package.json.
@@ -217,7 +346,8 @@ function createPageConfig(manifest, targetKey, forcedAppID) {
             targetKey,
             componentID: target.id,
             template: SupportedPageTypes[target.name],
-            isStartup: false
+            isStartup: false,
+            fileName: targetKey + '.gen'
         };
         if (target.options.settings.contextPath) {
             pageConfig.contextPath = target.options.settings.contextPath;
@@ -248,7 +378,8 @@ function createConfig(manifest, options, hideFilterBar) {
         pages: [],
         opaJourneyFileName: options.scriptName ?? 'FirstJourney',
         htmlTarget: options.htmlTarget ?? 'index.html',
-        hideFilterBar
+        hideFilterBar,
+        useVirtualPreviewEndpoints: options.useVirtualPreviewEndpoints ?? false
     };
     // Identify startup targets from the routes
     const appRoutes = (manifest['sap.ui5']?.routing?.routes ?? []);
@@ -319,32 +450,43 @@ function findLROP(pages, manifest) {
     return { pageLR, pageOP };
 }
 /**
- * Writes common test files, page objects, and the first journey file.
+ * Writes the common test files for the Fiori elements app.
  *
  * @param writeContext - shared write context (config, paths, editor, journey params)
- * @param rootCommonTemplateDirPath - template root directory for common files
- * @param useVirtualPreviewEndpoints - when true, testsuite harness files are served virtually; skip writing them to disk
  */
-function writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, useVirtualPreviewEndpoints = false) {
-    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams, dotFileExtension } = writeContext;
+function writeTestsuiteFiles(writeContext) {
     // Common test files (testsuite served virtually when useVirtualPreviewEndpoints is enabled)
-    if (!useVirtualPreviewEndpoints) {
-        editor.copyTpl(join(rootCommonTemplateDirPath), testOutDirPath, 
-        // unit tests are not added for Fiori elements app
-        { appId: config.appID }, undefined, {
-            globOptions: { dot: true }
-        });
-    }
-    config.pages.forEach((page) => {
-        writePageObject(page, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
-    });
-    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `FirstJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${config.opaJourneyFileName}${dotFileExtension}`), { ...journeyParams, appPath: config.appPath }, undefined, {
+    writeContext.editor.copyTpl(join(writeContext.rootCommonTemplateDirPath), writeContext.testOutDirPath, 
+    // unit tests are not added for Fiori elements app
+    { appId: writeContext.config.appID }, undefined, {
         globOptions: { dot: true }
     });
-    // Journey Runner
+}
+/**
+ * Writes common test files, page objects, and the first journey file.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @returns an array of the written page objects with their targetKey and appPath
+ */
+function writePageFiles(writeContext) {
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor } = writeContext;
+    const writtenPages = [];
+    config.pages.forEach((page) => {
+        writtenPages.push(writePageObject(page, rootV4TemplateDirPath, testOutDirPath, editor, writeContext.dotFileExtension));
+    });
+    return writtenPages;
+}
+/**
+ * Writes the JourneyRunner file.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ */
+function writeJourneyRunner(writeContext) {
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension, modifiedFiles } = writeContext;
     editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'pages', `JourneyRunner${dotFileExtension}`), join(testOutDirPath, 'integration', 'pages', `JourneyRunner${dotFileExtension}`), config, undefined, {
         globOptions: { dot: true }
     });
+    modifiedFiles.push(`integration/pages/JourneyRunner${dotFileExtension}`);
 }
 /**
  * Writes the OpaJourneyTypes.d.ts type definition file used by generated TypeScript OPA tests.
@@ -352,89 +494,43 @@ function writeCommonAndPageFiles(writeContext, rootCommonTemplateDirPath, useVir
  * @param writeContext - shared write context (config, paths, editor, journey params)
  */
 function writeOpaJourneyTypes(writeContext) {
-    const { config, rootV4TemplateDirPath, testOutDirPath, editor } = writeContext;
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, modifiedFiles } = writeContext;
     editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'types', 'OpaJourneyTypes.d.ts'), join(testOutDirPath, 'integration', 'types', 'OpaJourneyTypes.d.ts'), config, undefined, {
         globOptions: { dot: true }
     });
-}
-/**
- * Checks whether a page object file already exists for the given feature name.
- * Both `.ts` and `.js` extensions are checked to avoid creating duplicate page objects
- * when regenerating in a different language than the existing tests use.
- * If neither exists, 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
- * @param dotFileExtension - file extension ('.ts' or '.js')
- * @returns JourneyRunnerPage if the page was newly created, undefined otherwise
- */
-function ensurePageExists(featureName, config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension) {
-    const pagesDir = join(testOutDirPath, 'integration', 'pages');
-    if (editor.exists(join(pagesDir, `${featureName}${DotFileExtension.TS}`)) ||
-        editor.exists(join(pagesDir, `${featureName}${DotFileExtension.JS}`))) {
-        return undefined;
-    }
-    const pageConfig = config.pages.find((p) => p.targetKey === featureName);
-    if (pageConfig) {
-        writePageObject(pageConfig, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
-        return {
-            targetKey: featureName,
-            appPath: config.appPath,
-            template: pageConfig.template,
-            appID: config.appID,
-            componentID: pageConfig.componentID,
-            entitySet: pageConfig.entitySet,
-            contextPath: pageConfig.contextPath
-        };
-    }
-    return undefined;
+    modifiedFiles.push('integration/types/OpaJourneyTypes.d.ts');
 }
 /**
  * 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 already exists (standalone upgrade path)
- * @param virtualOPA5Configured - whether virtual OPA5 is configured
+ * @returns an array of feature names for which journey files were generated
  */
-function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRunner = false, virtualOPA5Configured = false) {
+function writeJourneyFiles(appFeatures, writeContext) {
     const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams, dotFileExtension } = writeContext;
-    const generatedJourneyPages = [];
-    const newPages = [];
+    const generatedJourneys = [];
     if (appFeatures.listReport?.name) {
-        editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `ListReportJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${appFeatures.listReport.name}Journey${dotFileExtension}`), {
+        editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `ListReportJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${appFeatures.listReport.name}Journey.gen${dotFileExtension}`), {
             ...journeyParams,
             ...appFeatures.listReport,
             appPath: config.appPath
         }, undefined, {
             globOptions: { dot: true }
         });
-        generatedJourneyPages.push(appFeatures.listReport.name);
-        const lrPage = ensurePageExists(appFeatures.listReport.name, config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
-        if (lrPage) {
-            newPages.push(lrPage);
-        }
+        generatedJourneys.push(appFeatures.listReport.name);
     }
     if (appFeatures.objectPages && appFeatures.objectPages.length > 0) {
         appFeatures.objectPages.forEach((objectPage) => {
             if (objectPage.name) {
-                editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `ObjectPageJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${objectPage.name}Journey${dotFileExtension}`), {
+                editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `ObjectPageJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${objectPage.name}Journey.gen${dotFileExtension}`), {
                     ...journeyParams,
                     ...objectPage,
-                    isStandalone,
                     appPath: config.appPath
                 }, undefined, {
                     globOptions: { dot: true }
                 });
-                generatedJourneyPages.push(objectPage.name);
-                const opPage = ensurePageExists(objectPage.name, config, rootV4TemplateDirPath, testOutDirPath, editor, dotFileExtension);
-                if (opPage) {
-                    newPages.push(opPage);
-                }
+                generatedJourneys.push(objectPage.name);
             }
         });
     }
@@ -446,33 +542,142 @@ function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRu
         // an LR-OP-FPM mix with `enableTypeScript` would crash in `writePageObject`
         // when trying to load the missing `FPM.ts` template.
         // Future work: add FPM.ts/FPMJourney.ts templates and switch to `dotFileExtension`.
-        editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'FPMJourney.js'), join(testOutDirPath, 'integration', `${appFeatures.fpm.name}Journey.js`), {
+        editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'FPMJourney.js'), join(testOutDirPath, 'integration', `${appFeatures.fpm.name}Journey.gen.js`), {
             ...journeyParams,
             ...appFeatures.fpm
         }, undefined, {
             globOptions: { dot: true }
         });
-        generatedJourneyPages.push(appFeatures.fpm.name);
-        const fpmPage = ensurePageExists(appFeatures.fpm.name, config, rootV4TemplateDirPath, testOutDirPath, editor, DotFileExtension.JS);
-        if (fpmPage) {
-            newPages.push(fpmPage);
+        generatedJourneys.push(appFeatures.fpm.name);
+    }
+    if (generatedJourneys.length === 0 && !writeContext.hasPreexistingTests) {
+        writeFallbackJourney(writeContext);
+    }
+    return generatedJourneys;
+}
+/**
+ * Writes the fallback `FirstJourney.js` starter file when no dynamically generated journeys
+ * were produced.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ */
+function writeFallbackJourney(writeContext) {
+    const { config, rootV4TemplateDirPath, testOutDirPath, editor, journeyParams, dotFileExtension } = writeContext;
+    editor.copyTpl(join(rootV4TemplateDirPath, 'integration', `FirstJourney${dotFileExtension}`), join(testOutDirPath, 'integration', `${config.opaJourneyFileName}${dotFileExtension}`), journeyParams, undefined, {
+        globOptions: { dot: true }
+    });
+}
+/**
+ * Update the `OpaJourneyTypes.d.ts` type-definition file used by generated TypeScript OPA tests.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param generatedPages - pages whose journeys should be reflected in the type definitions
+ */
+function handleOPAJourneyTypes(writeContext, generatedPages) {
+    if (writeContext.incompatibleTestSetup) {
+        writeContext.log?.info(t('info.opaJourneyTypesNotUpdated'));
+        return;
+    }
+    if (writeContext.hasPreexistingTests) {
+        const written = addJourneysToOpaJourneyTypes(generatedPages, writeContext.testOutDirPath, writeContext.editor, writeContext.log);
+        if (written) {
+            writeContext.modifiedFiles.push('integration/types/OpaJourneyTypes.d.ts');
         }
     }
-    if (newPages.length > 0) {
-        addPagesToJourneyRunner(newPages, testOutDirPath, editor, dotFileExtension);
+    else {
+        writeOpaJourneyTypes(writeContext);
+    }
+}
+/**
+ * Handles JourneyRunner File.
+ * If there is already a JourneyRunner file, it is updated with the generated pages, otherwise a new JourneyRunner file is written.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param generatedPages - an array of page objects that were generated, each containing a targetKey and appPath
+ */
+function handleJourneyRunner(writeContext, generatedPages) {
+    if (writeContext.incompatibleTestSetup) {
+        return;
+    }
+    else if (writeContext.hasPreexistingTests) {
+        updatePagesInJourneyRunner(writeContext, generatedPages);
     }
-    if (!virtualOPA5Configured) {
-        if (hasJourneyRunner) {
-            addPathsToQUnitJs(generatedJourneyPages.map((page) => {
-                return `${config.appPath}/test/integration/${page}Journey`;
-            }), testOutDirPath, editor);
+    else {
+        writeJourneyRunner(writeContext);
+    }
+}
+/**
+ * Ensures that there is a page object file for each generated journey and adds the pages to the JourneyRunner.js file if they were newly created.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param generatedPages - an array of page objects that were generated, each containing a targetKey and appPath
+ */
+function updatePagesInJourneyRunner(writeContext, generatedPages) {
+    const { testOutDirPath, editor, log, dotFileExtension, modifiedFiles } = writeContext;
+    if (generatedPages.length > 0) {
+        const written = addPagesToJourneyRunner(generatedPages, testOutDirPath, editor, dotFileExtension, log);
+        if (written) {
+            modifiedFiles.push(`integration/pages/JourneyRunner${dotFileExtension}`);
         }
-        else {
-            editor.copyTpl(join(rootV4TemplateDirPath, 'integration', 'opaTests.*.*'), join(testOutDirPath, 'integration'), { ...config, generatedJourneyPages }, undefined, {
-                globOptions: { dot: true }
-            });
+    }
+}
+/**
+ * Configures `ui5-mock.yaml` to serve the OPA harness virtually so the qunit/testsuite files
+ * do not need to be written to disk. Used when virtual OPA5 is configured for the app.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ */
+async function addVirtualOpa5Config(writeContext) {
+    await addVirtualTestConfig(writeContext.basePath, [{ framework: 'OPA5', path: '/test/integration/opaTests.qunit.html' }, { framework: 'Testsuite' }], writeContext.editor);
+    writeContext.modifiedFiles.push('ui5-mock.yaml');
+}
+/**
+ * Handles the opaTests.qunit.html, opaTests.qunit.js, and testsuite.qunit.* files for non-virtual setups.
+ * For virtual OPA5 setups, call `addVirtualOpa5Config` instead.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param generatedJourneys - an array of feature names for which journey files were generated
+ */
+function handleOpaTestsStartupFiles(writeContext, generatedJourneys = []) {
+    if (writeContext.incompatibleTestSetup) {
+        writeContext.log?.info(t('info.incompatibleTestSetupSkipped'));
+    }
+    else if (writeContext.hasPreexistingTests) {
+        // update existing opaTests.qunit.js only in a compatible setup, as long as virtual OPA5 is not used
+        const written = updateReferencesInOpaTestsStartupFiles(writeContext, generatedJourneys);
+        if (written) {
+            writeContext.modifiedFiles.push('integration/opaTests.qunit.js');
         }
     }
+    else {
+        // new app or missing integration folder: write all files
+        writeOpaTestsStartupFiles(writeContext, generatedJourneys);
+        writeTestsuiteFiles(writeContext);
+        writeContext.modifiedFiles.push('integration/opaTests.qunit.html', 'integration/opaTests.qunit.js', 'testsuite.qunit.html', 'testsuite.qunit.js');
+    }
+}
+/**
+ * Writes the opaTests.qunit.html and opaTests.qunit.js files to the test folder. The files are copied from the common templates, which are used for both new app generation and standalone generation in case of an incompatible existing test setup or when virtual OPA5 is used.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param generatedJourneys - an array of feature names for which journey files were generated, used for conditionally adding the test configuration for the virtual OPA5 setup
+ */
+function writeOpaTestsStartupFiles(writeContext, generatedJourneys = []) {
+    writeContext.editor.copyTpl(join(writeContext.rootV4TemplateDirPath, 'integration', 'opaTests.*.*'), join(writeContext.testOutDirPath, 'integration'), { ...writeContext.config, generatedJourneys }, undefined, {
+        globOptions: { dot: true }
+    });
+}
+/**
+ * Updates the references in the opaTests.qunit.js file to the generated journey files and adds the test configuration for virtual OPA5 in case it's used.
+ *
+ * @param writeContext - shared write context (config, paths, editor, journey params)
+ * @param generatedJourneys - an array of feature names for which journey files were generated, used for conditionally adding the test configuration for the virtual OPA5 setup
+ * @returns true if the file was written, false otherwise
+ */
+function updateReferencesInOpaTestsStartupFiles(writeContext, generatedJourneys = []) {
+    return addPathsToQUnitJs(generatedJourneys.map((page) => {
+        return `${writeContext.config.appPath}/test/integration/${page}Journey.gen`;
+    }), writeContext.testOutDirPath, writeContext.editor, writeContext.log);
 }
 /**
  * Writes a page object in a mem-fs-editor.
@@ -482,12 +687,24 @@ function writeJourneyFiles(appFeatures, writeContext, isStandalone, hasJourneyRu
  * @param testOutDirPath - output test directory (.../webapp/test)
  * @param fs - a reference to a mem-fs editor
  * @param dotFileExtension - file extension ('.ts' or '.js')
+ * @returns path to the written page object
  */
 function writePageObject(pageConfig, rootTemplateDirPath, testOutDirPath, fs, dotFileExtension) {
     // FPM has no .ts template; force .js regardless of the configured extension
     const ext = pageConfig.template === 'FPM' ? DotFileExtension.JS : dotFileExtension;
-    fs.copyTpl(join(rootTemplateDirPath, 'integration', 'pages', `${pageConfig.template}${ext}`), join(testOutDirPath, 'integration', 'pages', `${pageConfig.targetKey}${ext}`), pageConfig, undefined, {
+    fs.copyTpl(join(rootTemplateDirPath, 'integration', 'pages', `${pageConfig.template}${ext}`), join(testOutDirPath, 'integration', 'pages', `${pageConfig.targetKey}.gen${ext}`), pageConfig, undefined, {
         globOptions: { dot: true }
     });
+    return {
+        targetKey: pageConfig.targetKey,
+        appPath: pageConfig.appPath,
+        fileName: `${pageConfig.targetKey}.gen`,
+        dotFileExtension: ext,
+        template: pageConfig.template,
+        appID: pageConfig.appID,
+        componentID: pageConfig.componentID,
+        entitySet: pageConfig.entitySet,
+        contextPath: pageConfig.contextPath
+    };
 }
 //# sourceMappingURL=fiori-elements-opa-writer.js.map

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { generateOPAFiles } from './fiori-elements-opa-writer.js';
 export { generateFreestyleOPAFiles } from './fiori-freestyle-opa-writer.js';
-export { addVirtualTestConfig } from './utils/opaQUnitUtils.js';
+export { addVirtualTestConfig } from './utils/virtualOpaUtils.js';
 export type { OPAGenerationOptions } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,4 +1,4 @@
 export { generateOPAFiles } from './fiori-elements-opa-writer.js';
 export { generateFreestyleOPAFiles } from './fiori-freestyle-opa-writer.js';
-export { addVirtualTestConfig } from './utils/opaQUnitUtils.js';
+export { addVirtualTestConfig } from './utils/virtualOpaUtils.js';
 //# sourceMappingURL=index.js.map