9장: 테스트 전략 - 단위, 통합, 벤치마크

package service
 
import "testing"
 
func TestUserService_ValidateEmail(t *testing.T) {
    svc := NewUserService(nil)
 
    // 유효한 이메일
    err := svc.ValidateEmail("user@example.com")
    if err != nil {
        t.Errorf("유효한 이메일인데 에러 발생: %v", err)
    }
 
    // 잘못된 이메일
    err = svc.ValidateEmail("invalid-email")
    if err == nil {
        t.Error("잘못된 이메일인데 에러가 발생하지 않음")
    }
}

# 현재 패키지 테스트
go test ./...
 
# 상세 출력
go test -v ./...
 
# 특정 테스트만 실행
go test -run TestUserService_ValidateEmail ./service/...
 
# 커버리지 측정
go test -cover ./...
 
# 커버리지 리포트 생성
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out

func TestCalculateDiscount(t *testing.T) {
    tests := []struct {
        name     string
        price    float64
        quantity int
        want     float64
        wantErr  bool
    }{
        {
            name:     "일반 주문 -- 할인 없음",
            price:    10000,
            quantity: 1,
            want:     10000,
        },
        {
            name:     "대량 주문 -- 10% 할인",
            price:    10000,
            quantity: 10,
            want:     90000,
        },
        {
            name:     "VIP 대량 주문 -- 20% 할인",
            price:    10000,
            quantity: 100,
            want:     800000,
        },
        {
            name:     "음수 수량 -- 에러",
            price:    10000,
            quantity: -1,
            wantErr:  true,
        },
        {
            name:     "가격 0 -- 에러",
            price:    0,
            quantity: 1,
            wantErr:  true,
        },
    }
 
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            got, err := CalculateDiscount(tt.price, tt.quantity)
 
            if tt.wantErr {
                if err == nil {
                    t.Error("에러를 기대했으나 발생하지 않음")
                }
                return
            }
 
            if err != nil {
                t.Fatalf("예상하지 못한 에러: %v", err)
            }
            if got != tt.want {
                t.Errorf("got %v, want %v", got, tt.want)
            }
        })
    }
}

import (
    "testing"
    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/require"
)
 
func TestUserService_CreateUser(t *testing.T) {
    svc := setupTestService(t)
 
    user, err := svc.CreateUser(ctx, CreateUserRequest{
        Name:  "Kreath",
        Email: "kreath@example.com",
    })
 
    // require -- 실패 시 즉시 테스트 중단
    require.NoError(t, err)
    require.NotNil(t, user)
 
    // assert -- 실패해도 나머지 단언 계속 실행
    assert.Equal(t, "Kreath", user.Name)
    assert.Equal(t, "kreath@example.com", user.Email)
    assert.NotZero(t, user.ID)
    assert.WithinDuration(t, time.Now(), user.CreatedAt, time.Second)
}

import "github.com/stretchr/testify/mock"
 
// 목 객체 정의
type MockUserRepository struct {
    mock.Mock
}
 
func (m *MockUserRepository) FindByID(ctx context.Context, id int64) (*User, error) {
    args := m.Called(ctx, id)
    if args.Get(0) == nil {
        return nil, args.Error(1)
    }
    return args.Get(0).(*User), args.Error(1)
}
 
func (m *MockUserRepository) Save(ctx context.Context, user *User) error {
    args := m.Called(ctx, user)
    return args.Error(0)
}
 
// 테스트에서 목 사용
func TestUserService_GetUser(t *testing.T) {
    mockRepo := new(MockUserRepository)
    svc := NewUserService(mockRepo)
 
    expectedUser := &User{ID: 1, Name: "Kreath"}
    mockRepo.On("FindByID", mock.Anything, int64(1)).Return(expectedUser, nil)
 
    user, err := svc.GetUser(context.Background(), 1)
 
    require.NoError(t, err)
    assert.Equal(t, expectedUser, user)
    mockRepo.AssertExpectations(t)
}
 
// 에러 시나리오 테스트
func TestUserService_GetUser_NotFound(t *testing.T) {
    mockRepo := new(MockUserRepository)
    svc := NewUserService(mockRepo)
 
    mockRepo.On("FindByID", mock.Anything, int64(999)).
        Return(nil, ErrNotFound)
 
    user, err := svc.GetUser(context.Background(), 999)
 
    assert.Nil(t, user)
    assert.ErrorIs(t, err, ErrNotFound)
}

import "net/http/httptest"
 
func TestGetUserHandler(t *testing.T) {
    // 목 서비스 설정
    mockSvc := new(MockUserService)
    handler := NewUserHandler(mockSvc)
 
    expectedUser := &User{ID: 1, Name: "Kreath", Email: "kreath@example.com"}
    mockSvc.On("GetUser", mock.Anything, int64(1)).Return(expectedUser, nil)
 
    // 요청 생성
    req := httptest.NewRequest("GET", "/api/v1/users/1", nil)
    req.SetPathValue("id", "1") // Go 1.22+ 경로 파라미터
 
    // 응답 레코더
    rec := httptest.NewRecorder()
 
    // 핸들러 실행
    handler.GetUser(rec, req)
 
    // 검증
    assert.Equal(t, http.StatusOK, rec.Code)
 
    var response User
    err := json.NewDecoder(rec.Body).Decode(&response)
    require.NoError(t, err)
    assert.Equal(t, "Kreath", response.Name)
}
 
func TestGetUserHandler_NotFound(t *testing.T) {
    mockSvc := new(MockUserService)
    handler := NewUserHandler(mockSvc)
 
    mockSvc.On("GetUser", mock.Anything, int64(999)).
        Return(nil, ErrNotFound)
 
    req := httptest.NewRequest("GET", "/api/v1/users/999", nil)
    req.SetPathValue("id", "999")
    rec := httptest.NewRecorder()
 
    handler.GetUser(rec, req)
 
    assert.Equal(t, http.StatusNotFound, rec.Code)
}

func TestAPI_Integration(t *testing.T) {
    // 전체 앱 설정 (테스트 DB 사용)
    app := setupTestApp(t)
 
    // 테스트 서버 생성
    server := httptest.NewServer(app.Router())
    defer server.Close()
 
    client := server.Client()
 
    // 회원가입
    body := `{"name": "Test", "email": "test@example.com", "password": "secure123"}`
    resp, err := client.Post(server.URL+"/api/v1/auth/register",
        "application/json", strings.NewReader(body))
    require.NoError(t, err)
    assert.Equal(t, http.StatusCreated, resp.StatusCode)
 
    // 로그인
    loginBody := `{"email": "test@example.com", "password": "secure123"}`
    resp, err = client.Post(server.URL+"/api/v1/auth/login",
        "application/json", strings.NewReader(loginBody))
    require.NoError(t, err)
 
    var loginResp LoginResponse
    json.NewDecoder(resp.Body).Decode(&loginResp)
    assert.NotEmpty(t, loginResp.AccessToken)
}

import (
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/modules/postgres"
    "github.com/testcontainers/testcontainers-go/wait"
)
 
func setupTestDB(t *testing.T) *pgxpool.Pool {
    t.Helper()
    ctx := context.Background()
 
    pgContainer, err := postgres.Run(ctx,
        "postgres:16-alpine",
        postgres.WithDatabase("testdb"),
        postgres.WithUsername("testuser"),
        postgres.WithPassword("testpass"),
        testcontainers.WithWaitStrategy(
            wait.ForLog("database system is ready to accept connections").
                WithOccurrence(2).
                WithStartupTimeout(30*time.Second),
        ),
    )
    require.NoError(t, err)
 
    t.Cleanup(func() {
        require.NoError(t, pgContainer.Terminate(ctx))
    })
 
    connStr, err := pgContainer.ConnectionString(ctx, "sslmode=disable")
    require.NoError(t, err)
 
    pool, err := pgxpool.New(ctx, connStr)
    require.NoError(t, err)
 
    // 마이그레이션 실행
    runMigrations(t, connStr)
 
    return pool
}
 
func TestUserRepo_Integration(t *testing.T) {
    if testing.Short() {
        t.Skip("통합 테스트 건너뜀 (-short 플래그)")
    }
 
    pool := setupTestDB(t)
    repo := NewUserRepo(pool)
    ctx := context.Background()
 
    // 생성
    user := &User{Name: "Kreath", Email: "kreath@test.com"}
    err := repo.Create(ctx, user)
    require.NoError(t, err)
    assert.NotZero(t, user.ID)
 
    // 조회
    found, err := repo.FindByID(ctx, user.ID)
    require.NoError(t, err)
    assert.Equal(t, "Kreath", found.Name)
}

func BenchmarkJSONMarshal(b *testing.B) {
    user := User{
        ID:    1,
        Name:  "Kreath",
        Email: "kreath@example.com",
    }
 
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        json.Marshal(user)
    }
}
 
func BenchmarkJSONMarshal_Large(b *testing.B) {
    users := make([]User, 1000)
    for i := range users {
        users[i] = User{ID: int64(i), Name: "User", Email: "user@test.com"}
    }
 
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        json.Marshal(users)
    }
}

# 벤치마크 실행
go test -bench=. -benchmem ./...
 
# 특정 벤치마크만
go test -bench=BenchmarkJSONMarshal -benchmem ./...
 
# 결과 예시
# BenchmarkJSONMarshal-8      5000000     234 ns/op    128 B/op    2 allocs/op

func BenchmarkMapAccess(b *testing.B) {
    m := make(map[string]int)
    for i := 0; i < 1000; i++ {
        m[fmt.Sprintf("key-%d", i)] = i
    }
 
    b.Run("map", func(b *testing.B) {
        for i := 0; i < b.N; i++ {
            _ = m["key-500"]
        }
    })
 
    b.Run("sync.Map", func(b *testing.B) {
        var sm sync.Map
        for k, v := range m {
            sm.Store(k, v)
        }
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            sm.Load("key-500")
        }
    })
}

func FuzzParseUserInput(f *testing.F) {
    // 시드 코퍼스 추가
    f.Add("kreath@example.com")
    f.Add("invalid")
    f.Add("")
    f.Add("a@b.c")
    f.Add(strings.Repeat("a", 1000) + "@test.com")
 
    f.Fuzz(func(t *testing.T, input string) {
        result, err := ParseUserInput(input)
        if err != nil {
            return // 에러는 허용
        }
        // 성공했다면 결과가 유효해야 함
        if result.Email != "" && !strings.Contains(result.Email, "@") {
            t.Errorf("유효하지 않은 이메일이 통과됨: %s", result.Email)
        }
    })
}

# 30초간 퍼징 실행
go test -fuzz=FuzzParseUserInput -fuzztime=30s ./...

단위 테스트 (70%)
- 비즈니스 로직, 유틸리티 함수
- 의존성은 목으로 대체
- 실행 시간: 밀리초 단위
 
통합 테스트 (20%)
- 데이터베이스, 외부 서비스 연동
- testcontainers 또는 테스트 DB 사용
- 실행 시간: 초 단위
 
E2E 테스트 (10%)
- 전체 API 흐름 검증
- httptest.NewServer 활용
- 실행 시간: 수초 단위