3장: 통합 테스트와 API 테스트 자동화

paths:
  /api/users:
    post:
      summary: 사용자 생성
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required: [email, name, password]
              properties:
                email:
                  type: string
                  format: email
                name:
                  type: string
                  minLength: 2
                  maxLength: 50
                password:
                  type: string
                  minLength: 8
      responses:
        "201":
          description: 생성 성공
        "400":
          description: 유효성 검증 실패
        "409":
          description: 이메일 중복

import request from "supertest";
import { app } from "../app";
 
describe("POST /api/users", () => {
  describe("정상 요청", () => {
    it("유효한 데이터로 사용자를 생성합니다", async () => {
      const response = await request(app)
        .post("/api/users")
        .send({
          email: "test@example.com",
          name: "홍길동",
          password: "securePass123!",
        });
 
      expect(response.status).toBe(201);
      expect(response.body).toHaveProperty("id");
      expect(response.body.email).toBe("test@example.com");
    });
  });
 
  describe("유효성 검증", () => {
    it("이메일 형식이 올바르지 않으면 400을 반환합니다", async () => {
      const response = await request(app)
        .post("/api/users")
        .send({
          email: "invalid-email",
          name: "홍길동",
          password: "securePass123!",
        });
 
      expect(response.status).toBe(400);
    });
 
    it("이름이 2자 미만이면 400을 반환합니다", async () => {
      const response = await request(app)
        .post("/api/users")
        .send({
          email: "test@example.com",
          name: "홍",
          password: "securePass123!",
        });
 
      expect(response.status).toBe(400);
    });
 
    it("비밀번호가 8자 미만이면 400을 반환합니다", async () => {
      const response = await request(app)
        .post("/api/users")
        .send({
          email: "test@example.com",
          name: "홍길동",
          password: "short",
        });
 
      expect(response.status).toBe(400);
    });
 
    it("필수 필드가 누락되면 400을 반환합니다", async () => {
      const response = await request(app)
        .post("/api/users")
        .send({ email: "test@example.com" });
 
      expect(response.status).toBe(400);
    });
  });
 
  describe("비즈니스 규칙", () => {
    it("중복 이메일로 생성 시 409를 반환합니다", async () => {
      // 첫 번째 사용자 생성
      await request(app)
        .post("/api/users")
        .send({
          email: "duplicate@example.com",
          name: "사용자1",
          password: "securePass123!",
        });
 
      // 동일 이메일로 두 번째 생성 시도
      const response = await request(app)
        .post("/api/users")
        .send({
          email: "duplicate@example.com",
          name: "사용자2",
          password: "securePass456!",
        });
 
      expect(response.status).toBe(409);
    });
  });
});

type Query {
  user(id: ID!): User
  users(page: Int = 1, limit: Int = 20): UserConnection!
}
 
type Mutation {
  createUser(input: CreateUserInput!): User!
}
 
input CreateUserInput {
  email: String!
  name: String!
  password: String!
}

import { createTestClient } from "apollo-server-testing";
import { server } from "../graphql-server";
 
const { query, mutate } = createTestClient(server);
 
describe("User GraphQL API", () => {
  it("ID로 사용자를 조회합니다", async () => {
    const GET_USER = `
      query GetUser($id: ID!) {
        user(id: $id) {
          id
          email
          name
        }
      }
    `;
 
    const result = await query({
      query: GET_USER,
      variables: { id: "user-1" },
    });
 
    expect(result.errors).toBeUndefined();
    expect(result.data?.user).toHaveProperty("email");
  });
 
  it("페이지네이션으로 사용자 목록을 조회합니다", async () => {
    const GET_USERS = `
      query GetUsers($page: Int, $limit: Int) {
        users(page: $page, limit: $limit) {
          edges { node { id email } }
          pageInfo { hasNextPage totalCount }
        }
      }
    `;
 
    const result = await query({
      query: GET_USERS,
      variables: { page: 1, limit: 10 },
    });
 
    expect(result.errors).toBeUndefined();
    expect(result.data?.users.edges).toBeInstanceOf(Array);
  });
});

import { PaymentService } from "./payment-service";
import { PaymentGateway } from "./payment-gateway";
 
// AI가 PaymentGateway의 인터페이스를 분석하여 자동 생성한 모킹
jest.mock("./payment-gateway");
const mockGateway = jest.mocked(PaymentGateway);
 
describe("PaymentService", () => {
  let service: PaymentService;
 
  beforeEach(() => {
    service = new PaymentService(new PaymentGateway());
  });
 
  it("결제 성공 시 주문 상태를 완료로 변경합니다", async () => {
    mockGateway.prototype.charge.mockResolvedValue({
      transactionId: "txn-123",
      status: "succeeded",
      amount: 50000,
    });
 
    const result = await service.processPayment("order-1", 50000);
 
    expect(result.status).toBe("completed");
    expect(result.transactionId).toBe("txn-123");
  });
 
  it("결제 실패 시 적절한 에러를 반환합니다", async () => {
    mockGateway.prototype.charge.mockRejectedValue(
      new Error("카드 한도 초과")
    );
 
    await expect(service.processPayment("order-1", 5000000))
      .rejects.toThrow("카드 한도 초과");
  });
 
  it("타임아웃 시 재시도 후 실패합니다", async () => {
    mockGateway.prototype.charge
      .mockRejectedValueOnce(new Error("TIMEOUT"))
      .mockRejectedValueOnce(new Error("TIMEOUT"))
      .mockRejectedValueOnce(new Error("TIMEOUT"));
 
    await expect(service.processPayment("order-1", 50000))
      .rejects.toThrow("결제 처리 시간이 초과되었습니다");
    
    expect(mockGateway.prototype.charge).toHaveBeenCalledTimes(3);
  });
});

import { PactV4, MatchersV3 } from "@pact-foundation/pact";
 
const { like, eachLike, string, integer } = MatchersV3;
 
const provider = new PactV4({
  consumer: "OrderService",
  provider: "UserService",
});
 
describe("UserService 계약", () => {
  it("활성 사용자 조회 계약", async () => {
    await provider
      .addInteraction()
      .given("활성 사용자가 존재하는 상태")
      .uponReceiving("사용자 조회 요청")
      .withRequest("GET", "/api/users/user-1")
      .willRespondWith(200, (builder) => {
        builder.jsonBody({
          id: string("user-1"),
          email: string("user@example.com"),
          name: string("홍길동"),
          isActive: like(true),
          createdAt: string("2026-01-01T00:00:00Z"),
        });
      })
      .executeTest(async (mockServer) => {
        const client = new UserClient(mockServer.url);
        const user = await client.getUser("user-1");
 
        expect(user.id).toBe("user-1");
        expect(user.isActive).toBe(true);
      });
  });
});

import { PostgreSqlContainer, StartedPostgreSqlContainer } from "@testcontainers/postgresql";
import { Pool } from "pg";
import { UserRepository } from "./user-repository";
 
describe("UserRepository 통합 테스트", () => {
  let container: StartedPostgreSqlContainer;
  let pool: Pool;
  let repository: UserRepository;
 
  beforeAll(async () => {
    container = await new PostgreSqlContainer("postgres:16")
      .withDatabase("testdb")
      .start();
 
    pool = new Pool({
      connectionString: container.getConnectionUri(),
    });
 
    // 스키마 마이그레이션
    await pool.query(`
      CREATE TABLE users (
        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
        email VARCHAR(255) UNIQUE NOT NULL,
        name VARCHAR(100) NOT NULL,
        is_active BOOLEAN DEFAULT true,
        created_at TIMESTAMP DEFAULT NOW()
      )
    `);
 
    repository = new UserRepository(pool);
  }, 60000);
 
  afterAll(async () => {
    await pool.end();
    await container.stop();
  });
 
  afterEach(async () => {
    await pool.query("DELETE FROM users");
  });
 
  it("사용자를 생성하고 조회합니다", async () => {
    const user = await repository.create({
      email: "test@example.com",
      name: "테스트 사용자",
    });
 
    const found = await repository.findById(user.id);
    expect(found).not.toBeNull();
    expect(found?.email).toBe("test@example.com");
  });
 
  it("중복 이메일 생성 시 에러를 반환합니다", async () => {
    await repository.create({
      email: "duplicate@example.com",
      name: "사용자1",
    });
 
    await expect(
      repository.create({
        email: "duplicate@example.com",
        name: "사용자2",
      })
    ).rejects.toThrow();
  });
 
  it("비활성 사용자를 필터링하여 조회합니다", async () => {
    await repository.create({ email: "active@example.com", name: "활성" });
    const inactive = await repository.create({
      email: "inactive@example.com",
      name: "비활성",
    });
    await repository.deactivate(inactive.id);
 
    const activeUsers = await repository.findActive();
    expect(activeUsers).toHaveLength(1);
    expect(activeUsers[0].email).toBe("active@example.com");
  });
});

name: Integration Tests
 
on:
  pull_request:
    branches: [main]
 
jobs:
  integration-tests:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        test-suite: [api, database, external]
    
    services:
      postgres:
        image: postgres:16
        env:
          POSTGRES_DB: testdb
          POSTGRES_PASSWORD: testpass
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
 
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: "pnpm"
      
      - name: Install dependencies
        run: pnpm install --frozen-lockfile
      
      - name: Run integration tests
        run: pnpm test:integration --shard=${{ matrix.test-suite }}
        env:
          DATABASE_URL: postgresql://postgres:testpass@localhost:5432/testdb

코드 변경: src/services/payment.ts
  -> 영향 분석: PaymentService, OrderService
  -> 필요한 테스트: payment.integration.test.ts, order-payment.integration.test.ts
  -> 건너뛸 테스트: user.integration.test.ts, notification.integration.test.ts