PHPUnit에서 Go까지: Go 개발자를 위한 데이터 기반 단위 테스트

이 게시물에서는 PHP 단위 테스트 사고방식, 특히 PHPUnit 프레임워크의 데이터 제공자 접근 방식을 Go에 적용하는 방법을 살펴보겠습니다. 숙련된 PHP 개발자라면 테스트 데이터를 원시 배열로 별도로 수집하고 이 데이터를 테스트 함수에 공급하는 데이터 공급자 모델에 익숙할 것입니다. 이 접근 방식을 사용하면 단위 테스트가 더욱 깔끔하고 유지 관리가 용이해지며 개방형/폐쇄형과 같은 원칙을 준수하게 됩니다.

왜 데이터 제공자 접근 방식인가?

Go에서 구조 단위 테스트에 데이터 공급자 접근 방식을 사용하면 다음과 같은 여러 가지 이점을 얻을 수 있습니다.

향상된 가독성 및 확장성: 각 테스트 시나리오를 나타내는 상단의 명확하게 구분된 배열을 통해 테스트가 시각적으로 구성됩니다. 각 배열의 키는 시나리오를 설명하고 해당 콘텐츠에는 해당 시나리오를 테스트하기 위한 데이터가 포함됩니다. 이러한 구조로 인해 파일 작업이 즐겁고 확장이 쉬워졌습니다.

관심사 분리: 데이터 제공자 모델은 데이터와 테스트 논리를 분리하여 시간이 지나도 크게 변하지 않고 유지될 수 있는 가볍고 분리된 기능을 제공합니다. 새로운 시나리오를 추가하려면 제공자에 더 많은 데이터를 추가하기만 하면 됩니다. 즉, 테스트 기능을 확장을 위해 열어두고 수정을 위해 닫아두는 것입니다. 이는 테스트에 개방/폐쇄 원칙을 실제로 적용한 것입니다.

일부 프로젝트에서는 별도의 JSON 파일을 데이터 소스로 사용하고 수동으로 구축하여 공급자에게 공급한 후 테스트 기능에 데이터를 공급할 만큼 밀도가 높은 시나리오도 보았습니다.

데이터 공급자를 사용하는 것이 매우 권장되는 경우는 언제입니까?

다양한 데이터가 포함된 테스트 사례가 많은 경우 특히 데이터 공급자를 사용하는 것이 좋습니다. 각 테스트 사례는 개념적으로 유사하지만 입력 및 예상 출력만 다릅니다.

단일 테스트 기능에 데이터와 로직을 혼합하면 개발자 경험(DX)이 줄어들 수 있습니다. 이는 종종 다음과 같은 결과로 이어집니다.

자세한 내용 오버로드: 약간의 데이터 변형이 있는 명령문을 반복하는 중복 코드로 인해 추가적인 이점 없이 장황한 코드베이스가 됩니다.

명확성 감소: 주변 코드에서 실제 테스트 데이터를 분리하려고 할 때 테스트 기능을 통해 스캔하는 것은 번거로운 일이 되며, 데이터 제공자 접근 방식을 통해 자연스럽게 이러한 문제가 완화됩니다.

좋습니다. 그렇다면 정확히 데이터 공급자란 무엇인가요?

기본적으로 제공자 함수가 암시적 루프에서 사용되는 다양한 데이터 세트를 테스트 함수에 제공하는 PHPUnit의 DataProvider 패턴입니다. 핵심 테스트 기능 로직을 변경하지 않고도 테스트 시나리오를 더 쉽게 추가하거나 수정할 수 있도록 하여 DRY(Don't Repeat Yourself) 원칙을 보장하고 개방/폐쇄 원칙에도 부합합니다.

데이터 제공자 없이 문제를 해결하시겠습니까?

장황함, 코드 중복 및 유지 관리 문제의 단점을 설명하기 위해 다음은 데이터 제공자의 도움 없이 버블 정렬 기능에 대한 단위 테스트의 예를 보여줍니다.

<?php declare(strict_types=1);

use PHPUnit\Framework\TestCase;

final class BubbleSortTest extends TestCase
{
    public function testBubbleSortEmptyArray()
    {
        $this->assertSame([], BubbleSort([]));
    }

    public function testBubbleSortOneElement()
    {
        $this->assertSame([0], BubbleSort([0]));
    }

    public function testBubbleSortTwoElementsSorted()
    {
        $this->assertSame([5, 144], BubbleSort([5, 144]));
    }

    public function testBubbleSortTwoElementsUnsorted()
    {
        $this->assertSame([-7, 10], BubbleSort([10, -7]));
    }

    public function testBubbleSortMultipleElements()
    {
        $this->assertSame([1, 2, 3, 4], BubbleSort([1, 3, 4, 2]));
    }

    // And so on for each test case, could be 30 cases for example.

    public function testBubbleSortDescendingOrder()
    {
        $this->assertSame([1, 2, 3, 4, 5], BubbleSort([5, 4, 3, 2, 1]));
    }

    public function testBubbleSortBoundaryValues()
    {
        $this->assertSame([-2147483647, 2147483648], BubbleSort([2147483648, -2147483647]));
    }
}

위 코드에 문제가 있나요? 물론이죠:

자세함: 각 테스트 사례에는 별도의 메서드가 필요하므로 결과적으로 크고 반복적인 코드 베이스가 생성됩니다.

중복: 테스트 로직은 입력과 예상 출력에 따라 달라지며 각 방법에서 반복됩니다.

개방/폐쇄 위반: 새로운 테스트 케이스를 추가하려면 더 많은 메소드를 생성하여 테스트 클래스 구조를 변경해야 합니다.

데이터 제공자와의 문제 해결!

다음은 데이터 공급자를 사용하도록 리팩터링된 동일한 테스트 모음입니다

<?php declare(strict_types=1);

use PHPUnit\Framework\TestCase;

final class BubbleSortTest extends TestCase
{
    /**
     * Provides test data for bubble sort algorithm.
     *
     * @return array<string, array>
     */
    public function bubbleSortDataProvider(): array
    {
        return [
            'empty' => [[], []],
            'oneElement' => [[0], [0]],
            'twoElementsSorted' => [[5, 144], [5, 144]],
            'twoElementsUnsorted' => [[10, -7], [-7, 10]],
            'moreThanOneElement' => [[1, 3, 4, 2], [1, 2, 3, 4]],
            'moreThanOneElementWithRepetition' => [[1, 4, 4, 2], [1, 2, 4, 4]],
            'moreThanOneElement2' => [[7, 7, 1, 0, 99, -5, 10], [-5, 0, 1, 7, 7, 10, 99]],
            'sameElement' => [[1, 1, 1, 1], [1, 1, 1, 1]],
            'negativeNumbers' => [[-5, -2, -10, -1, -3], [-10, -5, -3, -2, -1]],
            'descendingOrder' => [[5, 4, 3, 2, 1], [1, 2, 3, 4, 5]],
            'randomOrder' => [[9, 2, 7, 4, 1, 6, 3, 8, 5], [1, 2, 3, 4, 5, 6, 7, 8, 9]],
            'duplicateElements' => [[2, 2, 1, 1, 3, 3, 4, 4], [1, 1, 2, 2, 3, 3, 4, 4]],
            'largeArray' => [[-1, -10000, -12345, -2032, -23, 0, 0, 0, 0, 10, 10000, 1024, 1024354, 155, 174, 1955, 2, 255, 3, 322, 4741, 96524], [-1, -10000, -12345, -2032, -23, 0, 0, 0, 0, 10, 10000, 1024, 1024354, 155, 174, 1955, 2, 255, 3, 322, 4741, 96524]],
            'singleNegativeElement' => [[-7], [-7]],
            'arrayWithZeroes' => [[0, -2, 0, 3, 0], [-2, 0, 0, 0, 3]],
            'ascendingOrder' => [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5]],
            'descendingOrderWithDuplicates' => [[5, 5, 4, 3, 3, 2, 1], [1, 2, 3, 3, 4, 5, 5]],
            'boundaryValues' => [[2147483648, -2147483647], [-2147483647, 2147483648]],
            'mixedSignNumbers' => [[-1, 0, 1, -2, 2], [-2, -1, 0, 1, 2]],
        ];
    }

    /**
     * @dataProvider bubbleSortDataProvider
     *
     * @param array<int> $input
     * @param array<int> $expected
     */
    public function testBubbleSort(array $input, array $expected)
    {
        $this->assertSame($expected, BubbleSort($input));
    }
}

</int></int>

데이터 제공자를 이용하면 좋은 점이 있나요? 아 그래요:

간결성: 모든 테스트 데이터가 단일 방법으로 중앙 집중화되므로 각 시나리오에 대해 여러 기능이 필요하지 않습니다.

가독성 향상: 각 테스트 사례는 각 시나리오에 대한 설명 키로 잘 구성되어 있습니다.

개방/폐쇄 원칙: 핵심 테스트 로직을 변경하지 않고도 데이터 제공자에 새로운 사례를 추가할 수 있습니다.

향상된 DX(Developer Experience): 테스트 구조가 깔끔하고 눈에 띄기 때문에 게으른 개발자라도 확장, 디버그 또는 업데이트할 동기를 부여받을 수 있습니다.

데이터 제공업체의 활용

• Go에는 PHPUnit과 같은 기본 데이터 제공자 모델이 없으므로 다른 접근 방식을 사용해야 합니다. 여러 수준의 복잡성을 지닌 많은 구현이 있을 수 있습니다. 다음은 Go land에서 데이터 공급자를 시뮬레이션할 수 있는 후보가 될 수 있는 평균적인 구현입니다.

package sort

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

type TestData struct {
    ArrayList    map[string][]int
    ExpectedList map[string][]int
}

const (
    maxInt32 = int32(^uint32(0) >> 1)
    minInt32 = -maxInt32 - 1
)

var testData = &TestData{
    ArrayList: map[string][]int{
        "empty":                            {},
        "oneElement":                       {0},
        "twoElementsSorted":                {5, 144},
        "twoElementsUnsorted":              {10, -7},
        "moreThanOneElement":               {1, 3, 4, 2},
        "moreThanOneElementWithRepetition": {1, 4, 4, 2},
        "moreThanOneElement2":              {7, 7, 1, 0, 99, -5, 10},
        "sameElement":                      {1, 1, 1, 1},
        "negativeNumbers":                  {-5, -2, -10, -1, -3},
        "descendingOrder":                  {5, 4, 3, 2, 1},
        "randomOrder":                      {9, 2, 7, 4, 1, 6, 3, 8, 5},
        "duplicateElements":                {2, 2, 1, 1, 3, 3, 4, 4},
        "largeArray":                       {-1, -10000, -12345, -2032, -23, 0, 0, 0, 0, 10, 10000, 1024, 1024354, 155, 174, 1955, 2, 255, 3, 322, 4741, 96524},
        "singleNegativeElement":            {-7},
        "arrayWithZeroes":                  {0, -2, 0, 3, 0},
        "ascendingOrder":                   {1, 2, 3, 4, 5},
        "descendingOrderWithDuplicates":    {5, 5, 4, 3, 3, 2, 1},
        "boundaryValues":                   {2147483648, -2147483647},
        "mixedSignNumbers":                 {-1, 0, 1, -2, 2},
    },
    ExpectedList: map[string][]int{
        "empty":                            {},
        "oneElement":                       {0},
        "twoElementsSorted":                {5, 144},
        "twoElementsUnsorted":              {-7, 10},
        "moreThanOneElement":               {1, 2, 3, 4},
        "moreThanOneElementWithRepetition": {1, 2, 4, 4},
        "moreThanOneElement2":              {-5, 0, 1, 7, 7, 10, 99},
        "sameElement":                      {1, 1, 1, 1},
        "negativeNumbers":                  {-10, -5, -3, -2, -1},
        "descendingOrder":                  {1, 2, 3, 4, 5},
        "randomOrder":                      {1, 2, 3, 4, 5, 6, 7, 8, 9},
        "duplicateElements":                {1, 1, 2, 2, 3, 3, 4, 4},
        "largeArray":                       {-1, -10000, -12345, -2032, -23, 0, 0, 0, 0, 10, 10000, 1024, 1024354, 155, 174, 1955, 2, 255, 3, 322, 4741, 96524},
        "singleNegativeElement":            {-7},
        "arrayWithZeroes":                  {-2, 0, 0, 0, 3},
        "ascendingOrder":                   {1, 2, 3, 4, 5},
        "descendingOrderWithDuplicates":    {1, 2, 3, 3, 4, 5, 5},
        "boundaryValues":                   {-2147483647, 2147483648},
        "mixedSignNumbers":                 {-2, -1, 0, 1, 2},
    },
}

func TestBubble(t *testing.T) {

    for testCase, array := range testData.ArrayList {
        t.Run(testCase, func(t *testing.T) {
            actual := Bubble(array)
            assert.ElementsMatch(t, actual, testData.ExpectedList[testCase])
        })

    }
}

• 기본적으로 두 개의 맵/목록을 정의합니다. 하나는 입력 데이터용이고 다른 하나는 예상 데이터용입니다. 우리는 양쪽의 각 사례 시나리오가 양쪽의 동일한 맵 키를 통해 참조되도록 보장합니다.
• 테스트 실행은 준비된 입력/예상 목록을 반복하는 간단한 함수의 루프 문제입니다.
• 일부 일회성 상용구 유형을 제외하고 테스트 수정은 데이터 측면에서만 이루어져야 하며, 대부분의 변경은 테스트를 실행하는 함수의 논리를 변경해서는 안 되며, 이를 통해 위에서 설명한 목표를 달성할 수 있습니다. 테스트 작업은 원시 데이터 준비까지 완료됩니다.

보너스: 이 블로그 게시물에 제시된 논리를 구현하는 Github 저장소는 여기(https://github.com/MedUnes/dsa-go)에서 찾을 수 있습니다. 지금까지는 이러한 테스트를 실행하고 매우 유명한 녹색 배지를 표시하는 Github 작업도 포함되어 있습니다. ;)

다음 유익한 포스팅에서 만나요!

위 내용은 PHPUnit에서 Go까지: Go 개발자를 위한 데이터 기반 단위 테스트의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!