rwsdk 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/lib/e2e/retry.mjs

@@ -0,0 +1,16 @@
+import { setTimeout } from "node:timers/promises";
+const log = console.log;
+export async function retry(fn, options) {
+    let lastError;
+    for (let i = 0; i < options.retries; i++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            lastError = e;
+            log(`Attempt ${i + 1} failed. Retrying in ${options.delay}ms...`);
+            await setTimeout(options.delay);
+        }
+    }
+    throw lastError;
+}

package/dist/lib/e2e/setup.d.mts

@@ -0,0 +1,2 @@
+export { launchBrowser } from "./browser.mjs";
+export type { Browser } from "puppeteer-core";

package/dist/lib/e2e/setup.mjs

@@ -0,0 +1 @@
+export { launchBrowser } from "./browser.mjs";

package/dist/lib/e2e/tarball.d.mts

@@ -0,0 +1,14 @@
+interface SetupTarballOptions {
+    projectDir: string;
+    monorepoRoot?: string;
+    packageManager?: "pnpm" | "npm" | "yarn";
+}
+interface TarballEnvironment {
+    targetDir: string;
+    cleanup: () => Promise<void>;
+}
+/**
+ * Creates a tarball-based test environment similar to the release script approach
+ */
+export declare function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager, }: SetupTarballOptions): Promise<TarballEnvironment>;
+export {};

package/dist/lib/e2e/tarball.mjs

@@ -0,0 +1,99 @@
+import { $ } from "execa";
+import fs from "node:fs";
+import path from "node:path";
+import { copyProjectToTempDir } from "./environment.mjs";
+import { uniqueNamesGenerator, adjectives, animals, } from "unique-names-generator";
+import { createHash } from "crypto";
+import { ROOT_DIR } from "../constants.mjs";
+const log = (message) => console.log(message);
+/**
+ * Copies wrangler cache from monorepo to temp directory for deployment tests
+ */
+async function copyWranglerCache(targetDir, sdkRoot) {
+    try {
+        // Find the monorepo root by starting from the SDK root directory
+        // and walking up to find the monorepo root
+        let currentDir = path.resolve(sdkRoot);
+        let monorepoRoot = null;
+        // Walk up the directory tree to find the monorepo root
+        while (currentDir !== path.dirname(currentDir)) {
+            const nodeModulesPath = path.join(currentDir, "node_modules");
+            const packageJsonPath = path.join(currentDir, "package.json");
+            if (fs.existsSync(nodeModulesPath) && fs.existsSync(packageJsonPath)) {
+                try {
+                    const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, "utf8"));
+                    // Check if this looks like our monorepo root
+                    if (packageJson.name === "rw-sdk-monorepo" ||
+                        packageJson.private === true) {
+                        monorepoRoot = currentDir;
+                        break;
+                    }
+                }
+                catch {
+                    // Continue searching if we can't read the package.json
+                }
+            }
+            currentDir = path.dirname(currentDir);
+        }
+        if (!monorepoRoot) {
+            log(`  ⚠️ Could not find monorepo root, skipping wrangler cache copy`);
+            return;
+        }
+        const sourceCachePath = path.join(monorepoRoot, "node_modules/.cache/wrangler");
+        const targetCachePath = path.join(targetDir, "node_modules/.cache/wrangler");
+        if (fs.existsSync(sourceCachePath)) {
+            log(`  🔐 Copying wrangler cache from monorepo to temp directory...`);
+            // Ensure the target cache directory exists
+            await fs.promises.mkdir(path.dirname(targetCachePath), {
+                recursive: true,
+            });
+            // Copy the entire wrangler cache directory
+            await $ `cp -r ${sourceCachePath} ${path.dirname(targetCachePath)}`;
+            log(`  ✅ Wrangler cache copied successfully`);
+        }
+        else {
+            log(`  ⚠️ No wrangler cache found in monorepo, deployment tests may require authentication`);
+        }
+    }
+    catch (error) {
+        log(`  ⚠️ Failed to copy wrangler cache: ${error.message}`);
+        // Don't throw - this is not a fatal error, deployment tests will just need manual auth
+    }
+}
+/**
+ * Creates a tarball-based test environment similar to the release script approach
+ */
+export async function setupTarballEnvironment({ projectDir, monorepoRoot, packageManager = "pnpm", }) {
+    log(`🚀 Setting up tarball environment for ${projectDir}`);
+    // Generate a resource unique key for this test run
+    const uniqueNameSuffix = uniqueNamesGenerator({
+        dictionaries: [adjectives, animals],
+        separator: "-",
+        length: 2,
+        style: "lowerCase",
+    });
+    // Create a short unique hash based on the timestamp
+    const hash = createHash("md5")
+        .update(Date.now().toString())
+        .digest("hex")
+        .substring(0, 8);
+    const resourceUniqueKey = `${uniqueNameSuffix}-${hash}`;
+    try {
+        const { tempDir, targetDir } = await copyProjectToTempDir(projectDir, resourceUniqueKey, packageManager, monorepoRoot);
+        // Copy wrangler cache to improve deployment performance
+        const sdkRoot = ROOT_DIR;
+        await copyWranglerCache(targetDir, sdkRoot);
+        log(`✅ Tarball environment setup complete`);
+        return {
+            targetDir,
+            cleanup: async () => {
+                log(`🧹 Cleaning up tarball environment: ${tempDir.path}`);
+                await tempDir.cleanup();
+            },
+        };
+    }
+    catch (error) {
+        // Cleanup tarball on error
+        throw error;
+    }
+}

package/dist/lib/e2e/testHarness.d.mts

@@ -0,0 +1,132 @@
+import { test } from "vitest";
+import { type Browser, type Page } from "puppeteer-core";
+export type { Browser, Page } from "puppeteer-core";
+interface DevServerInstance {
+    url: string;
+    stopDev: () => Promise<void>;
+}
+interface DeploymentInstance {
+    url: string;
+    workerName: string;
+    resourceUniqueKey: string;
+    projectDir: string;
+    cleanup: () => Promise<void>;
+}
+export interface SetupPlaygroundEnvironmentOptions {
+    /**
+     * The directory of the playground project to set up.
+     * Can be an absolute path, or a `import.meta.url` `file://` string.
+     * If not provided, it will be inferred from the test file's path.
+     */
+    sourceProjectDir?: string;
+    /**
+     * The root directory of the monorepo, if the project is part of one.
+     * This is used to correctly set up the test environment for monorepo projects.
+     */
+    monorepoRoot?: string;
+    /**
+     * Whether to provision a dev server for the test suite.
+     * @default true
+     */
+    dev?: boolean;
+    /**
+     * Whether to provision a deployment for the test suite.
+     * @default true
+     */
+    deploy?: boolean;
+}
+/**
+ * A Vitest hook that sets up a playground environment for a test file.
+ * It creates a temporary directory, copies the playground project into it,
+ * and installs dependencies using a tarball of the SDK.
+ * This ensures that tests run in a clean, isolated environment.
+ */
+export declare function setupPlaygroundEnvironment(options?: string | SetupPlaygroundEnvironmentOptions): void;
+/**
+ * Creates a dev server instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createDevServer(projectDir: string): Promise<DevServerInstance>;
+/**
+ * Creates a deployment instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createDeployment(projectDir: string): Promise<DeploymentInstance>;
+/**
+ * Executes a test function with a retry mechanism for specific error codes.
+ * @param name - The name of the test, used for logging.
+ * @param attemptFn - A function that executes one attempt of the test.
+ *                     It should set up resources, run the test logic, and
+ *                     return a cleanup function. The cleanup function will be
+ *                     called automatically on failure.
+ */
+export declare function runTestWithRetries(name: string, attemptFn: () => Promise<void>): Promise<void>;
+declare function createTestRunner(testFn: (typeof test | typeof test.only)["concurrent"], envType: "dev" | "deploy"): (name: string, testLogic: (context: {
+    devServer?: DevServerInstance;
+    deployment?: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>) => void;
+/**
+ * High-level test wrapper for dev server tests.
+ * Automatically skips if RWSDK_SKIP_DEV=1
+ */
+export declare function testDev(...args: Parameters<ReturnType<typeof createTestRunner>>): void;
+export declare namespace testDev {
+    var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testLogic: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
+}
+/**
+ * High-level test wrapper for deployment tests.
+ * Automatically skips if RWSDK_SKIP_DEPLOY=1
+ */
+export declare function testDeploy(...args: Parameters<ReturnType<typeof createTestRunner>>): void;
+export declare namespace testDeploy {
+    var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testLogic: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
+}
+/**
+ * Unified test function that runs the same test against both dev server and deployment.
+ * Automatically skips based on environment variables.
+ */
+export declare function testDevAndDeploy(name: string, testFn: (context: {
+    devServer?: DevServerInstance;
+    deployment?: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>): void;
+export declare namespace testDevAndDeploy {
+    var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testFn: (context: {
+        devServer?: DevServerInstance;
+        deployment?: DeploymentInstance;
+        browser: Browser;
+        page: Page;
+        url: string;
+    }) => Promise<void>) => void;
+}
+/**
+ * Waits for the page to be fully loaded and hydrated.
+ * This should be used before any user interaction is simulated.
+ */
+export declare function waitForHydration(page: Page): Promise<void>;
+export declare function trackPageErrors(page: Page): {
+    get: () => {
+        consoleErrors: string[];
+        failedRequests: string[];
+    };
+};