@probolabs/playwright 1.4.0-rc.6 → 1.4.0-rc.7

package/dist/index.cjs

@@ -5761,6 +5761,7 @@ export default class ProboReporter implements Reporter {
          */
         static async fetchScenarioData(scenarioId, apiToken, apiUrl) {
             const normalizedUrl = this.normalizeApiUrl(apiUrl);
+            // Scenario interactions endpoint is under /api/ (special endpoint)
             const url = `${normalizedUrl}/api/scenarios/${scenarioId}/interactions`;
             const response = await fetch(url, {
                 method: 'GET',
@@ -5795,6 +5796,54 @@ export default class ProboReporter implements Reporter {
             }
             return response.json();
         }
+        /**
+         * Fetch project data from the backend API
+         */
+        static async fetchProjectData(projectId, apiToken, apiUrl) {
+            const normalizedUrl = this.normalizeApiUrl(apiUrl);
+            // Projects endpoint is at root level, not under /api/
+            const url = `${normalizedUrl}/projects/${projectId}/`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Token ${apiToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await this.readResponseErrorText(response);
+                throw new Error(`Failed to fetch project ${projectId}: ${response.status} ${errorText}`);
+            }
+            return response.json();
+        }
+        /**
+         * Fetch all scenarios for a project from the backend API
+         */
+        static async fetchProjectScenarios(projectId, apiToken, apiUrl) {
+            const normalizedUrl = this.normalizeApiUrl(apiUrl);
+            // Scenarios endpoint is at root level, not under /api/
+            const url = `${normalizedUrl}/scenarios/?project_id=${projectId}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Token ${apiToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await this.readResponseErrorText(response);
+                throw new Error(`Failed to fetch scenarios for project ${projectId}: ${response.status} ${errorText}`);
+            }
+            const data = await response.json();
+            // Handle both array and paginated responses
+            if (Array.isArray(data)) {
+                return data;
+            }
+            if (data.results && Array.isArray(data.results)) {
+                return data.results;
+            }
+            return [];
+        }
         /**
          * Convert backend interaction format to Interaction[] format
          */
@@ -5945,6 +5994,48 @@ export default class ProboReporter implements Reporter {
                 scenarios: scenarioResults,
             };
         }
+        /**
+         * Generate code for all scenarios in a project
+         * Returns map of scenario names to generated code
+         */
+        static async generateCodeForProject(projectId, apiToken, apiUrl, options) {
+            // Validate inputs
+            if (!apiToken) {
+                throw new Error('API token is required');
+            }
+            if (!apiUrl) {
+                throw new Error('API URL is required');
+            }
+            // Fetch project data and scenarios
+            const [projectData, scenarios] = await Promise.all([
+                this.fetchProjectData(projectId, apiToken, apiUrl),
+                this.fetchProjectScenarios(projectId, apiToken, apiUrl),
+            ]);
+            if (scenarios.length === 0) {
+                throw new Error(`No scenarios found in project "${projectData.name}" (ID: ${projectId})`);
+            }
+            // Generate code for each scenario
+            const scenarioResults = await Promise.all(scenarios.map(async (scenario) => {
+                try {
+                    const code = await this.generateCodeForScenario(scenario.id, apiToken, apiUrl, options);
+                    return {
+                        scenarioId: scenario.id,
+                        scenarioName: scenario.name,
+                        code: code,
+                    };
+                }
+                catch (error) {
+                    // Log error but continue with other scenarios
+                    console.error(`Failed to generate code for scenario ${scenario.id}: ${error.message}`);
+                    throw error; // Re-throw to fail fast for now
+                }
+            }));
+            return {
+                projectId: projectData.id,
+                projectName: projectData.name,
+                scenarios: scenarioResults,
+            };
+        }
     }
 
     const execAsync = util.promisify(child_process.exec);
@@ -6066,6 +6157,33 @@ export default class ProboReporter implements Reporter {
      * TestSuiteRunner - Handles test suite file generation and execution
      */
     class TestSuiteRunner {
+        /**
+         * Lookup project ID by name
+         */
+        static async lookupProjectByName(projectName, apiToken, apiUrl) {
+            const baseUrl = apiUrl.endsWith('/') ? apiUrl.slice(0, -1) : apiUrl;
+            // Projects endpoint is at root level, not under /api/
+            const url = `${baseUrl}/projects/?name=${encodeURIComponent(projectName)}`;
+            const response = await fetch$1(url, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Token ${apiToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Failed to lookup project: ${response.status} ${errorText}`);
+            }
+            const data = await response.json();
+            if (Array.isArray(data) && data.length > 0) {
+                return data[0].id;
+            }
+            if (data.results && Array.isArray(data.results) && data.results.length > 0) {
+                return data.results[0].id;
+            }
+            throw new Error(`Project "${projectName}" not found`);
+        }
         /**
          * Lookup test suite ID by name and project
          */
@@ -6201,7 +6319,10 @@ export default class ProboReporter implements Reporter {
                     }
                 }
             }
-            const sanitizedName = slugify(codeGenResult.testSuiteName);
+            // Type guard: check for projectId to distinguish ProjectCodeGenResult from TestSuiteCodeGenResult
+            const sanitizedName = 'projectId' in codeGenResult && 'projectName' in codeGenResult
+                ? slugify(codeGenResult.projectName)
+                : slugify(codeGenResult.testSuiteName);
             const packageJsonContent = generatePackageJson({
                 name: sanitizedName,
                 hasSecrets: hasSecrets,
@@ -6234,12 +6355,12 @@ export default class ProboReporter implements Reporter {
          * Generates files, installs dependencies, and executes tests
          */
         static async runTestSuite(testSuiteId, apiToken, apiUrl, testSuiteName, runId, options = {}) {
-            const { outputDir, includeReporter = true, playwrightArgs = [], onStatusUpdate, onStdout, onStderr, onReporterEvent, } = options;
+            const { outputDir, includeReporter = true, playwrightArgs = [], skipRunCreation = false, onStatusUpdate, onStdout, onStderr, onReporterEvent, } = options;
             const testSuiteDir = outputDir || getDefaultTestSuiteDir(testSuiteId, testSuiteName);
             let currentRunId = runId;
             try {
-                // Create run record if not provided (needed for run-specific report directories)
-                if (!currentRunId) {
+                // Create run record if not provided and not skipping run creation
+                if (!currentRunId && !skipRunCreation) {
                     try {
                         const createResponse = await fetch$1(`${apiUrl}/test-suites/${testSuiteId}/runs/`, {
                             method: 'POST',
@@ -6664,6 +6785,233 @@ export default class ProboReporter implements Reporter {
                 };
             }
         }
+        /**
+         * Generate all files for a project (all scenarios)
+         */
+        static async generateProjectFiles(projectId, apiToken, apiUrl, outputDir, projectName, includeReporter = true) {
+            const projectDir = outputDir || getDefaultTestSuiteDir(projectId, projectName || `project-${projectId}`);
+            // Generate code for all scenarios
+            const codeGenResult = await ProboCodeGenerator.generateCodeForProject(projectId, apiToken, apiUrl);
+            if (codeGenResult.scenarios.length === 0) {
+                throw new Error(`No scenarios found in project "${codeGenResult.projectName}" (ID: ${projectId}). Cannot generate test files.`);
+            }
+            // Delete everything in the project directory except node_modules
+            if (fs__namespace.existsSync(projectDir)) {
+                try {
+                    const nodeModulesPath = path__namespace.join(projectDir, 'node_modules');
+                    const hasNodeModules = fs__namespace.existsSync(nodeModulesPath);
+                    // Temporarily move node_modules out of the way if it exists
+                    let tempNodeModulesPath = null;
+                    if (hasNodeModules) {
+                        tempNodeModulesPath = path__namespace.join(projectDir, '..', `node_modules.temp.${projectId}`);
+                        // Remove temp directory if it exists from a previous failed run
+                        if (fs__namespace.existsSync(tempNodeModulesPath)) {
+                            fs__namespace.rmSync(tempNodeModulesPath, { recursive: true, force: true });
+                        }
+                        fs__namespace.renameSync(nodeModulesPath, tempNodeModulesPath);
+                        console.log(`📦 Preserved node_modules temporarily`);
+                    }
+                    // Delete everything in the directory
+                    const entries = fs__namespace.readdirSync(projectDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const entryPath = path__namespace.join(projectDir, entry.name);
+                        try {
+                            if (entry.isDirectory()) {
+                                fs__namespace.rmSync(entryPath, { recursive: true, force: true });
+                            }
+                            else {
+                                fs__namespace.unlinkSync(entryPath);
+                            }
+                        }
+                        catch (error) {
+                            console.warn(`⚠️  Failed to delete ${entry.name}:`, error);
+                        }
+                    }
+                    console.log(`🗑️  Cleaned project directory (preserved node_modules)`);
+                    // Move node_modules back
+                    if (hasNodeModules && tempNodeModulesPath) {
+                        fs__namespace.renameSync(tempNodeModulesPath, nodeModulesPath);
+                        console.log(`📦 Restored node_modules`);
+                    }
+                }
+                catch (error) {
+                    console.warn(`⚠️  Failed to clean project directory ${projectDir}:`, error);
+                    // Continue anyway - we'll overwrite files as needed
+                }
+            }
+            // Ensure directories exist (will recreate after deletion)
+            ensureDirectoryExists(projectDir);
+            const testsDir = path__namespace.join(projectDir, 'tests');
+            ensureDirectoryExists(testsDir);
+            // Save each scenario's code to a .spec.ts file
+            for (const scenario of codeGenResult.scenarios) {
+                const fileName = `${slugify(scenario.scenarioName)}.spec.ts`;
+                const filePath = path__namespace.join(testsDir, fileName);
+                fs__namespace.writeFileSync(filePath, scenario.code, 'utf-8');
+                console.log(`✅ Generated test file: ${filePath}`);
+            }
+            // Generate package.json
+            await this.generatePackageJson(projectDir, codeGenResult);
+            // Generate playwright.config.ts (no runId for project runs)
+            await this.generatePlaywrightConfig(projectDir, includeReporter, undefined);
+            // Generate custom reporter file for live progress streaming (only if requested)
+            if (includeReporter) {
+                await this.generateProboReporter(projectDir);
+            }
+        }
+        /**
+         * Run all scenarios in a project
+         * Generates files, installs dependencies, and executes tests
+         * Does not create run records in the database (CLI mode)
+         */
+        static async runProjectScenarios(projectId, apiToken, apiUrl, projectName, options = {}) {
+            const { outputDir, includeReporter = false, // CLI mode - no custom reporter
+            playwrightArgs = [], onStdout, onStderr, } = options;
+            const projectDir = outputDir || getDefaultTestSuiteDir(projectId, projectName || `project-${projectId}`);
+            try {
+                // Generate all files
+                console.log(`📝 Generating test files for project ${projectId}...`);
+                await this.generateProjectFiles(projectId, apiToken, apiUrl, projectDir, projectName, includeReporter);
+                // Count total tests
+                const testsTotal = countTotalTests(projectDir);
+                if (testsTotal === 0) {
+                    throw new Error(`No test files generated for project ${projectId}`);
+                }
+                // Install dependencies
+                console.log(`📦 Installing dependencies in ${projectDir}...`);
+                try {
+                    const { stdout: installStdout, stderr: installStderr } = await execAsync('npm install', { cwd: projectDir, timeout: 300000 } // 5 minute timeout for install
+                    );
+                    console.log('✅ Dependencies installed successfully');
+                    if (installStdout)
+                        console.log(installStdout);
+                    if (installStderr)
+                        console.warn(installStderr);
+                }
+                catch (installError) {
+                    console.error('❌ Failed to install dependencies:', installError);
+                    const errorMsg = `Failed to install dependencies: ${installError.message}`;
+                    return {
+                        success: false,
+                        exitCode: installError.code || 1,
+                        stdout: installError.stdout || '',
+                        stderr: installError.stderr || installError.message || '',
+                        error: errorMsg,
+                    };
+                }
+                // Run Playwright tests with streaming output
+                console.log(`🚀 Running Playwright tests in ${projectDir}...`);
+                if (playwrightArgs.length > 0) {
+                    console.log(`🧪 Playwright extra args: ${playwrightArgs.join(' ')}`);
+                }
+                return new Promise(async (resolve) => {
+                    var _a, _b;
+                    let stdout = '';
+                    let stderr = '';
+                    let hasResolved = false;
+                    let stdoutLineBuffer = '';
+                    // Use spawn for streaming output
+                    const testProcess = child_process.spawn('npx', ['playwright', 'test', ...playwrightArgs], {
+                        cwd: projectDir,
+                        shell: true,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                    });
+                    // Stream stdout line by line
+                    (_a = testProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', async (data) => {
+                        var _a;
+                        const chunk = data.toString();
+                        stdoutLineBuffer += chunk;
+                        // Process complete lines
+                        const parts = stdoutLineBuffer.split(/\n/);
+                        stdoutLineBuffer = (_a = parts.pop()) !== null && _a !== void 0 ? _a : '';
+                        for (const rawLine of parts) {
+                            const line = rawLine.endsWith('\r') ? rawLine.slice(0, -1) : rawLine;
+                            stdout += rawLine + '\n';
+                            // Call stdout callback if provided
+                            if (onStdout) {
+                                await onStdout(rawLine + '\n');
+                            }
+                        }
+                    });
+                    // Stream stderr line by line
+                    (_b = testProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', async (data) => {
+                        const chunk = data.toString();
+                        stderr += chunk;
+                        // Call stderr callback if provided
+                        if (onStderr) {
+                            await onStderr(chunk);
+                        }
+                    });
+                    // Handle process completion
+                    testProcess.on('close', async (code) => {
+                        if (hasResolved)
+                            return;
+                        hasResolved = true;
+                        // Flush any remaining buffered stdout
+                        if (stdoutLineBuffer) {
+                            stdout += stdoutLineBuffer;
+                            if (onStdout) {
+                                await onStdout(stdoutLineBuffer);
+                            }
+                        }
+                        const exitCode = code !== null && code !== void 0 ? code : 1;
+                        const success = exitCode === 0;
+                        const isTestFailure = exitCode === 1 && stdout.length > 0;
+                        console.log(success ? '✅ Tests completed successfully' : (isTestFailure ? '⚠️ Tests completed with failures' : '❌ Test execution failed'));
+                        resolve({
+                            success: success,
+                            exitCode: exitCode,
+                            stdout: stdout,
+                            stderr: stderr,
+                            error: success || isTestFailure ? undefined : `Test execution failed with exit code ${exitCode}`,
+                        });
+                    });
+                    // Handle process errors
+                    testProcess.on('error', async (error) => {
+                        if (hasResolved)
+                            return;
+                        hasResolved = true;
+                        const errorMessage = error.message || String(error);
+                        stderr += errorMessage;
+                        console.error('❌ Test execution failed:', error);
+                        resolve({
+                            success: false,
+                            exitCode: 1,
+                            stdout: stdout,
+                            stderr: stderr,
+                            error: `Test execution failed: ${errorMessage}`,
+                        });
+                    });
+                    // Set timeout (1 hour)
+                    setTimeout(async () => {
+                        if (!hasResolved) {
+                            hasResolved = true;
+                            testProcess.kill();
+                            const errorMessage = 'Test execution timed out after 1 hour';
+                            stderr += errorMessage;
+                            resolve({
+                                success: false,
+                                exitCode: 1,
+                                stdout: stdout,
+                                stderr: stderr,
+                                error: errorMessage,
+                            });
+                        }
+                    }, 3600000); // 1 hour timeout
+                });
+            }
+            catch (error) {
+                console.error('❌ Error running project scenarios:', error);
+                const errorMsg = error.message || String(error);
+                return {
+                    success: false,
+                    exitCode: 1,
+                    stdout: '',
+                    stderr: errorMsg,
+                    error: errorMsg,
+                };
+            }
+        }
         /**
          * Upload artifacts for a test suite run
          *