Go 테스트 완전 정리

Go code

// calculator_test.go
package main

import (
	"testing"
)

func Add(a, b int) int { return a + b }
func Divide(a, b float64) (float64, error) {
	if b == 0 { return 0, fmt.Errorf("division by zero") }
	return a / b, nil
}

// 기본 테스트
func TestAdd(t *testing.T) {
	got  := Add(2, 3)
	want := 5
	if got != want {
		t.Errorf("Add(2,3) = %d; want %d", got, want)
	}
}

// 테이블 드리븐 테스트 (Go 관용구)
func TestAddTable(t *testing.T) {
	tests := []struct {
		name string
		a, b int
		want int
	}{
		{"양수+양수", 2, 3, 5},
		{"음수포함", -1, 1, 0},
		{"둘다음수", -3, -2, -5},
		{"영포함", 0, 5, 5},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := Add(tt.a, tt.b)
			if got != tt.want {
				t.Errorf("Add(%d,%d) = %d; want %d",
					tt.a, tt.b, got, tt.want)
			}
		})
	}
}

// 벤치마크
func BenchmarkAdd(b *testing.B) {
	for i := 0; i < b.N; i++ {
		Add(100, 200)
	}
}

// 예제 함수 (문서화 + 테스트)
func ExampleAdd() {
	fmt.Println(Add(1, 2))
	// Output: 3
}

// go test ./...        — 테스트 실행
// go test -v ./...     — 상세 출력
// go test -run Table   — 특정 테스트만
// go test -bench=.     — 벤치마크 실행
// go test -cover ./... — 커버리지

Go code

// go get github.com/stretchr/testify
package main

import (
	"testing"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/mock"
)

// 인터페이스 정의
type UserRepo interface {
	FindByID(id int) (*User, error)
	Save(u *User) error
}

// Mock 구현
type MockUserRepo struct {
	mock.Mock
}

func (m *MockUserRepo) FindByID(id int) (*User, error) {
	args := m.Called(id)
	return args.Get(0).(*User), args.Error(1)
}

func (m *MockUserRepo) Save(u *User) error {
	return m.Called(u).Error(0)
}

// 서비스
type UserService struct{ repo UserRepo }

func (s *UserService) GetUser(id int) (*User, error) {
	return s.repo.FindByID(id)
}

// 테스트
func TestGetUser(t *testing.T) {
	mockRepo := new(MockUserRepo)
	expected := &User{ID: 1, Name: "Alice"}

	// Mock 설정
	mockRepo.On("FindByID", 1).Return(expected, nil)

	svc := &UserService{repo: mockRepo}
	user, err := svc.GetUser(1)

	// assert — 실패해도 계속
	assert.NoError(t, err)
	assert.Equal(t, expected.Name, user.Name)
	assert.NotNil(t, user)

	// require — 실패 시 즉시 중단
	require.NotNil(t, user)

	// Mock 호출 검증
	mockRepo.AssertExpectations(t)
	mockRepo.AssertCalled(t, "FindByID", 1)
}

Go code

<span class="cm">// min/max 내장 함수 (Go 1.21+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("min/max 내장 함수 (Go 1.21+)") }

Go code

package main

import (
	"fmt"
	"strings"
	"testing"
)

// 벤치마크 대상 함수들
func ConcatPlus(strs []string) string {
	result := ""
	for _, s := range strs {
		result += s
	}
	return result
}

func ConcatBuilder(strs []string) string {
	var b strings.Builder
	for _, s := range strs {
		b.WriteString(s)
	}
	return b.String()
}

func ConcatJoin(strs []string) string {
	return strings.Join(strs, "")
}

// 벤치마크 테스트 (파일명: concat_test.go)
func BenchmarkConcatPlus(b *testing.B) {
	strs := make([]string, 100)
	for i := range strs {
		strs[i] = "hello"
	}
	b.ResetTimer() // 준비 시간 제외
	for i := 0; i < b.N; i++ {
		ConcatPlus(strs)
	}
}

func BenchmarkConcatBuilder(b *testing.B) {
	strs := make([]string, 100)
	for i := range strs {
		strs[i] = "hello"
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ConcatBuilder(strs)
	}
}

func BenchmarkConcatJoin(b *testing.B) {
	strs := make([]string, 100)
	for i := range strs {
		strs[i] = "hello"
	}
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		ConcatJoin(strs)
	}
}

// 서브 벤치마크로 크기별 비교
func BenchmarkConcat(b *testing.B) {
	sizes := []int{10, 100, 1000}
	for _, size := range sizes {
		strs := make([]string, size)
		for i := range strs {
			strs[i] = "x"
		}
		b.Run(fmt.Sprintf("Plus/%d", size), func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				ConcatPlus(strs)
			}
		})
		b.Run(fmt.Sprintf("Builder/%d", size), func(b *testing.B) {
			for i := 0; i < b.N; i++ {
				ConcatBuilder(strs)
			}
		})
	}
}

// 메모리 할당 추적
func BenchmarkMemory(b *testing.B) {
	strs := make([]string, 100)
	for i := range strs {
		strs[i] = "test"
	}
	b.ReportAllocs() // 메모리 할당 보고
	for i := 0; i < b.N; i++ {
		ConcatBuilder(strs)
	}
}

// 실행: go test -bench=. -benchmem -count=3
func main() {
	fmt.Println("벤치마크 실행 방법:")
	fmt.Println("  go test -bench=. -benchmem")
	fmt.Println("  go test -bench=BenchmarkConcat -benchtime=5s")
	fmt.Println("  go test -bench=. -cpuprofile=cpu.prof")
}

Go code

package main

import (
	"fmt"
	"testing"
)

func Add(a, b int) int { return a + b }

func TestAdd(t *testing.T) {
	tests := []struct {
		name     string
		a, b     int
		expected int
	}{
		{"양수 덧셈", 2, 3, 5},
		{"음수 포함", -1, 5, 4},
		{"제로", 0, 0, 0},
		{"큰 수", 1000000, 1, 1000001},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := Add(tt.a, tt.b)
			if got != tt.expected {
				t.Errorf("Add(%d, %d) = %d, want %d",
					tt.a, tt.b, got, tt.expected)
			}
		})
	}
}

func main() {
	// go test -v -run TestAdd
	fmt.Println("테이블 기반 테스트: go test -v")
}

Go code

package main

import (
	"fmt"
	"testing"
)

func TestUserService(t *testing.T) {
	// 셋업
	// db := setupTestDB(t)

	t.Run("Create", func(t *testing.T) {
		t.Run("유효한 입력", func(t *testing.T) {
			// 테스트 코드
		})
		t.Run("중복 이메일", func(t *testing.T) {
			// 테스트 코드
		})
	})

	t.Run("Find", func(t *testing.T) {
		t.Run("존재하는 ID", func(t *testing.T) {
			// 테스트 코드
		})
		t.Run("존재하지 않는 ID", func(t *testing.T) {
			// 테스트 코드
		})
	})

	// 병렬 서브테스트
	t.Run("Parallel", func(t *testing.T) {
		tests := []string{"test1", "test2", "test3"}
		for _, name := range tests {
			t.Run(name, func(t *testing.T) {
				t.Parallel() // 병렬 실행
				// 독립적인 테스트
			})
		}
	})
}

func main() {
	// go test -v -run TestUserService/Create/유효한_입력
	fmt.Println("서브테스트: go test -v -run TestX/SubTest")
}

Go code

package main

import (
	"fmt"
	"strings"
	"testing"
)

// 문자열 연결 벤치마크 비교
func BenchmarkConcat(b *testing.B) {
	b.Run("Plus", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			s := ""
			for j := 0; j < 100; j++ {
				s += "x"
			}
		}
	})

	b.Run("Builder", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			var sb strings.Builder
			for j := 0; j < 100; j++ {
				sb.WriteString("x")
			}
			_ = sb.String()
		}
	})

	b.Run("Join", func(b *testing.B) {
		parts := make([]string, 100)
		for i := range parts { parts[i] = "x" }
		b.ResetTimer() // 준비 시간 제외
		for i := 0; i < b.N; i++ {
			_ = strings.Join(parts, "")
		}
	})
}

func main() {
	// go test -bench=. -benchmem -count=5
	fmt.Println("벤치마크: go test -bench=BenchmarkConcat -benchmem")
}

Go code

package main

import (
	"fmt"
	"testing"
)

// 테스트 헬퍼
func assertEqual[T comparable](t *testing.T, got, want T) {
	t.Helper() // 에러 위치를 호출자로 표시
	if got != want {
		t.Errorf("got %v, want %v", got, want)
	}
}

func assertNoError(t *testing.T, err error) {
	t.Helper()
	if err != nil {
		t.Fatalf("예상치 못한 에러: %v", err)
	}
}

func assertError(t *testing.T, err error) {
	t.Helper()
	if err == nil {
		t.Fatal("에러를 기대했지만 nil")
	}
}

// 테스트 픽스처
func setupTest(t *testing.T) func() {
	t.Helper()
	fmt.Println("테스트 셋업")
	// DB 연결, 임시 파일 생성 등

	return func() {
		fmt.Println("테스트 정리")
		// 리소스 해제
	}
}

func TestExample(t *testing.T) {
	cleanup := setupTest(t)
	defer cleanup()
	// 또는 Go 1.14+: t.Cleanup(func() { ... })

	assertEqual(t, 1+1, 2)
	assertNoError(t, nil)
}

func main() {
	fmt.Println("t.Helper()로 에러 위치를 정확히 표시")
}

Go code

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
)

func healthHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
}

func TestHealthHandler(t *testing.T) {
	req := httptest.NewRequest("GET", "/health", nil)
	rec := httptest.NewRecorder()

	healthHandler(rec, req)

	if rec.Code != 200 {
		t.Errorf("상태 코드: got %d, want 200", rec.Code)
	}

	var resp map[string]string
	json.Unmarshal(rec.Body.Bytes(), &resp)
	if resp["status"] != "ok" {
		t.Errorf("상태: got %s, want ok", resp["status"])
	}
}

// 테스트 서버로 통합 테스트
func TestWithServer(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(healthHandler))
	defer srv.Close()

	resp, err := http.Get(srv.URL + "/health")
	if err != nil { t.Fatal(err) }
	defer resp.Body.Close()

	if resp.StatusCode != 200 {
		t.Errorf("상태: %d", resp.StatusCode)
	}
}

func main() {
	fmt.Println("httptest: 핸들러 단위 테스트 & 서버 통합 테스트")
}

Go code

package main

import (
	"errors"
	"fmt"
	"testing"
)

type Mailer interface {
	Send(to, subject, body string) error
}

// 수동 목 구현
type MockMailer struct {
	SendFunc  func(to, subject, body string) error
	SendCalls []struct{ To, Subject, Body string }
}

func (m *MockMailer) Send(to, subject, body string) error {
	m.SendCalls = append(m.SendCalls, struct{ To, Subject, Body string }{to, subject, body})
	if m.SendFunc != nil { return m.SendFunc(to, subject, body) }
	return nil
}

type NotifyService struct{ mailer Mailer }

func (s *NotifyService) Welcome(email string) error {
	return s.mailer.Send(email, "환영합니다", "가입을 축하합니다!")
}

func TestWelcome(t *testing.T) {
	mock := &MockMailer{}
	svc := &NotifyService{mailer: mock}

	err := svc.Welcome("user@go.dev")
	if err != nil { t.Fatal(err) }

	if len(mock.SendCalls) != 1 { t.Fatal("Send 호출 1회 기대") }
	if mock.SendCalls[0].To != "user@go.dev" { t.Error("잘못된 수신자") }

	// 에러 시나리오
	mock.SendFunc = func(_, _, _ string) error { return errors.New("전송 실패") }
	err = svc.Welcome("fail@go.dev")
	if err == nil { t.Error("에러 기대") }
}

func main() {
	fmt.Println("인터페이스 기반 목 테스트 패턴")
}

Go code

package main

import (
	"context"
	"fmt"
	"testing"
	"time"
)

// 테스트 가능한 시간 인터페이스
type Clock interface {
	Now() time.Time
}

type RealClock struct{}
func (c RealClock) Now() time.Time { return time.Now() }

type FakeClock struct{ Fixed time.Time }
func (c FakeClock) Now() time.Time { return c.Fixed }

// 테스트 가능한 서비스
type TokenService struct{ clock Clock }

func (s *TokenService) Generate() string {
	t := s.clock.Now()
	return fmt.Sprintf("token_%d", t.Unix())
}

func (s *TokenService) IsExpired(token string, maxAge time.Duration) bool {
	// 토큰 생성 시각과 현재 시각 비교
	return false // 간단한 예시
}

func TestTokenGeneration(t *testing.T) {
	fixed := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
	svc := &TokenService{clock: FakeClock{Fixed: fixed}}

	token := svc.Generate()
	expected := fmt.Sprintf("token_%d", fixed.Unix())
	if token != expected {
		t.Errorf("got %s, want %s", token, expected)
	}
}

func main() {
	_ = context.Background()
	fmt.Println("인터페이스로 시간, 랜덤, IO를 테스트 가능하게")
}

Go code

package main

import (
	"fmt"
	"os"
	"testing"
)

// 통합 테스트 스킵 헬퍼
func skipIfShort(t *testing.T) {
	t.Helper()
	if testing.Short() {
		t.Skip("통합 테스트: -short 모드에서 건너뜀")
	}
}

func skipIfNoEnv(t *testing.T, key string) {
	t.Helper()
	if os.Getenv(key) == "" {
		t.Skipf("통합 테스트: %s 환경 변수 필요", key)
	}
}

func TestDatabaseIntegration(t *testing.T) {
	skipIfShort(t)
	skipIfNoEnv(t, "TEST_DB_URL")

	// dsn := os.Getenv("TEST_DB_URL")
	// db, err := sql.Open("postgres", dsn)
	// ...실제 DB 테스트

	t.Run("CreateUser", func(t *testing.T) {
		// DB에 사용자 생성 후 조회
	})

	t.Run("Transaction", func(t *testing.T) {
		// 트랜잭션 테스트
	})
}

// 파일 상단에 빌드 태그 사용 (Go 1.17+):
// //go:build integration

func main() {
	fmt.Println("통합 테스트 실행:")
	fmt.Println("  go test -v                    # 단위만")
	fmt.Println("  go test -v -short             # 빠른 테스트만")
	fmt.Println("  go test -v -tags integration  # 통합 포함")
}

Go code

package main

import (
	"fmt"
	"testing"
)

func Abs(n int) int {
	if n < 0 { return -n }
	return n
}

func Clamp(val, min, max int) int {
	if val < min { return min }
	if val > max { return max }
	return val
}

func TestAbs(t *testing.T) {
	tests := []struct{ input, want int }{
		{-5, 5}, {5, 5}, {0, 0},
	}
	for _, tt := range tests {
		if got := Abs(tt.input); got != tt.want {
			t.Errorf("Abs(%d) = %d, want %d", tt.input, got, tt.want)
		}
	}
}

func TestClamp(t *testing.T) {
	if Clamp(5, 0, 10) != 5 { t.Error("범위 내 실패") }
	if Clamp(-5, 0, 10) != 0 { t.Error("하한 실패") }
	if Clamp(15, 0, 10) != 10 { t.Error("상한 실패") }
}

func main() {
	fmt.Println("커버리지 명령어:")
	fmt.Println("  go test -cover              # 커버리지 %")
	fmt.Println("  go test -coverprofile=c.out  # 프로파일 생성")
	fmt.Println("  go tool cover -html=c.out    # HTML 보고서")
	fmt.Println("  go tool cover -func=c.out    # 함수별 커버리지")
}

Go code

package main

import (
	"fmt"
	"testing"
	"unicode/utf8"
)

func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func FuzzReverse(f *testing.F) {
	// 시드 코퍼스 (초기 입력)
	f.Add("hello")
	f.Add("세계")
	f.Add("")
	f.Add("🌍🎉")

	f.Fuzz(func(t *testing.T, orig string) {
		rev := Reverse(orig)
		doubleRev := Reverse(rev)

		// 불변식 검증
		if orig != doubleRev {
			t.Errorf("두 번 뒤집기 실패: %q → %q → %q",
				orig, rev, doubleRev)
		}
		if utf8.ValidString(orig) && !utf8.ValidString(rev) {
			t.Errorf("유효한 UTF-8이 뒤집기 후 무효: %q", orig)
		}
	})
}

func main() {
	fmt.Println("퍼즈 테스트:")
	fmt.Println("  go test -fuzz=FuzzReverse            # 퍼즈 실행")
	fmt.Println("  go test -fuzz=FuzzReverse -fuzztime=30s # 30초간 실행")
}

Go code

package main

import (
	"flag"
	"fmt"
	"os"
	"path/filepath"
	"testing"
)

var update = flag.Bool("update", false, "골든 파일 업데이트")

func golden(t *testing.T, name string, actual []byte) {
	t.Helper()
	path := filepath.Join("testdata", name+".golden")

	if *update {
		os.MkdirAll("testdata", 0755)
		os.WriteFile(path, actual, 0644)
		return
	}

	expected, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("골든 파일 없음: %s (--update로 생성)", path)
	}

	if string(actual) != string(expected) {
		t.Errorf("골든 파일 불일치:\n기대:\n%s\n실제:\n%s",
			string(expected), string(actual))
	}
}

func GenerateReport(name string) string {
	return fmt.Sprintf("=== 보고서 ===\n이름: %s\n상태: 정상\n", name)
}

func TestReport(t *testing.T) {
	actual := GenerateReport("테스트")
	golden(t, "report", []byte(actual))
}

func main() {
	fmt.Println("골든 파일 테스트:")
	fmt.Println("  go test -run TestReport -update  # 골든 파일 생성/업데이트")
	fmt.Println("  go test -run TestReport           # 비교 테스트")
}

Go code

package main

import (
	"context"
	"fmt"
	"testing"
)

// testcontainers-go 사용 예시
// import "github.com/testcontainers/testcontainers-go"

type TestDB struct {
	Host string
	Port int
	// container testcontainers.Container
}

func SetupPostgres(t *testing.T) *TestDB {
	t.Helper()

	// ctx := context.Background()
	// req := testcontainers.ContainerRequest{
	//     Image:        "postgres:16",
	//     ExposedPorts: []string{"5432/tcp"},
	//     Env: map[string]string{
	//         "POSTGRES_PASSWORD": "test",
	//         "POSTGRES_DB":       "testdb",
	//     },
	//     WaitingFor: wait.ForListeningPort("5432/tcp"),
	// }
	// container, _ := testcontainers.GenericContainer(ctx, req)
	// host, _ := container.Host(ctx)
	// port, _ := container.MappedPort(ctx, "5432")

	db := &TestDB{Host: "localhost", Port: 5432}

	t.Cleanup(func() {
		fmt.Println("컨테이너 정리")
		// container.Terminate(ctx)
	})

	return db
}

func TestWithPostgres(t *testing.T) {
	if testing.Short() { t.Skip("통합 테스트") }
	db := SetupPostgres(t)
	fmt.Printf("테스트 DB: %s:%d\n", db.Host, db.Port)
}

func main() {
	_ = context.Background()
	fmt.Println("testcontainers: Docker 기반 통합 테스트")
}

Go code

package main

import (
	"fmt"
	"sync"
	"testing"
)

// 레이스 컨디션이 있는 코드 (나쁜 예)
type UnsafeCounter struct {
	count int
}

func (c *UnsafeCounter) Inc() { c.count++ }
func (c *UnsafeCounter) Get() int { return c.count }

// 안전한 버전
type SafeCounter struct {
	mu    sync.Mutex
	count int
}

func (c *SafeCounter) Inc() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.count++
}

func (c *SafeCounter) Get() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.count
}

func TestRace(t *testing.T) {
	c := &SafeCounter{}
	var wg sync.WaitGroup

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			c.Inc()
		}()
	}
	wg.Wait()

	if c.Get() != 100 {
		t.Errorf("카운터: got %d, want 100", c.Get())
	}
}

func main() {
	fmt.Println("레이스 디텍터:")
	fmt.Println("  go test -race ./...   # 모든 테스트에 레이스 감지")
	fmt.Println("  go build -race        # 바이너리에 레이스 감지 포함")
	fmt.Println("  go run -race main.go  # 실행 시 감지")
}

Go code

package main

import (
	"fmt"
	"testing"
	"time"
)

func TestParallel(t *testing.T) {
	tests := []struct {
		name     string
		duration time.Duration
	}{
		{"빠른 테스트", 100 * time.Millisecond},
		{"중간 테스트", 200 * time.Millisecond},
		{"느린 테스트", 300 * time.Millisecond},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel() // 병렬 실행 선언

			// 독립적인 테스트 로직
			time.Sleep(tt.duration)
			// 순차: 600ms, 병렬: ~300ms
		})
	}
}

// 병렬 테스트에서 공유 리소스
func TestParallelWithSetup(t *testing.T) {
	// 셋업은 직렬로
	// db := setupTestDB(t)

	t.Run("group", func(t *testing.T) {
		t.Run("test1", func(t *testing.T) {
			t.Parallel()
			// db 사용 (읽기만)
		})
		t.Run("test2", func(t *testing.T) {
			t.Parallel()
			// db 사용 (읽기만)
		})
	})
	// 모든 병렬 서브테스트 완료 후 정리
}

func main() {
	fmt.Println("병렬 테스트: go test -v -parallel 4")
}

Go code

package main

import "fmt"

func main() {
	fmt.Println("=== CI/CD Go 테스트 전략 ===")
	fmt.Println()
	fmt.Println("1단계: 빠른 검증 (PR 체크)")
	fmt.Println("  go vet ./...")
	fmt.Println("  staticcheck ./...")
	fmt.Println("  go test -short -count=1 ./...")
	fmt.Println()
	fmt.Println("2단계: 전체 테스트")
	fmt.Println("  go test -race -count=1 ./...")
	fmt.Println("  go test -cover -coverprofile=coverage.out ./...")
	fmt.Println()
	fmt.Println("3단계: 통합 테스트")
	fmt.Println("  go test -v -tags=integration -count=1 ./...")
	fmt.Println()
	fmt.Println("4단계: 벤치마크 (주간)")
	fmt.Println("  go test -bench=. -benchmem -count=5 ./...")
	fmt.Println()
	fmt.Println("5단계: 퍼즈 테스트 (야간)")
	fmt.Println("  go test -fuzz=. -fuzztime=5m ./...")
	fmt.Println()
	fmt.Println("캐싱:")
	fmt.Println("  GOMODCACHE, GOCACHE 디렉토리를 CI 캐시에 저장")
	fmt.Println("  go test -count=1 로 캐시 무효화 (CI에서 권장)")
}