Next.js Server Action 단위 테스트: Vitest로 폼 처리·인증·에러 핸들링 커버하기

// vitest.config.mts
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: "happy-dom",
    globals: true,
    setupFiles: ["./vitest.setup.ts"],
  },
});

// 모든 Action 테스트 파일의 공통 구조
import { describe, it, expect, vi, beforeEach } from "vitest";
 
// 모킹 선언은 항상 최상단에
vi.mock("@/lib/auth", () => ({ getSession: vi.fn() }));
vi.mock("@/lib/db", () => ({ savePost: vi.fn() }));
// 쿠키·헤더를 사용하는 Action이라면 아래도 추가
vi.mock("next/headers", () => ({ cookies: vi.fn(), headers: vi.fn() }));
// redirect()를 호출하는 Action이라면 아래도 추가
vi.mock("next/navigation", () => ({ redirect: vi.fn() }));
// revalidatePath/revalidateTag를 호출하는 Action이라면 아래도 추가
vi.mock("next/cache", () => ({
  revalidatePath: vi.fn(),
  revalidateTag: vi.fn(),
}));
 
import { getSession } from "@/lib/auth";
 
describe("...", () => {
  beforeEach(() => vi.clearAllMocks()); // 항상 초기화
});

// actions/create-post.ts
"use server";
import { z } from "zod";
import { getSession } from "@/lib/auth";
import { savePost } from "@/lib/db";
import { revalidatePath } from "next/cache";
 
const schema = z.object({
  title: z.string().min(1, "제목을 입력해주세요"),
});
 
export async function createPost(prevState: unknown, formData: FormData) {
  // 컴포넌트에 의존하지 않고 Action 내부에서 독립적으로 인증 검사
  const session = await getSession();
  if (!session) return { error: "Unauthorized" };
 
  const result = schema.safeParse({ title: formData.get("title") });
  if (!result.success) return { error: result.error.flatten().fieldErrors };
 
  try {
    await savePost({ title: result.data.title, userId: session.userId });
    revalidatePath("/posts"); // 성공 후 캐시 무효화
    return { success: true };
  } catch {
    return { error: "저장에 실패했습니다. 잠시 후 다시 시도해주세요." };
  }
}

// actions/create-post.test.ts
import { describe, it, expect, vi, beforeEach } from "vitest";
import { createPost } from "./create-post";
 
vi.mock("@/lib/auth", () => ({ getSession: vi.fn() }));
vi.mock("@/lib/db", () => ({ savePost: vi.fn() }));
vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
 
import { getSession } from "@/lib/auth";
import { savePost } from "@/lib/db";
import { revalidatePath } from "next/cache";
 
describe("createPost — 인증 검증", () => {
  beforeEach(() => vi.clearAllMocks());
 
  it("미인증 사용자는 Unauthorized 에러를 반환합니다", async () => {
    vi.mocked(getSession).mockResolvedValue(null);
 
    const fd = new FormData();
    fd.append("title", "Hello");
    const result = await createPost(undefined, fd);
 
    expect(result).toEqual({ error: "Unauthorized" });
    expect(savePost).not.toHaveBeenCalled();
  });
 
  it("인증된 사용자는 포스트를 저장하고 캐시를 무효화합니다", async () => {
    vi.mocked(getSession).mockResolvedValue({ userId: "u1" });
    vi.mocked(savePost).mockResolvedValue({ id: "post-1" });
 
    const fd = new FormData();
    fd.append("title", "Valid Title");
    const result = await createPost(undefined, fd);
 
    expect(result).toEqual({ success: true });
    expect(savePost).toHaveBeenCalledOnce();
    expect(revalidatePath).toHaveBeenCalledWith("/posts");
  });
});

// actions/admin-delete.ts
"use server";
import { getSession } from "@/lib/auth";
import { savePost } from "@/lib/db";
 
export async function adminDeleteAction(prevState: unknown, formData: FormData) {
  const session = await getSession();
  if (!session) return { error: "Unauthorized" };
  if (session.role !== "ADMIN") return { error: "Forbidden" }; // 역할 검사
 
  const targetId = formData.get("targetId") as string;
  try {
    await savePost({ id: targetId, deleted: true, userId: session.userId });
    return { success: true };
  } catch {
    return { error: "삭제에 실패했습니다." };
  }
}

// actions/admin-delete.test.ts
import { describe, it, expect, vi, beforeEach } from "vitest";
import { adminDeleteAction } from "./admin-delete";
 
vi.mock("@/lib/auth", () => ({ getSession: vi.fn() }));
vi.mock("@/lib/db", () => ({ savePost: vi.fn() }));
 
import { getSession } from "@/lib/auth";
import { savePost } from "@/lib/db";
 
describe("adminDeleteAction — 역할 기반 접근 제어", () => {
  beforeEach(() => vi.clearAllMocks());
 
  it("USER 역할은 접근이 거부됩니다", async () => {
    vi.mocked(getSession).mockResolvedValue({ userId: "u1", role: "USER" });
 
    const fd = new FormData();
    const result = await adminDeleteAction(undefined, fd);
 
    expect(result).toEqual({ error: "Forbidden" });
    expect(savePost).not.toHaveBeenCalled();
  });
 
  it("ADMIN 역할은 정상 처리됩니다", async () => {
    vi.mocked(getSession).mockResolvedValue({ userId: "u1", role: "ADMIN" });
    vi.mocked(savePost).mockResolvedValue({ id: "item-123" });
 
    const fd = new FormData();
    fd.append("targetId", "item-123");
    const result = await adminDeleteAction(undefined, fd);
 
    expect(result.success).toBe(true);
  });
});

// actions/signup.test.ts (일부)
import { describe, it, expect, vi, beforeEach } from "vitest";
import { signupAction } from "./signup";
 
vi.mock("@/lib/auth", () => ({ getSession: vi.fn() }));
 
import { getSession } from "@/lib/auth";
 
describe("signupAction — 이메일 검증", () => {
  beforeEach(() => vi.clearAllMocks());
 
  const cases = [
    { email: "",              expected: "이메일을 입력해주세요" },
    { email: "not-email",     expected: "올바른 이메일 형식이 아닙니다" },
    { email: "valid@test.com", expected: null }, // 에러 없음
  ];
 
  it.each(cases)(
    "이메일 '$email' 입력 시 검증 결과 확인",
    async ({ email, expected }) => {
      vi.mocked(getSession).mockResolvedValue({ userId: "u1" });
 
      const fd = new FormData();
      fd.append("email", email);
      const result = await signupAction(undefined, fd);
 
      if (expected) {
        expect(result.error?.email?.[0]).toBe(expected);
      } else {
        expect(result.error).toBeUndefined();
      }
    }
  );
});

// actions/create-post.test.ts (에러 핸들링 + redirect 파트)
import { describe, it, expect, vi, beforeEach } from "vitest";
import { createPost } from "./create-post";
import { loginAction } from "./login"; // createPost와 동일한 패턴으로 작성된 Action
 
vi.mock("@/lib/auth", () => ({ getSession: vi.fn() }));
vi.mock("@/lib/db", () => ({ savePost: vi.fn() }));
vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
vi.mock("next/navigation", () => ({ redirect: vi.fn() })); // 반드시 모킹
 
import { getSession } from "@/lib/auth";
import { savePost } from "@/lib/db";
import { redirect } from "next/navigation";
 
describe("createPost — 에러 핸들링", () => {
  beforeEach(() => vi.clearAllMocks());
 
  it("DB 저장 실패 시 사용자 친화적인 에러 메시지를 반환합니다", async () => {
    vi.mocked(getSession).mockResolvedValue({ userId: "u1" });
    vi.mocked(savePost).mockRejectedValue(new Error("Connection timeout"));
 
    const fd = new FormData();
    fd.append("title", "My Post");
    const result = await createPost(undefined, fd);
 
    expect(result).toEqual({
      error: "저장에 실패했습니다. 잠시 후 다시 시도해주세요.",
    });
  });
});
 
describe("loginAction — 리다이렉트", () => {
  beforeEach(() => vi.clearAllMocks());
 
  it("로그인 성공 시 대시보드로 리다이렉트됩니다", async () => {
    vi.mocked(getSession).mockResolvedValue({ userId: "u1" });
 
    const fd = new FormData();
    fd.append("email", "user@test.com");
    fd.append("password", "correct-pass");
 
    await loginAction(undefined, fd);
 
    expect(redirect).toHaveBeenCalledWith("/dashboard");
  });
});