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

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, 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);
+        // 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,123 @@
+import type { Browser, Page } from "puppeteer-core";
+interface PlaygroundEnvironment {
+    projectDir: string;
+    cleanup: () => Promise<void>;
+}
+interface DevServerInstance {
+    url: string;
+    stopDev: () => Promise<void>;
+}
+interface DeploymentInstance {
+    url: string;
+    workerName: string;
+    resourceUniqueKey: string;
+    projectDir: string;
+}
+/**
+ * Sets up a playground environment for the entire test suite.
+ * Automatically registers beforeAll and afterAll hooks.
+ *
+ * @param sourceProjectDir - Explicit path to playground directory, or import.meta.url to auto-detect
+ */
+export declare function setupPlaygroundEnvironment(sourceProjectDir?: string): void;
+/**
+ * Gets the current playground environment.
+ * Throws if no environment has been set up.
+ */
+export declare function getPlaygroundEnvironment(): PlaygroundEnvironment;
+/**
+ * Creates a dev server instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createDevServer(): Promise<DevServerInstance>;
+/**
+ * Creates a deployment instance using the shared playground environment.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createDeployment(): Promise<DeploymentInstance>;
+/**
+ * Manually cleans up a deployment instance (deletes worker and D1 database).
+ * This is optional since cleanup happens automatically after each test.
+ */
+export declare function cleanupDeployment(deployment: DeploymentInstance): Promise<void>;
+/**
+ * Creates a browser instance for testing.
+ * Automatically registers cleanup to run after the test.
+ */
+export declare function createBrowser(): Promise<Browser>;
+/**
+ * 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<{
+    cleanup: () => Promise<void>;
+}>): Promise<void>;
+/**
+ * High-level test wrapper for dev server tests.
+ * Automatically skips if RWSDK_SKIP_DEV=1
+ */
+export declare function testDev(name: string, testFn: (context: {
+    devServer: DevServerInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>): void;
+export declare namespace testDev {
+    var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testFn: (context: {
+        devServer: DevServerInstance;
+        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(name: string, testFn: (context: {
+    deployment: DeploymentInstance;
+    browser: Browser;
+    page: Page;
+    url: string;
+}) => Promise<void>): void;
+export declare namespace testDeploy {
+    var skip: (name: string, testFn?: any) => void;
+    var only: (name: string, testFn: (context: {
+        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;
+}
+/**
+ * Utility function for polling/retrying assertions
+ */
+export declare function poll(fn: () => Promise<boolean>, timeout?: number, // 2 minutes
+interval?: number): Promise<void>;
+export {};