Testing

# TaskFlow Phase 28 Testing Snapshot

This snapshot demonstrates the intended testing boundaries. It is reference code, not a wholesale replacement for every existing file.

Test layers:
1. Pure unit policies
2. Nest service tests with fake repositories
3. Prisma repository integration tests with a dedicated PostgreSQL database
4. Nest HTTP e2e tests
5. React/TanStack component tests
6. Playwright critical browser journeys

- NestJS Testing: https://docs.nestjs.com/fundamentals/testing
- Prisma ORM v7 Testing: https://www.prisma.io/docs/orm/v7/more/best-practices
- Prisma Unit Testing: https://docs.prisma.io/docs/orm/prisma-client/testing/unit-testing
- Next.js Vitest: https://nextjs.org/docs/app/guides/testing/vitest
- Next.js Playwright: https://nextjs.org/docs/app/guides/testing/playwright
- React Testing Library: https://testing-library.com/docs/react-testing-library/intro/
- TanStack Query Testing: https://tanstack.com/query/latest/docs/framework/react/guides/testing
- Playwright: https://playwright.dev/docs/browsers
- Vitest npm: https://www.npmjs.com/package/vitest
- React Testing Library npm: https://www.npmjs.com/package/@testing-library/react
- Playwright npm: https://www.npmjs.com/package/@playwright/test

# Testing strategy

- Pure rules: no framework, no database.
- TasksService: FakeTaskRepository.
- PrismaTaskRepository: real PostgreSQL.
- API security/contracts: boot Nest application, use Supertest.
- React components/forms: Vitest + Testing Library + jsdom.
- Query behavior: isolated QueryClient per test.
- Critical user journeys: Playwright.

Do not mock the dependency whose real behavior is the subject of the test.

- vitest: 5.0.1
- @nestjs/testing: 12.0.3
- supertest: 7.2.2
- @testing-library/react: 16.3.3
- @testing-library/dom: 10.4.2
- @testing-library/jest-dom: 7.0.1
- @testing-library/user-event: 14.6.7
- jsdom: 30.1.0
- @playwright/test: 1.63.0

import { describe, expect, it } from "vitest";
import { assertTaskStatusTransition, TaskStatusTransitionNotAllowed } from "./task-status.policy";

describe("assertTaskStatusTransition", () => {
  it.each([
    ["TODO", "IN_PROGRESS"],
    ["TODO", "CANCELED"],
    ["IN_PROGRESS", "DONE"],
    ["DONE", "IN_PROGRESS"],
  ] as const)("allows %s -> %s", (from, to) => {
    expect(() => assertTaskStatusTransition(from, to)).not.toThrow();
  });

  it("rejects DONE -> TODO", () => {
    expect(() => assertTaskStatusTransition("DONE", "TODO"))
      .toThrow(TaskStatusTransitionNotAllowed);
  });
});

export type TaskStatus = "TODO" | "IN_PROGRESS" | "DONE" | "CANCELED";

const allowed: Record<TaskStatus, readonly TaskStatus[]> = {
  TODO: ["IN_PROGRESS", "CANCELED"],
  IN_PROGRESS: ["TODO", "DONE", "CANCELED"],
  DONE: ["IN_PROGRESS"],
  CANCELED: [],
};

export class TaskStatusTransitionNotAllowed extends Error {}

export function assertTaskStatusTransition(from: TaskStatus, to: TaskStatus) {
  if (!allowed[from].includes(to)) {
    throw new TaskStatusTransitionNotAllowed(`${from} -> ${to}`);
  }
}

import type { TaskRepository, TaskRecord } from "../src/tasks/repositories/task.repository";

export class FakeTaskRepository implements TaskRepository {
  readonly items = new Map<string, TaskRecord>();
  seed(task: TaskRecord) { this.items.set(task.id, structuredClone(task)); }
  async findById(id: string) { return this.items.get(id) ?? null; }
  // Implement the rest of the contract with the minimum behavior each service test needs.
}

import { beforeEach, describe, expect, it } from "vitest";
// Reference skeleton: point PrismaService at TEST_DATABASE_URL only.
// Apply migrations before this suite, reset rows between tests, and seed two workspaces.

describe("PrismaTaskRepository integration", () => {
  beforeEach(async () => {
    // resetTestDatabase(); seedScenario();
  });

  it("never returns tasks outside the caller workspace scope", async () => {
    // const result = await repository.listScoped(USER_A, query);
    // expect(result.data.map(x => x.id)).toEqual([TASK_A]);
    expect(true).toBe(true);
  });
});

import { afterAll, beforeAll, describe, expect, it } from "vitest";
import { Test } from "@nestjs/testing";
import request from "supertest";
import { AppModule } from "../src/app.module";
import { SupabaseAuthService } from "../src/auth/supabase-auth.service";

describe("Tasks HTTP", () => {
  let app: any;
  beforeAll(async () => {
    const mod = await Test.createTestingModule({ imports: [AppModule] })
      .overrideProvider(SupabaseAuthService)
      .useValue({ getClaims: async (token: string) => token === "member-token" ? { sub: "member-sub" } : null })
      .compile();
    app = mod.createNestApplication();
    await app.init();
  });
  afterAll(async () => app?.close());

  it("rejects a missing bearer token", async () => {
    await request(app.getHttpServer()).get("/tasks").expect(401);

import { beforeEach, describe, expect, it } from "vitest";
import { Test } from "@nestjs/testing";
import { TasksService } from "../src/tasks/tasks.service";
import { TASK_REPOSITORY } from "../src/tasks/repositories/task.repository";
import { FakeTaskRepository } from "./fake-task.repository";

describe("TasksService", () => {
  let service: TasksService;
  let repo: FakeTaskRepository;

  beforeEach(async () => {
    repo = new FakeTaskRepository();
    const moduleRef = await Test.createTestingModule({
      providers: [TasksService, { provide: TASK_REPOSITORY, useValue: repo }],
    }).compile();
    service = moduleRef.get(TasksService);
  });

  it("is tested through business outcomes, not Prisma calls", async () => {
    expect(service).toBeDefined();

import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { describe, expect, it } from "vitest";

describe("TaskForm", () => {
  it("shows an accessible title error before sending invalid input", async () => {
    const user = userEvent.setup();
    // render(<TaskForm ... />);
    // await user.click(screen.getByRole("button", { name: /create task/i }));
    // expect(await screen.findByText(/title is required/i)).toBeVisible();
    expect(user).toBeDefined();
  });
});

import { QueryClient } from "@tanstack/react-query";

export function createTestQueryClient() {
  return new QueryClient({
    defaultOptions: {
      queries: { retry: false },
      mutations: { retry: false },
    },
  });
}

import { defineConfig } from "vitest/config";
import react from "@vitejs/plugin-react";
import tsconfigPaths from "vite-tsconfig-paths";

export default defineConfig({
  plugins: [tsconfigPaths(), react()],
  test: {
    environment: "jsdom",
    setupFiles: ["./vitest.setup.ts"],
  },
});

import "@testing-library/jest-dom/vitest";

import { defineConfig, devices } from "@playwright/test";

export default defineConfig({
  testDir: "./tests",
  use: {
    baseURL: "http://127.0.0.1:3000",
    trace: "on-first-retry",
  },
  projects: [
    { name: "chromium", use: { ...devices["Desktop Chrome"] } },
  ],
  webServer: {
    command: "pnpm --filter web start",
    url: "http://127.0.0.1:3000",
    reuseExistingServer: !process.env.CI,
  },
});

import { test, expect } from "@playwright/test";

test("member creates a task and persisted state survives reload", async ({ page }) => {
  // Reuse a test-auth storageState fixture in the real project.
  await page.goto("/tasks");
  await page.getByRole("button", { name: /create task/i }).click();
  await page.getByLabel("Title").fill("Prepare payroll");
  await page.getByRole("button", { name: /save/i }).click();
  await expect(page.getByText("Prepare payroll")).toBeVisible();
  await page.reload();
  await expect(page.getByText("Prepare payroll")).toBeVisible();
});

# Phase 28 test matrix

## Unit
- allowed/rejected status transitions
- due-date policy with fixed time

## Service
- completedAt derived correctly
- business conflicts become domain exceptions

## Repository integration
- tenant scope never leaks rows
- filters/count/pagination share authorization scope

## HTTP
- 400 validation
- 401 unauthenticated
- 403/404 authorization semantics
- 409 business conflict
- safe 500 error contract