🧪 유닛 테스트: Go에서의 커맨드 패턴 vs 모의 객체(Mocks) 🔗

func Benchmark(binary string, sourcePath string, resultPath string, numBuilds int) error {
	if err := build(binary); err != nil {
		return err
	}
	source, err := read(sourcePath)
	if err != nil {
		return err
	}
	
	deltas := []time.Duration{}
	for i := 0; i < numBuilds; i++ {
		if err := write(sourcePath, edit(source, i)); err != nil {
			return err
		}
		
		start := now()
		if err := build(binary); err != nil {
			return err
		}
		
		delta := now().Sub(start)
		deltas = append(deltas, delta)
		
		if err := revert(sourcePath); err != nil {
			return err
		}
	}
	return write(resultPath, report(deltas))
}

func Benchmark(binary string, sourcePath string, source string, numBuilds int) (string, error) {
	// ... 핵심 루프 로직은 그대로 유지 ...
	// 리포트를 파일에 쓰는 대신 리포트 문자열을 반환
	return report(deltas), nil
}

func Main() error {
	// 초기 설정 및 첫 빌드를 이곳으로 이동
	source, _ := read(sourcePath)
	result, _ := Benchmark(binary, sourcePath, source, 3)
	return write(resultPath, result)
}

type Delegate interface {
	Build(binary string) error
	Read(path string) (string, error)
	Write(path string, content string) error
	Now() time.Time
	Revert(path string) error
}

type BenchmarkRunner struct {
	Delegate Delegate
}

func (b *BenchmarkRunner) Run(binary string, sourcePath string, resultPath string, numBuilds int) error {
	// ... b.Delegate.Build(), b.Delegate.Now() 등을 사용하는 구현 ...
}

type Runner interface {
	Run(cmd Command) (Result, error)
}

type BuildCmd struct { Binary string }
type ReadCmd struct { Path string }
type WriteCmd struct { Path string; Content string }
type NowCmd struct {}
type RevertCmd struct { Path string }

type BenchmarkProcess struct {
	runner Runner
}

func (p *BenchmarkProcess) Execute(binary, sourcePath, resultPath string, numBuilds int) error {
	_, err := p.runner.Run(BuildCmd{Binary: binary})
	if err != nil { return err }
	
	readRes, err := p.runner.Run(ReadCmd{Path: sourcePath})
	if err != nil { return err }
	source := readRes.(string) // 여기서 타입 단언(Type assertion)이 필요함

	// ... p.runner.Run()을 사용하는 나머지 루프 로직 ...
}

func TestBenchmark(t *testing.T) {
	// 1. 스크립트 정의: "이 커맨드를 보면 이 결과를 반환하라"
	fakeRunner := NewFakeRunner([]Step{
		{Cmd: BuildCmd{"binary"}, Err: nil},
		{Cmd: ReadCmd{"source_path"}, Res: "source code", Err: nil},
		{Cmd: WriteCmd{"source_path", "edited code"}, Err: nil},
		{Cmd: NowCmd{}, Res: time.Unix(0, 0), Err: nil},
		// ... 이하 생략 ...
	})

	p := BenchmarkProcess{runner: fakeRunner}
	err := p.Execute("binary", "source_path", "result_path", 1)
	
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	
	// 2. runner가 예상된 모든 단계를 소진했는지 검증
	if !fakeRunner.IsDone() {
		t.Fatalf("did not execute all expected commands")
	}
}