21.1. 프로그램언어 고(Go)의 유닛 테스팅

by

프로그램언어 고(Go)의 유닛 테스팅 기본개념

Go언어의 유닛 테스트는 테스트 주도 개발(TDD)의 핵심 기술 중 하나입니다. 유닛 테스트를 통해 프로그램의 기능 단위별로 정확성을 검증하고 버그를 발견할 수 있습니다.

Go언어의 표준 라이브러리 testing 패키지가 유닛 테스트를 위한 다양한 기능을 제공합니다.


package calculator

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

위 코드는 간단한 덧셈 기능을 제공하는 Add() 함수입니다. 이를 테스트 하기 위해서는 다음과 같이 테스트 코드를 작성할 수 있습니다.


package calculator

import "testing"

func TestAdd(t *testing.T) {
    total := Add(10, 5)
    if total != 15 { 
        t.Errorf("Add(10, 5) failed, got %d, want 15", total)
    }
}

– testing 패키지를 import 합니다.
– TestXXX 형태의 테스트 함수를 정의합니다. XXX는 테스트하고자 하는 대상 함수입니다.
– 테스트 함수 매개변수 t는 *testing.T 타입으로, 테스트에 실패했을 때 에러를 기록할 수 있습니다.
– Add() 함수를 실행하고기대하는값과 실제 결과를 비교합니다. 값이 일치하지 않으면t.Errorf()를 사용해 에러를 기록합니다.

이 테스트 코드를 go test 명령으로 실행하면 테스트 결과를 확인할 수 있습니다.

유닛 테스트 코드는 대상 함수 코드와 별개로 관리됩니다. 테스트가 필요한 대상 함수마다 별도의 테스트 함수를 작성하는 식입니다.

Go언어의 테스트 기능을 활용하면 TDD 방식으로 안정적인 코드를 개발할 수 있습니다. 기능 추가시마다 먼저 테스트 코드를 작성하고 이를 통과하는 코드를 개발하는 프로세스를 거치면 됩니다.

이외에도 테스트의 입출력을 가짜로 구현하는 mock 기능, 테스트 반복 실행기능 등 유용한 기능들이 있습니다. Go언어 표준 라이브러리와 함께 제공되는 테스트 패키지를 잘 활용한다면 효과적으로 유닛테스트를 도입할 수 있을 것 입니다.

이해가 가셨다면 기쁘겠습니다.

프로그램언어 고(Go)에서의 유닛 테스팅 실제 예제

고(Go)언어에서 유닛 테스트를 하는 실제 예제를 설명드리겠습니다.

package calculator

import "testing"

func TestAdd(t *testing.T) {
    total := Add(2, 3)
    if total != 5 {
        t.Errorf("Add was incorrect, got: %d, want: %d", total, 5)
    }
}

위 예제는 계산기 패키지의 Add 함수에 대한 간단한 유닛 테스트 예제입니다.

main 패키지가 아닌 다른 패키지의 함수를 테스트하고 싶다면 해당 패키지를 import 해주어야 합니다.

테스트 함수 이름은 주로 Test로 시작하며, 테스트하고 싶은 함수 이름으로 마무리합니다. 위 예제의 경우 Add 함수를 테스트하고 있으므로 TestAdd라는 이름을 사용했습니다.

테스트 함수의 인자로 *testing.T 타입을 받습니다. 이 인터페이스에는 테스트 결과를 출력하는 Error, Errorf와 같은 메서드가 정의되어 있습니다.

테스트 로직은 주로 다음과 같은 흐름으로 작성합니다.

1. 테스트하고 싶은 함수를 호출하고 결과값을 얻습니다.

2. 얻어낸 결과값이 예상한 값과 맞는지 확인합니다.

3. 맞지 않는 경우 t.Errorf 등을 사용하여 테스트 실패 에러를 기록합니다.

Add 함수에 2와 3을 전달했을 때 5가 반환되어야 한다고 가정했습니다.

따라서 Add(2, 3)의 결과값 total과 5를 비교하는 단순한 테스트 코드를 작성했습니다.

위 예제처럼 고루틴을 사용하지 않는 단순한 함수들은 이런 식으로 직접 결과를 검증할 수 있습니다.

유닛테스트에 대한 더 자세한 설명이 필요하시다면 말씀해 주세요. 가능한 친절하고 쉽게 설명드리겠습니다.

프로그램언어 고(Go)의 유닛 테스팅 도구 사용 방법

Go언어의 유닛 테스트를 위한 도구 사용 방법을 최대한 친절하고 상세하게 설명드리겠습니다.

Go언어에서 유닛 테스트를 위해 주로 사용하는 도구는 testing 패키지와 testify 패키지입니다.


import "testing"

func TestSplit(t *testing.T) {
    got := Split("a:b:c", ":")
    want := []string{"a", "b", "c"}

    if !reflect.DeepEqual(want, got) {
        t.Errorf("Expected %v, got %v", want, got)
    }
}

위 코드는 testing 패키지를 이용한 기본적인 유닛 테스트 예제입니다.
t.Errorf 메서드를 사용하여 검증 로직을 추가할 수 있습니다.


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

func TestSomething(t *testing.T) {
    var a string = "Hello"
    var b string = "Hello"

    assert.Equal(t, a, b, "The two words should be the same")
}

testify 패키지는 assert 메서드를 제공하여 보다 편리하게 검증 로직을 추가할 수 있습니다.

유닛 테스트는 다음과 같은 장점이 있습니다.

– 코드 변경시 기존 동작 확인 가능
– 문서화 효과
– 코드 설계 개선
– 버그 발견 용이

따라서 Go언어로 개발 시에는 반드시 유닛 테스트를 작성하는 것이 좋습니다.

매 테스트마다 t.Run()을 사용하여 하위 테스트도 구분할 수 있습니다.
benchamrk 테스트로 성능을 검증할 수도 있습니다.

이와 같이 Go언어의 테스트 도구 사용법을 최대한 친절하고 상세하게 설명드렸습니다.
추가적인 질문이 있으시면 언제든 질문해 주세요.

프로그램언어 고(Go)에서의 유닛 테스팅 경험담

Go언어에서 유닛테스트를 하는 경험에 대해 설명드리겠습니다. Go언어는 테스트를 위한 표준 라이브러리를 제공하므로 테스트 코드를 작성하고 실행하는 것이 매우 쉽습니다. 


func Calculate(x, y int) int {
    return x + y
}

func TestCalculate(t *testing.T) {
    total := Calculate(1, 2)
    if total != 3 {
        t.Errorf("Calculate was incorrect, got: %d, want: %d.", total, 3)
    }
}

위 예제코드는 Calculate라는 함수의 테스트 코드입니다. TestCalculate 함수가 실행되면 Calculate 함수에 1과 2를 전달하여 반환값이 3인지 검증합니다. 반환값이 3이 아니면 t.Errorf를 사용하여 에러 메시지를 출력합니다.

이런 식으로 테스트 함수를 작성하고 go test 명령어로 실행할 수 있습니다. 여러 테스트 함수를 작성할 수 있고, 테스트 코드 파일당 하나의 테스트 함수만 있어도 됩니다.

테스트 함수의 이름은 반드시 Test로 시작해야 하며, 파라미터는 *testing.T 형식이어야 합니다. 여기에는 에러 정보를 출력할 수 있는 메소드들이 정의되어 있습니다.


func TestSum(t *testing.T) {

    totals := []struct{
        values [2]int
        expected int
    }{
        {[2]int{1, 2}, 3},
        {[2]int{10, 5}, 15},
        {[2]int{5, 2}, 7},
    }

    for _, pair := range totals {
        total := Sum(pair.values[0], pair.values[1])
        if total != pair.expected {
            t.Errorf("Sum was incorrect, got: %d, want: %d.", total, pair.expected)
        }
    }

}

func Sum(x, y int) int {
    return x + y
}

이 예제는 입력값과 기두값을 저장한 totals slice를 사용하여 Sum 함수에 대한 여러 개의 테스트 케이스를 동시에 실행합니다. 반복문을 사용하여 매 테스트 케이스마다 Sum 함수를 호출하고 반환값이 일치하는지 검증합니다.

이처럼 데이터 기반의 테스트도 손쉽게 작성할 수 있습니다. 또한 Go언어 표준 라이브러리를 사용하여 복잡한 입력 데이터를 생성하거나, 정규식을 이용한 문자열 검증, 시간 관련 검증 등 다양한 테스트 기능을 제공받을 수 있습니다.

Go 언어의 테스트 문화는 TDD(Test Driven Development)를 매우 권장하므로, 기능 구현에 앞서 그 기능에 대한 테스트 코드를 먼저 작성하는 것이 일반적입니다. 이를 통해 프로그램의 안정성과 신뢰성을 높일 수 있습니다.

유닛테스트는 Go언어 프로그래밍에 있어 매우 중요한 부분을 차지합니다. 표준 라이브러리의 지원으로 손쉽게 다양한 테스트를 작성할 수 있고 TDD 문화 덕분에 개발 생산성 향상과 코드 품질 개선의 효과를 볼 수 있습니다.

이상 Go언어의 유닛테스트에 대한 제 경험을 설명드렸습니다. 잘못된 부분이 있다면 양해 부탁드립니다.

프로그램언어 고(Go)의 유닛 테스팅 주의사항

고(Go)언어의 유닛 테스트를 작성할 때 다음과 같은 주의사항이 있습니다.


package main

import "testing"

func TestSplit(t *testing.T) {
    got := Split("a:b:c", ":")
    want := []string{"a", "b", "c"}

    if !reflect.DeepEqual(want, got) {
        t.Errorf("Expected %v, got %v", want, got)
    }
}

위 코드에서 볼 수 있듯이 테스트 함수 이름은 Test로 시작해야 합니다. 또한 테스트 함수의 매개변수는 *testing.T 형식이어야 하며 이를 사용하여 테스트가 실패한 경우 에러를 기록할 수 있습니다.


func TestExample(t *testing.T) {

    // 준비 단계
    input := generateInput()
    expected := runAlgorithm(input)

    // 테스트 실행
    actual := executeFunction(input)

    // 검증
    if expected != actual {
        t.Errorf("Expected %v but got %v", expected, actual) 
    }

}

위 코드에서 볼 수 있듯이 일반적으로 테스트는 준비, 실행, 검증의 단계를 거치게 됩니다. 입력 데이터를 준비하고 기댓값을 계산한 후 실제 함수를 실행하여 결과를 검증하는 플로우가 보편적입니다.

또한 독립성을 위해 테스트 함수간에 공유하는 전역변수는 지양해야 합니다. 테스트 함수가 서로 영향을 미치지 않도록 주의하는 것이 좋습니다.


func TestA(t *testing.T) {
    x = 0 // 전역변수 사용

    x++

    if x != 1 {
       t.Error("x should be 1") 
    }
}

func TestB(t *testing.T) {

    if x != 0 { // 예상하지 못한 값
       t.Error("x should be 0")  
    }

}

위 경우에서 볼 수 있듯이 전역 상태를 변경하면 테스트의 독립성이 깨지고 예상치 못한 결과를 초래할 수 있습니다.

이 외에도 테스트에 사용되는 입력 데이터의 크기에 주의를 기울여야 합니다. 과다한 양의 데이터는 테스트 시간을 늘릴 수 있습니다. 반대로 충분하지 않은 데이터는 정확성을 해칠 수 있습니다. 적당한 크기를 유지하는 것이 중요합니다.

마지막으로 테스트 결과를 쉽게 해석할 수 있도록 충분한 로깅과 오류 메시지를 제공하는 것이 좋습니다. 무슨 문제가 발생했는지 파악하기 어렵다면 디버깅 하는데 시간이 오래 걸릴 수 있습니다.

이상 고(Go)언어의 유닛테스트 작성시 주의할 점에 대하여 설명 드렸습니다. 잘못된 점이 있다면 양해 부탁드립니다.

Leave a Comment