rwsdk 1.0.0-alpha.1-test.20250911154541 → 1.0.0-alpha.10

package/dist/lib/jsonUtils.test.mjs

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { extractLastJson, extractAllJson, parseJson } from "./jsonUtils.mjs";
+describe("jsonUtils", () => {
+    describe("extractLastJson", () => {
+        it("should extract the last JSON object from a string", () => {
+            const output = 'some text {"a":1} some other text {"b":2, "c": {"d": 3}} end';
+            expect(extractLastJson(output)).toEqual({ b: 2, c: { d: 3 } });
+        });
+        it("should extract the last JSON array from a string", () => {
+            const output = "start [1, 2] middle [3, 4, [5]] end";
+            expect(extractLastJson(output)).toEqual([3, 4, [5]]);
+        });
+        it("should return the object if the string is just JSON", () => {
+            const output = '{"a":1}';
+            expect(extractLastJson(output)).toEqual({ a: 1 });
+        });
+        it("should handle nested structures correctly", () => {
+            const output = '{"a":{"b":{"c":"d"}}}';
+            expect(extractLastJson(output)).toEqual({ a: { b: { c: "d" } } });
+        });
+        it("should return null if no valid JSON is found", () => {
+            const output = "this is just some text without json";
+            expect(extractLastJson(output)).toBeNull();
+        });
+        it("should return null for malformed JSON", () => {
+            const output = '{"a":1, "b":}';
+            expect(extractLastJson(output)).toBeNull();
+        });
+        it("should handle undefined and empty string input", () => {
+            expect(extractLastJson(undefined)).toBeNull();
+            expect(extractLastJson("")).toBeNull();
+        });
+    });
+    describe("extractAllJson", () => {
+        it("should extract all JSON objects from a string", () => {
+            const output = '{"a":1} some text {"b":2} and then {"c":3, "d": [4]}';
+            expect(extractAllJson(output)).toEqual([
+                { a: 1 },
+                { b: 2 },
+                { c: 3, d: [4] },
+            ]);
+        });
+        it("should extract all JSON arrays from a string", () => {
+            const output = "[1,2] then [3,4]";
+            expect(extractAllJson(output)).toEqual([
+                [1, 2],
+                [3, 4],
+            ]);
+        });
+        it("should handle a mix of objects and arrays", () => {
+            const output = '{"a":1} [2,3] {"b":4}';
+            expect(extractAllJson(output)).toEqual([{ a: 1 }, [2, 3], { b: 4 }]);
+        });
+        it("should return an empty array if no JSON is found", () => {
+            const output = "no json here";
+            expect(extractAllJson(output)).toEqual([]);
+        });
+        it("should ignore malformed JSON", () => {
+            const output = '{"a":1} {"b":2,} [3,4]';
+            expect(extractAllJson(output)).toEqual([{ a: 1 }, [3, 4]]);
+        });
+    });
+    describe("parseJson", () => {
+        it("should parse the last JSON object by default", () => {
+            const output = '{"a":1} {"b":2}';
+            expect(parseJson(output, {})).toEqual({ b: 2 });
+        });
+        it("should return the default value if no JSON is found", () => {
+            const output = "no json";
+            expect(parseJson(output, { default: true })).toEqual({ default: true });
+        });
+        it("should find an object with a uuid property when requested", () => {
+            const output = '{"a":1} {"uuid":"123-abc", "data": "yes"} {"c":3}';
+            expect(parseJson(output, {}, true)).toEqual({
+                uuid: "123-abc",
+                data: "yes",
+            });
+        });
+        it("should return the last object if findUuid is true but no object with uuid is found", () => {
+            const output = '{"a":1} {"b":2}';
+            expect(parseJson(output, {}, true)).toEqual({ b: 2 });
+        });
+        it("should return the default value if findUuid is true and no JSON is found", () => {
+            const output = "no json";
+            expect(parseJson(output, { default: true }, true)).toEqual({
+                default: true,
+            });
+        });
+    });
+});

package/dist/lib/normalizeModulePath.d.mts

@@ -1,3 +1,8 @@
+/**
+ * Find the number of common ancestor segments between two absolute paths.
+ * Returns the count of shared directory segments from the root.
+ */
+export declare function findCommonAncestorDepth(path1: string, path2: string): number;
 /**
  * Normalize a module path to a consistent form.
  * Returns slash-prefixed paths for files within project root,

package/dist/lib/normalizeModulePath.mjs

@@ -4,7 +4,7 @@ import { normalizePath as normalizePathSeparators } from "vite";
  * Find the number of common ancestor segments between two absolute paths.
  * Returns the count of shared directory segments from the root.
  */
-function findCommonAncestorDepth(path1, path2) {
+export function findCommonAncestorDepth(path1, path2) {
     const segments1 = path1.split("/").filter(Boolean);
     const segments2 = path2.split("/").filter(Boolean);
     let commonLength = 0;

package/dist/lib/normalizeModulePath.test.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/lib/{normalizeModulePath.test.js → normalizeModulePath.test.mjs}

@@ -1,5 +1,24 @@
 import { describe, it, expect } from "vitest";
-import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { normalizeModulePath, findCommonAncestorDepth, } from "./normalizeModulePath.mjs";
+describe("findCommonAncestorDepth", () => {
+    it("should return the correct depth for common paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/d")).toBe(2);
+    });
+    it("should return 0 for completely different paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/d/e/f")).toBe(0);
+    });
+    it("should handle identical paths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/c")).toBe(3);
+    });
+    it("should handle paths of different lengths", () => {
+        expect(findCommonAncestorDepth("/a/b/c", "/a/b/c/d/e")).toBe(3);
+    });
+    it("should handle the root path", () => {
+        expect(findCommonAncestorDepth("/", "/a/b")).toBe(0);
+        expect(findCommonAncestorDepth("/a", "/")).toBe(0);
+        expect(findCommonAncestorDepth("/", "/")).toBe(0);
+    });
+});
 describe("normalizeModulePath", () => {
     describe("1. Project-local paths", () => {
         it("Relative file", () => {

package/dist/lib/smokeTests/browser.mjs

@@ -1,10 +1,5 @@
-import * as os from "os";
 import { join } from "path";
-import { pathExists } from "fs-extra";
 import { log } from "./constants.mjs";
-import { mkdirp } from "fs-extra";
-import { install, resolveBuildId, computeExecutablePath, detectBrowserPlatform, Browser as PuppeteerBrowser, } from "@puppeteer/browsers";
-import puppeteer from "puppeteer-core";
 import { takeScreenshot } from "./artifacts.mjs";
 import { RETRIES } from "./constants.mjs";
 import { $ } from "../$.mjs";
@@ -14,6 +9,7 @@ import { updateTestStatus } from "./state.mjs";
 import * as fs from "fs/promises";
 import { template as urlStylesTemplate } from "./templates/smokeTestUrlStyles.css.template";
 import { template as clientStylesTemplate } from "./templates/smokeTestClientStyles.module.css.template";
+import { launchBrowser as launchE2EBrowser, getBrowserPath as getE2EBrowserPath, } from "../../lib/e2e/browser.mjs";
 export async function checkUrlStyles(page, expectedColor) {
     const selector = '[data-testid="smoke-test-url-styles"]';
     log(`Checking for element with selector: ${selector}`);
@@ -86,100 +82,13 @@ export async function checkClientModuleStyles(page, expectedColor) {
  * Launch a browser instance
  */
 export async function launchBrowser(browserPath, headless = true) {
-    // Get browser path if not provided
-    if (!browserPath) {
-        log("Getting browser executable path");
-        browserPath = await getBrowserPath();
-    }
-    console.log(`🚀 Launching browser from ${browserPath} (headless: ${headless})`);
-    log("Starting browser with puppeteer");
-    return await puppeteer.launch({
-        executablePath: browserPath,
-        headless,
-        args: ["--no-sandbox", "--disable-setuid-sandbox"],
-    });
+    return launchE2EBrowser(browserPath, headless);
 }
 /**
  * Get the browser executable path
  */
 export async function getBrowserPath(testOptions) {
-    console.log("Finding Chrome executable...");
-    // First try using environment variable if set
-    if (process.env.CHROME_PATH) {
-        console.log(`Using Chrome from environment variable: ${process.env.CHROME_PATH}`);
-        return process.env.CHROME_PATH;
-    }
-    // Detect platform
-    log("Detecting platform");
-    const platform = detectBrowserPlatform();
-    if (!platform) {
-        log("ERROR: Failed to detect browser platform");
-        throw new Error("Failed to detect browser platform");
-    }
-    log("Detected platform: %s", platform);
-    // Define a consistent cache directory path in system temp folder
-    const rwCacheDir = join(os.tmpdir(), "redwoodjs-smoke-test-cache");
-    await mkdirp(rwCacheDir);
-    log("Using cache directory: %s", rwCacheDir);
-    // Determine browser type based on headless option
-    const browser = testOptions?.headless === false
-        ? PuppeteerBrowser.CHROME
-        : PuppeteerBrowser.CHROMEHEADLESSSHELL;
-    log(`Using browser type: ${browser}`);
-    // Resolve the buildId for the stable Chrome version - do this once
-    log("Resolving Chrome buildId for stable channel");
-    const buildId = await resolveBuildId(browser, platform, "stable");
-    log("Resolved buildId: %s", buildId);
-    // Create installation options - use them consistently
-    const installOptions = {
-        browser,
-        platform,
-        cacheDir: rwCacheDir,
-        buildId,
-        unpack: true,
-    };
-    try {
-        // Try to compute the path first (this will check if it's installed)
-        log("Attempting to find existing Chrome installation");
-        const path = computeExecutablePath(installOptions);
-        if (await pathExists(path)) {
-            console.log(`Found existing Chrome at: ${path}`);
-            return path;
-        }
-        else {
-            throw new Error("Chrome not found at: " + path);
-        }
-    }
-    catch (error) {
-        // If path computation fails, install Chrome
-        console.log("No Chrome installation found. Installing Chrome...");
-        // Add better error handling for the install step
-        try {
-            console.log("Downloading Chrome (this may take a few minutes)...");
-            await install(installOptions);
-            console.log("✅ Chrome installation completed successfully");
-            // Now compute the path for the installed browser
-            const path = computeExecutablePath(installOptions);
-            console.log(`Installed and using Chrome at: ${path}`);
-            return path;
-        }
-        catch (installError) {
-            // Provide more detailed error about the browser download failure
-            log("ERROR: Failed to download/install Chrome: %O", installError);
-            console.error(`❌ Failed to download/install Chrome browser.`);
-            console.error(`This is likely a network issue or the browser download URL is unavailable.`);
-            console.error(`Error details: ${installError instanceof Error ? installError.message : String(installError)}`);
-            // For debug builds, show the full error stack if available
-            if (installError instanceof Error && installError.stack) {
-                log("Error stack: %s", installError.stack);
-            }
-            console.log("\nPossible solutions:");
-            console.log("1. Check your internet connection");
-            console.log("2. Set CHROME_PATH environment variable to an existing Chrome installation");
-            console.log("3. Install Chrome manually and run the tests again");
-            throw new Error(`Failed to install Chrome browser: ${installError instanceof Error ? installError.message : String(installError)}`);
-        }
-    }
+    return getE2EBrowserPath(testOptions);
 }
 /**
  * Check a URL by performing smoke tests and realtime upgrade

package/dist/lib/smokeTests/development.mjs

@@ -1,233 +1,12 @@
-import { setTimeout } from "node:timers/promises";
 import { log, RETRIES } from "./constants.mjs";
-import { $ } from "../$.mjs";
 import { checkUrl, checkServerUp, launchBrowser } from "./browser.mjs";
-import { fail } from "./utils.mjs";
 import { state } from "./state.mjs";
+import { runDevServer as runE2EDevServer } from "../../lib/e2e/dev.mjs";
 /**
  * Run the local development server and return the URL
  */
 export async function runDevServer(cwd) {
-    console.log("🚀 Starting development server...");
-    // Function to stop the dev server - defined early so we can use it in error handling
-    let devProcess = null;
-    let isErrorExpected = false;
-    const stopDev = async () => {
-        isErrorExpected = true;
-        if (!devProcess) {
-            log("No dev process to stop");
-            return;
-        }
-        console.log("Stopping development server...");
-        try {
-            // Send a regular termination signal first
-            devProcess.kill();
-            // Wait for the process to terminate with a timeout
-            const terminationTimeout = 5000; // 5 seconds timeout
-            const terminationPromise = Promise.race([
-                // Wait for natural process termination
-                (async () => {
-                    try {
-                        await devProcess;
-                        log("Dev server process was terminated normally");
-                        return true;
-                    }
-                    catch (e) {
-                        // Expected error when the process is killed
-                        log("Dev server process was terminated");
-                        return true;
-                    }
-                })(),
-                // Or timeout
-                (async () => {
-                    await setTimeout(terminationTimeout);
-                    return false;
-                })(),
-            ]);
-            // Check if process terminated within timeout
-            const terminated = await terminationPromise;
-            // If not terminated within timeout, force kill
-            if (!terminated) {
-                log("Dev server process did not terminate within timeout, force killing with SIGKILL");
-                console.log("⚠️ Development server not responding after 5 seconds timeout, force killing...");
-                // Try to kill with SIGKILL if the process still has a pid
-                if (devProcess.pid) {
-                    try {
-                        // Use process.kill with SIGKILL for a stronger termination
-                        process.kill(devProcess.pid, "SIGKILL");
-                        log("Sent SIGKILL to process %d", devProcess.pid);
-                    }
-                    catch (killError) {
-                        log("Error sending SIGKILL to process: %O", killError);
-                        // Non-fatal, as the process might already be gone
-                    }
-                }
-            }
-        }
-        catch (e) {
-            // Process might already have exited
-            log("Could not kill dev server process: %O", e);
-        }
-        console.log("Development server stopped");
-    };
-    try {
-        // Check if we're in CI mode
-        const inCIMode = process.env.CI === "true" || process.env.CI === "1";
-        // Start dev server with stdout pipe to capture URL
-        // Create environment variables object
-        const env = { ...process.env };
-        // Disable colors when running in CI mode to make URL parsing more reliable
-        if (inCIMode) {
-            log("Running in CI mode, disabling colors for dev server output");
-            env.NO_COLOR = "1";
-            env.FORCE_COLOR = "0";
-        }
-        // Map package manager names to actual commands
-        const getPackageManagerCommand = (pm) => {
-            switch (pm) {
-                case "yarn-classic":
-                    return "yarn";
-                default:
-                    return pm;
-            }
-        };
-        const pm = getPackageManagerCommand(state.options.packageManager || "npm");
-        // Use the provided cwd if available
-        devProcess = $({
-            all: true,
-            detached: false, // Keep attached so we can access streams
-            cleanup: false, // Don't auto-kill on exit
-            cwd: cwd || process.cwd(), // Use provided directory or current directory
-            env, // Pass the updated environment variables
-            stdio: 'pipe', // Ensure streams are piped
-        }) `${pm} run dev`;
-        devProcess.catch((error) => {
-            if (!isErrorExpected) {
-                // Use fail() directly here to properly handle errors from the dev process
-                fail(error, 1, "Development Server Process");
-            }
-        });
-        log("Development server process spawned in directory: %s", cwd || process.cwd());
-        // Store chunks to parse the URL
-        let url = "";
-        let allOutput = "";
-        // Listen for all output to get the URL
-        const handleOutput = (data, source) => {
-            const output = data.toString();
-            console.log(output);
-            allOutput += output; // Accumulate all output
-            log("Received output from %s: %s", source, output.replace(/\n/g, "\\n"));
-            if (!url) {
-                // Multiple patterns to catch different package manager outputs
-                const patterns = [
-                    // Standard Vite output: "Local:   http://localhost:5173/"
-                    /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
-                    // Alternative Vite output: "➜  Local:   http://localhost:5173/"
-                    /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
-                    // Unicode-safe arrow pattern
-                    /[\u27A1\u2192\u279C]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
-                    // Direct URL pattern: "http://localhost:5173"
-                    /(https?:\/\/localhost:\d+)/i,
-                    // Port-only pattern: "localhost:5173"
-                    /localhost:(\d+)/i,
-                    // Server ready messages
-                    /server.*ready.*localhost:(\d+)/i,
-                    /dev server.*localhost:(\d+)/i,
-                ];
-                for (const pattern of patterns) {
-                    const match = output.match(pattern);
-                    log("Testing pattern %s against output: %s", pattern.source, output.replace(/\n/g, "\\n"));
-                    if (match) {
-                        log("Pattern matched: %s, groups: %o", pattern.source, match);
-                        if (match[1] && match[1].startsWith("http")) {
-                            url = match[1];
-                            log("Found development server URL with pattern %s: %s", pattern.source, url);
-                            break;
-                        }
-                        else if (match[1] && /^\d+$/.test(match[1])) {
-                            url = `http://localhost:${match[1]}`;
-                            log("Found development server URL with port pattern %s: %s", pattern.source, url);
-                            break;
-                        }
-                    }
-                }
-                // Log potential matches for debugging
-                if (!url &&
-                    (output.includes("localhost") ||
-                        output.includes("Local") ||
-                        output.includes("server"))) {
-                    log("Potential URL pattern found but not matched: %s", output.trim());
-                }
-            }
-        };
-        // Listen to all possible output streams
-        log("Setting up stream listeners. Available streams: all=%s, stdout=%s, stderr=%s", !!devProcess.all, !!devProcess.stdout, !!devProcess.stderr);
-        devProcess.all?.on("data", (data) => handleOutput(data, "all"));
-        devProcess.stdout?.on("data", (data) => handleOutput(data, "stdout"));
-        devProcess.stderr?.on("data", (data) => handleOutput(data, "stderr"));
-        // Also try listening to the raw process output
-        if (devProcess.child) {
-            log("Setting up child process stream listeners");
-            devProcess.child.stdout?.on("data", (data) => handleOutput(data, "child.stdout"));
-            devProcess.child.stderr?.on("data", (data) => handleOutput(data, "child.stderr"));
-        }
-        // Wait for URL with timeout
-        const waitForUrl = async () => {
-            const start = Date.now();
-            const timeout = 60000; // 60 seconds
-            while (Date.now() - start < timeout) {
-                if (url) {
-                    return url;
-                }
-                // Fallback: check accumulated output if stream listeners aren't working
-                if (!url && allOutput) {
-                    log("Checking accumulated output for URL patterns: %s", allOutput.replace(/\n/g, "\\n"));
-                    const patterns = [
-                        /Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
-                        /[➜→]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
-                        /[\u27A1\u2192\u279C]\s*Local:\s*(?:\u001b\[\d+m)?(https?:\/\/localhost:\d+)/i,
-                        /(https?:\/\/localhost:\d+)/i,
-                        /localhost:(\d+)/i,
-                    ];
-                    for (const pattern of patterns) {
-                        const match = allOutput.match(pattern);
-                        if (match) {
-                            if (match[1] && match[1].startsWith("http")) {
-                                url = match[1];
-                                log("Found URL in accumulated output with pattern %s: %s", pattern.source, url);
-                                return url;
-                            }
-                            else if (match[1] && /^\d+$/.test(match[1])) {
-                                url = `http://localhost:${match[1]}`;
-                                log("Found URL in accumulated output with port pattern %s: %s", pattern.source, url);
-                                return url;
-                            }
-                        }
-                    }
-                }
-                // Check if the process is still running
-                if (devProcess.exitCode !== null) {
-                    log("ERROR: Development server process exited with code %d. Final output: %s", devProcess.exitCode, allOutput);
-                    throw new Error(`Development server process exited with code ${devProcess.exitCode}`);
-                }
-                await setTimeout(500); // Check every 500ms
-            }
-            log("ERROR: Timed out waiting for dev server URL. Final accumulated output: %s", allOutput);
-            throw new Error("Timed out waiting for dev server URL");
-        };
-        // Wait for the URL
-        const serverUrl = await waitForUrl();
-        console.log(`✅ Development server started at ${serverUrl}`);
-        return { url: serverUrl, stopDev };
-    }
-    catch (error) {
-        // Make sure to try to stop the server on error
-        log("Error during dev server startup: %O", error);
-        await stopDev().catch((e) => {
-            log("Failed to stop dev server during error handling: %O", e);
-        });
-        throw error;
-    }
+    return runE2EDevServer(state.options.packageManager, cwd);
 }
 /**
  * Runs tests against the development server

package/dist/lib/smokeTests/environment.d.mts

@@ -1,14 +1,7 @@
-import tmp from "tmp-promise";
-import { SmokeTestOptions, TestResources, PackageManager } from "./types.mjs";
+import { copyProjectToTempDir } from "../../lib/e2e/environment.mjs";
+import { SmokeTestOptions, TestResources } from "../../lib/e2e/types.mjs";
 /**
- * Sets up the test environment, preparing any resources needed for testing
+ * Sets up the test environment for smoke tests, preparing any resources needed for testing
  */
 export declare function setupTestEnvironment(options?: SmokeTestOptions): Promise<TestResources>;
-/**
- * Copy project to a temporary directory with a unique name
- */
-export declare function copyProjectToTempDir(projectDir: string, sync: boolean | undefined, resourceUniqueKey: string, packageManager?: PackageManager): Promise<{
-    tempDir: tmp.DirectoryResult;
-    targetDir: string;
-    workerName: string;
-}>;
+export { copyProjectToTempDir };