@donkeylabs/server 2.0.18 → 2.0.20

package/src/testing/e2e.test.ts

@@ -0,0 +1,189 @@
+// packages/server/src/testing/e2e.test.ts
+import { describe, it, expect } from "bun:test";
+import { defineE2EConfig, createE2EFixtures } from "./e2e";
+
+describe("E2E Testing Utilities", () => {
+  describe("defineE2EConfig", () => {
+    it("should return default configuration", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.testDir).toBe("./e2e");
+      expect(config.timeout).toBe(30000);
+      expect(config.expect?.timeout).toBe(5000);
+      expect(config.fullyParallel).toBe(true);
+      expect(config.use?.baseURL).toBe("http://localhost:3000");
+      expect(config.use?.trace).toBe("on-first-retry");
+      expect(config.use?.screenshot).toBe("only-on-failure");
+    });
+
+    it("should use custom port", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:4000",
+        port: 4000,
+      });
+
+      expect(config.use?.baseURL).toBe("http://localhost:4000");
+    });
+
+    it("should use custom timeout", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        timeout: 60000,
+      });
+
+      expect(config.timeout).toBe(60000);
+    });
+
+    it("should configure chromium by default", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.projects?.length).toBe(1);
+      expect(config.projects?.[0].name).toBe("chromium");
+    });
+
+    it("should add firefox when specified", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        browsers: ["firefox"],
+      });
+
+      // Chromium + Firefox
+      expect(config.projects?.length).toBe(2);
+      expect(config.projects?.some((p) => p.name === "firefox")).toBe(true);
+    });
+
+    it("should add webkit when specified", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        browsers: ["webkit"],
+      });
+
+      expect(config.projects?.some((p) => p.name === "webkit")).toBe(true);
+    });
+
+    it("should add mobile viewports when testMobile is true", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        testMobile: true,
+      });
+
+      const mobileProjects = config.projects?.filter(
+        (p) => p.name.includes("Mobile")
+      );
+      expect(mobileProjects?.length).toBe(2);
+      expect(mobileProjects?.some((p) => p.name === "Mobile Chrome")).toBe(true);
+      expect(mobileProjects?.some((p) => p.name === "Mobile Safari")).toBe(true);
+    });
+
+    it("should configure webServer for auto-start", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        serverEntry: "./src/server.ts",
+        autoStart: true,
+      });
+
+      expect(config.webServer).toBeDefined();
+      expect(config.webServer?.command).toBe("bun ./src/server.ts");
+      expect(config.webServer?.url).toBe("http://localhost:3000");
+    });
+
+    it("should use default dev command when no serverEntry", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.webServer?.command).toBe("bun run dev");
+    });
+
+    it("should disable webServer when autoStart is false", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+        autoStart: false,
+      });
+
+      expect(config.webServer).toBeUndefined();
+    });
+
+    it("should configure CI settings based on environment", () => {
+      const originalCI = process.env.CI;
+
+      // Test non-CI
+      delete process.env.CI;
+      const nonCIConfig = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+      expect(nonCIConfig.forbidOnly).toBe(false);
+      expect(nonCIConfig.retries).toBe(0);
+
+      // Test CI
+      process.env.CI = "true";
+      const ciConfig = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+      expect(ciConfig.forbidOnly).toBe(true);
+      expect(ciConfig.retries).toBe(2);
+      expect(ciConfig.workers).toBe(1);
+
+      // Restore
+      if (originalCI) {
+        process.env.CI = originalCI;
+      } else {
+        delete process.env.CI;
+      }
+    });
+
+    it("should configure reporters", () => {
+      const config = defineE2EConfig({
+        baseURL: "http://localhost:3000",
+      });
+
+      expect(config.reporter).toEqual([["html"], ["list"]]);
+    });
+  });
+
+  describe("createE2EFixtures", () => {
+    const baseURL = "http://localhost:9999";
+
+    it("should create api fixture with all HTTP methods", () => {
+      const fixtures = createE2EFixtures(baseURL);
+
+      expect(fixtures.api).toBeDefined();
+      expect(typeof fixtures.api).toBe("function");
+    });
+
+    it("should create seed fixture", () => {
+      const fixtures = createE2EFixtures(baseURL);
+
+      expect(fixtures.seed).toBeDefined();
+      expect(typeof fixtures.seed).toBe("function");
+    });
+
+    it("should create cleanup fixture", () => {
+      const fixtures = createE2EFixtures(baseURL);
+
+      expect(fixtures.cleanup).toBeDefined();
+      expect(typeof fixtures.cleanup).toBe("function");
+    });
+
+    // Integration tests for fixtures would require a running server
+    // These tests verify the fixture structure
+  });
+
+  describe("E2EFixtures API client", () => {
+    // These tests require a mock server
+    // For now we just verify the structure
+
+    it("should have correct fixture structure", () => {
+      const fixtures = createE2EFixtures("http://test:3000");
+
+      // Verify all expected fixtures exist
+      expect(Object.keys(fixtures)).toContain("api");
+      expect(Object.keys(fixtures)).toContain("seed");
+      expect(Object.keys(fixtures)).toContain("cleanup");
+    });
+  });
+});

package/src/testing/e2e.ts

@@ -0,0 +1,272 @@
+// packages/server/src/testing/e2e.ts
+/**
+ * E2E Testing Utilities for DonkeyLabs Applications
+ * 
+ * Simplifies Playwright integration for testing your DonkeyLabs app.
+ * 
+ * @example
+ * ```typescript
+ * // playwright.config.ts
+ * import { defineE2EConfig } from "@donkeylabs/server";
+ * 
+ * export default defineE2EConfig({
+ *   baseURL: "http://localhost:3000",
+ *   serverEntry: "./src/server/index.ts",
+ * });
+ * ```
+ * 
+ * @example
+ * ```typescript
+ * // tests/auth.spec.ts
+ * import { test, expect } from "@donkeylabs/server";
+ * 
+ * test("user can sign up", async ({ page, api }) => {
+ *   await page.goto("/signup");
+ *   await page.fill('[name="email"]', "test@example.com");
+ *   await page.fill('[name="password"]', "password123");
+ *   await page.click('button[type="submit"]');
+ *   
+ *   await expect(page).toHaveURL("/dashboard");
+ * });
+ * ```
+ */
+
+// Only import types - actual @playwright/test is a peer dependency
+// Users should import { test, expect } from "@playwright/test" directly
+type PlaywrightTestConfig = {
+  testDir?: string;
+  timeout?: number;
+  expect?: { timeout?: number };
+  fullyParallel?: boolean;
+  forbidOnly?: boolean;
+  retries?: number;
+  workers?: number | undefined;
+  reporter?: any[];
+  use?: Record<string, any>;
+  projects?: any[];
+  webServer?: {
+    command: string;
+    url: string;
+    reuseExistingServer?: boolean;
+    timeout?: number;
+  };
+};
+
+export interface E2EConfig {
+  /** Base URL of your application */
+  baseURL: string;
+  
+  /** Server entry point file */
+  serverEntry?: string;
+  
+  /** Port for test server */
+  port?: number;
+  
+  /** Database to use for testing (isolated per test) */
+  database?: "sqlite" | "postgres" | "mysql";
+  
+  /** Auto-start dev server */
+  autoStart?: boolean;
+  
+  /** Test timeout in milliseconds */
+  timeout?: number;
+  
+  /** Browsers to test */
+  browsers?: ("chromium" | "firefox" | "webkit")[];
+  
+  /** Mobile viewport testing */
+  testMobile?: boolean;
+}
+
+export interface E2EFixtures {
+  /** API client for making HTTP requests */
+  api: {
+    get: (route: string) => Promise<any>;
+    post: (route: string, data: any) => Promise<any>;
+    put: (route: string, data: any) => Promise<any>;
+    delete: (route: string) => Promise<any>;
+  };
+  
+  /** Database instance for direct queries */
+  db: any;
+  
+  /** Helper to seed test data */
+  seed: (data: { users?: any[]; [key: string]: any[] | undefined }) => Promise<void>;
+  
+  /** Helper to cleanup test data */
+  cleanup: () => Promise<void>;
+}
+
+/**
+ * Define E2E test configuration for Playwright
+ */
+export function defineE2EConfig(config: E2EConfig): PlaywrightTestConfig {
+  const port = config.port || 3333;
+  const baseURL = config.baseURL || `http://localhost:${port}`;
+  
+  return {
+    testDir: "./e2e",
+    timeout: config.timeout || 30000,
+    expect: {
+      timeout: 5000,
+    },
+    fullyParallel: true,
+    forbidOnly: !!process.env.CI,
+    retries: process.env.CI ? 2 : 0,
+    workers: process.env.CI ? 1 : undefined,
+    reporter: [
+      ["html"],
+      ["list"],
+    ],
+    use: {
+      baseURL,
+      trace: "on-first-retry",
+      screenshot: "only-on-failure",
+      video: "on-first-retry",
+    },
+    projects: [
+      {
+        name: "chromium",
+        use: { 
+          browserName: "chromium",
+          viewport: { width: 1280, height: 720 },
+        },
+      },
+      ...(config.browsers?.includes("firefox") ? [{
+        name: "firefox",
+        use: { browserName: "firefox" as const },
+      }] : []),
+      ...(config.browsers?.includes("webkit") ? [{
+        name: "webkit",
+        use: { browserName: "webkit" as const },
+      }] : []),
+      ...(config.testMobile ? [
+        {
+          name: "Mobile Chrome",
+          use: { 
+            browserName: "chromium" as const,
+            ...devices["Pixel 5"],
+          },
+        },
+        {
+          name: "Mobile Safari",
+          use: { 
+            browserName: "webkit" as const,
+            ...devices["iPhone 12"],
+          },
+        },
+      ] : []),
+    ],
+    webServer: config.autoStart !== false ? {
+      command: config.serverEntry 
+        ? `bun ${config.serverEntry}`
+        : "bun run dev",
+      url: baseURL,
+      reuseExistingServer: !process.env.CI,
+      timeout: 120 * 1000,
+    } : undefined,
+  };
+}
+
+// Import devices from playwright
+const devices = {
+  "Pixel 5": {
+    userAgent: "Mozilla/5.0 (Linux; Android 11; Pixel 5) AppleWebKit/537.36",
+    viewport: { width: 393, height: 727 },
+    deviceScaleFactor: 2.75,
+    isMobile: true,
+    hasTouch: true,
+  },
+  "iPhone 12": {
+    userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 14_4 like Mac OS X) AppleWebKit/605.1.15",
+    viewport: { width: 390, height: 664 },
+    deviceScaleFactor: 3,
+    isMobile: true,
+    hasTouch: true,
+  },
+};
+
+/**
+ * Create E2E fixtures for Playwright tests
+ * Use this in your playwright.config.ts fixtures
+ */
+export function createE2EFixtures(baseURL: string) {
+  return {
+    api: async ({}, use: (api: E2EFixtures["api"]) => Promise<void>) => {
+      const api: E2EFixtures["api"] = {
+        async get(route: string) {
+          const response = await fetch(`${baseURL}/${route}`);
+          if (!response.ok) {
+            throw new Error(`API Error: ${response.status}`);
+          }
+          return response.json();
+        },
+        
+        async post(route: string, data: any) {
+          const response = await fetch(`${baseURL}/${route}`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(data),
+          });
+          if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`API Error: ${response.status} - ${error}`);
+          }
+          return response.json();
+        },
+        
+        async put(route: string, data: any) {
+          const response = await fetch(`${baseURL}/${route}`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(data),
+          });
+          if (!response.ok) {
+            throw new Error(`API Error: ${response.status}`);
+          }
+          return response.json();
+        },
+        
+        async delete(route: string) {
+          const response = await fetch(`${baseURL}/${route}`, {
+            method: "DELETE",
+          });
+          if (!response.ok) {
+            throw new Error(`API Error: ${response.status}`);
+          }
+          return response.json();
+        },
+      };
+      
+      await use(api);
+    },
+    
+    seed: async ({}, use: (fn: E2EFixtures["seed"]) => Promise<void>) => {
+      await use(async (data) => {
+        // Seed data via API
+        for (const [table, items] of Object.entries(data)) {
+          if (!items) continue;
+          for (const item of items) {
+            await fetch(`${baseURL}/${table}.create`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(item),
+            });
+          }
+        }
+      });
+    },
+    
+    cleanup: async ({}, use: (fn: E2EFixtures["cleanup"]) => Promise<void>) => {
+      await use(async () => {
+        // Cleanup test data
+        await fetch(`${baseURL}/test.cleanup`, {
+          method: "POST",
+        });
+      });
+    },
+  };
+}
+
+// Note: Import test and expect directly from @playwright/test in your test files:
+// import { test, expect } from "@playwright/test";

package/src/testing/index.ts

@@ -0,0 +1,18 @@
+// Testing utilities - separate subpath export to avoid loading Playwright at runtime
+// Usage: import { createE2EFixtures } from "@donkeylabs/server/testing";
+
+// E2E Testing - requires @playwright/test as peer dependency
+export {
+  createE2EFixtures,
+  defineE2EConfig,
+  type E2EFixtures,
+  type E2EConfig,
+} from "./e2e";
+
+// Database Testing Utilities
+export {
+  createTestDatabase,
+  resetTestDatabase,
+  seedTestData,
+  type TestDatabaseOptions,
+} from "./database";