Bagaimana saya bisa melakukan pengaturan pengujian menggunakan paket pengujian di Go

Bagaimana saya dapat melakukan pemrosesan pengaturan pengujian secara keseluruhan yang menetapkan tahapan untuk semua pengujian saat menggunakan paket pengujian ?

Sebagai contoh di Nunit ada [SetUp]atribut.

[TestFixture]
public class SuccessTests
{
  [SetUp] public void Init()
  { /* Load test data */ }
}

Dimulai dengan Go 1.4 Anda dapat mengimplementasikan pengaturan / pembongkaran (tidak perlu menyalin fungsi Anda sebelum / setelah setiap pengujian). Dokumentasi diuraikan di sini di bagian Utama :

TestMain berjalan di goroutine utama dan dapat melakukan penyiapan dan pembongkaran apa pun yang diperlukan seputar panggilan ke m.Run. Ini kemudian harus memanggil os.Exit dengan hasil m.Run

Butuh beberapa saat bagi saya untuk mengetahui bahwa ini berarti jika pengujian berisi fungsi func TestMain(m *testing.M)maka fungsi ini akan dipanggil alih-alih menjalankan pengujian. Dan dalam fungsi ini saya dapat menentukan bagaimana tes akan berjalan. Misalnya saya dapat mengimplementasikan pengaturan global dan pembongkaran:

func TestMain(m *testing.M) {
    setup()
    code := m.Run() 
    shutdown()
    os.Exit(code)
}

Beberapa contoh lainnya dapat ditemukan di sini .

Fitur TestMain yang ditambahkan ke framework pengujian Go di rilis terbaru adalah solusi sederhana untuk beberapa kasus penggunaan pengujian. TestMain menyediakan hook global untuk melakukan penyiapan dan penghentian, mengontrol lingkungan pengujian, menjalankan kode yang berbeda dalam proses anak, atau memeriksa sumber daya yang bocor oleh kode pengujian. Sebagian besar paket tidak memerlukan TestMain, tetapi ini adalah tambahan yang disambut baik untuk saat-saat dibutuhkan.

Ini dapat dicapai dengan meletakkan init()fungsi di _test.gofile. Ini akan dijalankan sebelum init()fungsi.

// package_test.go
package main

func init() {
     /* load test data */
}

_Test.init () akan dipanggil sebelum fungsi package init ().

Diberikan fungsi sederhana untuk pengujian unit:

package math

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

Anda dapat mengujinya dengan fungsi pengaturan yang mengembalikan fungsi pembongkaran. Dan setelah memanggil setup () Anda dapat melakukan panggilan yang ditangguhkan ke teardown ().

package math

import "testing"

func setupTestCase(t *testing.T) func(t *testing.T) {
    t.Log("setup test case")
    return func(t *testing.T) {
        t.Log("teardown test case")
    }
}

func setupSubTest(t *testing.T) func(t *testing.T) {
    t.Log("setup sub test")
    return func(t *testing.T) {
        t.Log("teardown sub test")
    }
}

func TestAddition(t *testing.T) {
    cases := []struct {
        name     string
        a        int
        b        int
        expected int
    }{
        {"add", 2, 2, 4},
        {"minus", 0, -2, -2},
        {"zero", 0, 0, 0},
    }

    teardownTestCase := setupTestCase(t)
    defer teardownTestCase(t)

    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            teardownSubTest := setupSubTest(t)
            defer teardownSubTest(t)

            result := Sum(tc.a, tc.b)
            if result != tc.expected {
                t.Fatalf("expected sum %v, but got %v", tc.expected, result)
            }
        })
    }
}

Alat pengujian Go akan melaporkan pernyataan logging di konsol shell:

% go test -v
=== RUN   TestAddition
=== RUN   TestAddition/add
=== RUN   TestAddition/minus
=== RUN   TestAddition/zero
--- PASS: TestAddition (0.00s)
    math_test.go:6: setup test case
    --- PASS: TestAddition/add (0.00s)
        math_test.go:13: setup sub test
        math_test.go:15: teardown sub test
    --- PASS: TestAddition/minus (0.00s)
        math_test.go:13: setup sub test
        math_test.go:15: teardown sub test
    --- PASS: TestAddition/zero (0.00s)
        math_test.go:13: setup sub test
        math_test.go:15: teardown sub test
    math_test.go:8: teardown test case
PASS
ok      github.com/kare/go-unit-test-setup-teardown 0.010s
% 

Anda dapat meneruskan beberapa parameter tambahan ke penyiapan / pembongkaran dengan pendekatan ini.

Biasanya, pengujian dalam go tidak ditulis dalam gaya yang sama seperti bahasa lain. Seringkali, ada fungsi pengujian yang relatif lebih sedikit, tetapi masing-masing berisi sekumpulan kasus pengujian berdasarkan tabel. Lihat artikel ini yang ditulis oleh salah satu tim Go.

Dengan pengujian berbasis tabel, Anda cukup meletakkan kode penyiapan apa pun sebelum loop yang menjalankan kasus uji individual yang ditentukan dalam tabel, dan meletakkan kode pembersihan apa pun setelahnya.

Jika Anda masih memiliki kode penyiapan yang dibagikan di antara fungsi pengujian, Anda dapat mengekstrak kode penyiapan bersama ke dalam suatu fungsi, dan menggunakan a sync.Oncejika penting agar dijalankan tepat satu kali (atau seperti yang disarankan oleh jawaban lain, gunakan init(), tetapi ini memiliki kerugian bahwa penyiapan akan dilakukan meskipun kasus pengujian tidak berjalan (mungkin karena Anda telah membatasi kasus pengujian dengan menggunakan go test -run <regexp>.)

Saya akan mengatakan jika Anda berpikir Anda memerlukan pengaturan bersama antara pengujian berbeda yang dijalankan tepat setelah Anda harus berpikir jika Anda benar-benar membutuhkannya, dan jika pengujian berbasis tabel tidak akan lebih baik.

Kerangka pengujian Go tidak memiliki apa pun yang setara dengan atribut SetUp NUnit (menandai fungsi yang akan dipanggil sebelum setiap pengujian di suite). Ada beberapa opsi:

1. Cukup panggil SetUpfungsi Anda dari setiap pengujian jika diperlukan.

2. Gunakan ekstensi untuk kerangka pengujian Go yang mengimplementasikan paradigma dan konsep xUnit. Tiga opsi kuat muncul di benak:

   • gocheck
   • bersaksi
   • unit G

Masing-masing pustaka ini mendorong Anda untuk mengatur pengujian Anda ke dalam suite / perlengkapan yang mirip dengan kerangka kerja xUnit lainnya, dan akan memanggil metode penyiapan pada tipe suite / perlengkapan sebelum masing-masing Test*metode.

Steker tak tahu malu, saya membuat https://github.com/houqp/gtest untuk membantu menyelesaikan masalah ini dengan tepat.

Berikut ini contoh singkatnya:

import (
  "strings"
  "testing"
  "github.com/houqp/gtest"
)

type SampleTests struct{}

// Setup and Teardown are invoked per test group run
func (s *SampleTests) Setup(t *testing.T)      {}
func (s *SampleTests) Teardown(t *testing.T)   {}
// BeforeEach and AfterEach are invoked per test run
func (s *SampleTests) BeforeEach(t *testing.T) {}
func (s *SampleTests) AfterEach(t *testing.T)  {}

func (s *SampleTests) SubTestCompare(t *testing.T) {
  if 1 != 1 {
    t.FailNow()
  }
}

func (s *SampleTests) SubTestCheckPrefix(t *testing.T) {
  if !strings.HasPrefix("abc", "ab") {
    t.FailNow()
  }
}

func TestSampleTests(t *testing.T) {
  gtest.RunSubTests(t, &SampleTests{})
}

Anda dapat membuat grup uji apa pun yang Anda inginkan dalam sebuah paket dengan masing-masing grup tersebut menggunakan rangkaian rutinitas penyiapan / pembongkaran yang berbeda.