@gallopsystems/agent-skills 1.0.0

package/plugins/nitro-testing/skills/nitro-testing/examples/handler.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Example: Testing a POST handler
+ *
+ * Co-located with the handler: index.post.ts -> index.post.test.ts
+ */
+
+import {
+  describe,
+  test,
+  expect,
+  mockPost,
+  mockGet,
+  expectHttpError,
+} from "~/server/test-utils";
+import handler from "./index.post";
+import getHandler from "./[id].get";
+
+describe("POST /api/users", () => {
+  test("creates user with valid data", async ({ factories: _, db }) => {
+    const event = mockPost({}, {
+      email: "new@example.com",
+      name: "New User",
+    });
+
+    const result = await handler(event);
+
+    // Verify response
+    expect(result.id).toBeDefined();
+    expect(result.email).toBe("new@example.com");
+    expect(result.name).toBe("New User");
+
+    // Verify persisted in database
+    const saved = await db
+      .selectFrom("user")
+      .where("id", "=", result.id)
+      .selectAll()
+      .executeTakeFirst();
+
+    expect(saved).toBeDefined();
+    expect(saved?.email).toBe("new@example.com");
+  });
+
+  test("creates user with all optional fields", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      email: "full@example.com",
+      name: "Full User",
+      role: "admin",
+      metadata: { source: "api", version: 2 },
+    });
+
+    const result = await handler(event);
+
+    expect(result.role).toBe("admin");
+    expect(result.metadata).toEqual({ source: "api", version: 2 });
+  });
+
+  test("sets default values", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      email: "minimal@example.com",
+      name: "Minimal",
+    });
+
+    const result = await handler(event);
+
+    expect(result.role).toBe("user"); // Default role
+    expect(result.created_at).toBeDefined();
+  });
+
+  test("throws 400 for missing required email", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      name: "No Email",
+    });
+
+    await expectHttpError(handler(event), { statusCode: 400 });
+  });
+
+  test("throws 400 for missing required name", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      email: "test@example.com",
+    });
+
+    await expectHttpError(handler(event), { statusCode: 400 });
+  });
+
+  test("throws 400 for invalid email format", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      email: "not-an-email",
+      name: "Test",
+    });
+
+    await expectHttpError(handler(event), { statusCode: 400 });
+  });
+
+  test("throws 400 for invalid role", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      email: "test@example.com",
+      name: "Test",
+      role: "superadmin", // Not a valid role
+    });
+
+    await expectHttpError(handler(event), { statusCode: 400 });
+  });
+
+  test("throws 409 for duplicate email", async ({ factories }) => {
+    // Create existing user
+    await factories.user({ email: "existing@example.com" });
+
+    const event = mockPost({}, {
+      email: "existing@example.com",
+      name: "Duplicate",
+    });
+
+    await expectHttpError(handler(event), { statusCode: 409 });
+  });
+
+  test("created user appears in GET", async ({ factories: _ }) => {
+    // Create user
+    const createEvent = mockPost({}, {
+      email: "findme@example.com",
+      name: "Find Me",
+    });
+    const created = await handler(createEvent);
+
+    // Fetch user
+    const getEvent = mockGet({ id: created.id });
+    const fetched = await getHandler(getEvent);
+
+    expect(fetched.id).toBe(created.id);
+    expect(fetched.email).toBe("findme@example.com");
+  });
+});
+
+describe("POST /api/users - with related data", () => {
+  test("creates user with organization", async ({ factories, db }) => {
+    const org = await factories.organization({ name: "Acme Corp" });
+
+    const event = mockPost({}, {
+      email: "employee@example.com",
+      name: "Employee",
+      organizationId: org.id,
+    });
+
+    const result = await handler(event);
+
+    expect(result.organization_id).toBe(org.id);
+
+    // Verify relationship
+    const user = await db
+      .selectFrom("user")
+      .innerJoin("organization", "organization.id", "user.organization_id")
+      .where("user.id", "=", result.id)
+      .select(["user.id", "organization.name as org_name"])
+      .executeTakeFirst();
+
+    expect(user?.org_name).toBe("Acme Corp");
+  });
+
+  test("throws 404 for non-existent organization", async ({ factories: _ }) => {
+    const event = mockPost({}, {
+      email: "test@example.com",
+      name: "Test",
+      organizationId: 999999,
+    });
+
+    await expectHttpError(handler(event), { statusCode: 404 });
+  });
+});

package/plugins/nitro-testing/skills/nitro-testing/examples/setup.ts

@@ -0,0 +1,29 @@
+/**
+ * Vitest Setup File
+ *
+ * Runs before each test file to stub Nuxt auto-imports.
+ * Database reset/migrations happen in global-setup.ts (runs once).
+ */
+
+import { vi } from "vitest";
+
+function getTestConnectionString(): string {
+  if (process.env.TEST_POSTGRESQL_CONNECTION_STRING) {
+    return process.env.TEST_POSTGRESQL_CONNECTION_STRING;
+  }
+  return "postgresql://localhost/myapp-test";
+}
+
+// Stub useRuntimeConfig before importing anything else
+vi.stubGlobal("useRuntimeConfig", () => ({
+  postgresql: {
+    connectionString: getTestConnectionString(),
+  },
+  public: {
+    environment: "test",
+  },
+}));
+
+// Import and run handler mocks (after useRuntimeConfig is stubbed)
+const { setupHandlerMocks } = await import("./index");
+await setupHandlerMocks();

package/plugins/nitro-testing/skills/nitro-testing/examples/test-utils-index.ts

@@ -0,0 +1,297 @@
+/**
+ * Test Utilities
+ *
+ * Helpers for testing Nuxt/Nitro API handlers with real PostgreSQL.
+ * Auto-import mocks are set up via vitest setupFiles (see setup.ts).
+ */
+
+import { vi, test as base, expect } from "vitest";
+import { createEvent } from "h3";
+import { IncomingMessage, ServerResponse } from "http";
+import { Socket } from "net";
+import { db } from "../utils/db";
+import type { Transaction } from "kysely";
+import type { DB } from "../db/db";
+
+// ============================================================================
+// Task Registry (for async/automation testing)
+// ============================================================================
+
+const taskHandlers: Map<string, (opts: { payload: any }) => Promise<any>> = new Map();
+let pendingTasks: Promise<any>[] = [];
+let currentTrx: Transaction<DB> | null = null;
+
+// ============================================================================
+// Global Stubs
+// ============================================================================
+
+export async function setupHandlerMocks() {
+  vi.stubGlobal("defineEventHandler", (handler: Function) => handler);
+
+  vi.stubGlobal("getUserSession", async () => ({
+    user: { id: 1, firstName: "Test", lastName: "User", role: "admin" },
+  }));
+
+  vi.stubGlobal("setUserSession", async () => {});
+
+  // Default: no-op for automations
+  vi.stubGlobal("triggerAutomation", () => {});
+
+  // Task registration and execution
+  vi.stubGlobal("defineTask", (config: { meta: { name: string }; run: Function }) => {
+    taskHandlers.set(config.meta.name, config.run as any);
+    return config;
+  });
+
+  vi.stubGlobal("runTask", (taskName: string, options: { payload: any }) => {
+    const handler = taskHandlers.get(taskName);
+    if (!handler) {
+      return Promise.reject(new Error(`Task handler not found: ${taskName}`));
+    }
+    const promise = handler(options);
+    pendingTasks.push(promise);
+    return promise;
+  });
+
+  vi.stubGlobal("useDatabase", () => {
+    if (!currentTrx) {
+      throw new Error("useDatabase called outside of test transaction");
+    }
+    return currentTrx;
+  });
+
+  // Handle nested transactions
+  const KyselyModule = await import("kysely");
+  const TransactionClass = (KyselyModule as any).Transaction;
+  if (TransactionClass?.prototype) {
+    TransactionClass.prototype.transaction = function () {
+      const self = this;
+      return {
+        execute: async <T>(callback: (trx: any) => Promise<T>): Promise<T> => {
+          return callback(self);
+        },
+      };
+    };
+  }
+
+  vi.stubGlobal("createError", (opts: {
+    statusCode: number;
+    message?: string;
+    statusMessage?: string;
+    data?: unknown;
+  }) => {
+    const error = new Error(opts.message || opts.statusMessage || "") as any;
+    error.statusCode = opts.statusCode;
+    if (opts.data !== undefined) error.data = opts.data;
+    return error;
+  });
+
+  vi.stubGlobal("getValidatedRouterParams", async (event: any, validate: Function) => {
+    return validate(event.context.params ?? {});
+  });
+
+  vi.stubGlobal("getRouterParam", (event: any, param: string) => {
+    return event.context.params?.[param];
+  });
+
+  vi.stubGlobal("getValidatedQuery", async (event: any, validate: Function) => {
+    return validate(event.context._mockQuery ?? {});
+  });
+
+  vi.stubGlobal("getQuery", (event: any) => {
+    return event.context._mockQuery ?? {};
+  });
+
+  vi.stubGlobal("readValidatedBody", async (event: any, validate: Function) => {
+    return validate(event.context._mockBody ?? {});
+  });
+
+  vi.stubGlobal("readBody", async (event: any) => event.context._mockBody);
+}
+
+// ============================================================================
+// Automation Testing
+// ============================================================================
+
+export async function enableAutomationTriggers() {
+  await import("../tasks/execute-automation");
+  const { triggerAutomation: realTrigger } = await import("../utils/automation");
+
+  vi.stubGlobal("triggerAutomation", (...args: Parameters<typeof realTrigger>) => {
+    const promise = realTrigger(...args);
+    pendingTasks.push(promise);
+    return promise;
+  });
+}
+
+export async function waitForAutomations(): Promise<void> {
+  while (pendingTasks.length > 0) {
+    const tasksToWait = [...pendingTasks];
+    pendingTasks = [];
+    await Promise.allSettled(tasksToWait);
+  }
+}
+
+// ============================================================================
+// Mock Event Helpers
+// ============================================================================
+
+type Params = Record<string, string | number>;
+
+export function createMockEvent(options: {
+  method?: string;
+  params?: Params;
+  body?: unknown;
+  query?: Record<string, string>;
+}) {
+  const { method = "GET", params = {}, body, query = {} } = options;
+
+  const socket = new Socket();
+  const req = new IncomingMessage(socket);
+  req.method = method;
+  req.url = "/" + (Object.keys(query).length
+    ? "?" + new URLSearchParams(query).toString()
+    : "");
+
+  const res = new ServerResponse(req);
+  const event = createEvent(req, res);
+
+  event.context.params = Object.fromEntries(
+    Object.entries(params).map(([k, v]) => [k, String(v)])
+  );
+
+  if (body !== undefined) event.context._mockBody = body;
+  if (Object.keys(query).length > 0) event.context._mockQuery = query;
+
+  return event;
+}
+
+export function mockGet(params: Params, query?: Record<string, string>) {
+  return createMockEvent({ method: "GET", params, query });
+}
+
+export function mockPost(params: Params, body: unknown) {
+  return createMockEvent({ method: "POST", params, body });
+}
+
+export function mockPatch(params: Params, body: unknown) {
+  return createMockEvent({ method: "PATCH", params, body });
+}
+
+export function mockDelete(params: Params) {
+  return createMockEvent({ method: "DELETE", params });
+}
+
+// ============================================================================
+// Assertion Helpers
+// ============================================================================
+
+export async function expectHttpError(
+  promise: Promise<unknown>,
+  expected: { statusCode: number; message?: string }
+) {
+  await expect(promise).rejects.toMatchObject(expected);
+}
+
+// ============================================================================
+// Factories
+// ============================================================================
+
+function createFactories(trx: Transaction<DB>) {
+  return {
+    async user(data: Partial<{
+      email: string;
+      name: string;
+      role: string;
+    }> = {}) {
+      const num = Math.floor(Math.random() * 10000);
+      return trx
+        .insertInto("user")
+        .values({
+          email: data.email ?? `test${num}@example.com`,
+          name: data.name ?? "Test User",
+          role: data.role ?? "user",
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    },
+
+    async project(data: Partial<{
+      name: string;
+      ownerId: number;
+      status: string;
+    }> = {}) {
+      let ownerId = data.ownerId;
+      if (!ownerId) {
+        const owner = await this.user();
+        ownerId = owner.id;
+      }
+      return trx
+        .insertInto("project")
+        .values({
+          name: data.name ?? `Project ${Date.now()}`,
+          owner_id: ownerId,
+          status: data.status ?? "active",
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    },
+
+    async task(data: {
+      projectId: number;
+      title?: string;
+      status?: string;
+      assigneeId?: number | null;
+    }) {
+      return trx
+        .insertInto("task")
+        .values({
+          project_id: data.projectId,
+          title: data.title ?? "Test Task",
+          status: data.status ?? "pending",
+          assignee_id: data.assigneeId ?? null,
+        })
+        .returningAll()
+        .executeTakeFirstOrThrow();
+    },
+
+    // Add more factories as needed...
+  };
+}
+
+export type Factories = ReturnType<typeof createFactories>;
+
+// ============================================================================
+// Test Fixture
+// ============================================================================
+
+interface TestFixtures {
+  factories: Factories;
+  db: Transaction<DB>;
+}
+
+export const test = base.extend<TestFixtures>({
+  factories: async ({}, use) => {
+    await db.transaction().execute(async (trx) => {
+      currentTrx = trx;
+      try {
+        await use(createFactories(trx));
+        throw { __rollback: true };
+      } finally {
+        currentTrx = null;
+      }
+    }).catch((e) => {
+      if (e && typeof e === "object" && "__rollback" in e) return;
+      throw e;
+    });
+  },
+
+  db: async ({ factories: _ }, use) => {
+    if (!currentTrx) {
+      throw new Error("db fixture used outside transaction context");
+    }
+    await use(currentTrx);
+  },
+});
+
+export { describe, expect, beforeAll } from "vitest";

package/plugins/nitro-testing/skills/nitro-testing/examples/vitest.config.ts

@@ -0,0 +1,42 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    // Enable globals (describe, test, expect without imports)
+    globals: true,
+
+    // Node environment for API testing
+    environment: "node",
+
+    // Global setup: runs once before all tests
+    // - Drops all tables
+    // - Runs migrations
+    globalSetup: ["./server/test-utils/global-setup.ts"],
+
+    // Setup files: runs before each test file
+    // - Stubs Nuxt auto-imports
+    setupFiles: ["./server/test-utils/setup.ts"],
+
+    // Coverage configuration
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "html", "lcov", "json", "json-summary"],
+      include: ["server/**/*.ts"],
+      exclude: [
+        "server/**/*.test.ts",
+        "server/test-utils/**",
+        "server/db/migrations/**",
+        "server/db/db.d.ts",
+      ],
+      reportsDirectory: "./coverage",
+    },
+  },
+
+  resolve: {
+    alias: {
+      "~": path.resolve(__dirname),
+      "@": path.resolve(__dirname),
+    },
+  },
+});