Ginkgo: rangka kerja bahasa BDD Go

Tumpuan ujian unit ialah unit logik kod, yang biasanya objek atau fungsi tertentu. Kita boleh menulis ujian unit yang mencukupi untuk memastikan kualiti kod Apabila fungsi diubah suai atau kod difaktorkan semula, kes ujian unit yang mencukupi boleh memberikan keyakinan yang mencukupi.

Di atas ujian unit adalah spesifikasi pembangunan. Dalam pembangunan perisian tangkas, terdapat dua pelawat yang kerap: Pembangunan Terpacu Ujian (TDD) dan pembangunan dipacu Tingkah Laku (BDD). Ia adalah amalan dan teknik, tetapi juga metodologi reka bentuk.

TDD

Idea asas TDD adalah untuk mempromosikan keseluruhan pembangunan melalui ujian Prinsipnya ialah menulis kes ujian unit sebelum membangunkan kod berfungsi. Mengandungi lima langkah berikut:

• Pemaju menulis beberapa kes ujian terlebih dahulu
• Jalankan ujian ini, tetapi ujian ini jelas akan gagal kerana logik perniagaan dalam kes ujian belum dilaksanakan
• Butiran kod pelaksanaan
• Jika pembangun berjaya melaksanakan kod, semua ujian akan lulus
• Faktor semula kod perniagaan tepat pada masanya. Jika fail baharu, fungsinya sepadan Ia juga akan gagal

Apabila ciri baharu perlu dibangunkan, ulangi langkah di atas. Proses ini ditunjukkan dalam rajah di bawah

tdd-carta alir

Terdapat repositori Github yang lebih menarik: belajar-ikut-dengan-ujian

melalui Go. 🎜🎜

BDD

TDD memfokuskan pada pembangunan, dan menggunakan kes ujian untuk mengawal selia dan mengekang pembangun untuk menulis kod yang berkualiti tinggi dan kurang buggy. BDD lebih menumpukan pada reka bentuk, yang memerlukan sistem ditakrifkan semasa mereka bentuk kes ujian, menyokong menggunakan bahasa yang sama untuk menerangkan gelagat sistem, dan menggabungkan reka bentuk sistem dan kes ujian untuk memacu kerja pembangunan.

BDD berasal daripada TDD, Perbezaan utama terletak pada penerangan ujian. BDD menggunakan bahasa yang lebih mudah difahami untuk menerangkan kes ujian, lebih memfokuskan pada fungsi yang diperlukan dan bukannya keputusan sebenar.

Keupayaan yang diberikan oleh BDD untuk membaca ujian seperti ayat membawa perubahan dalam persepsi ujian dan membantu kami berfikir tentang cara menulis ujian dengan lebih baik.

Ginkgo

Ginkgo ialah rangka kerja ujian BDD dalam bahasa Go, direka untuk membantu pembangun menulis ujian yang ekspresif dan komprehensif.

Ginkgo menyepadukan asli Go <code style='font-size: 14px;overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;background: rgba(14, 210, 247, 0.15);'><span style="font-size: 15px;">testing</span> 库，这意味着你可以通过 <span style="font-size: 15px;">go test</span> 来运行 Ginkgo 测试套件。同时，它与断言和 mock 套件 testify 、富测试集 go-check 同样兼容。但 Ginkgo 建议的是搭配 gomega 库一起使用。

下面，我们使用 Ginkgo 来感受一下 BDD 模式的测试代码。

下载

使用 <span style="font-size: 15px;">go get</span>testing library , yang bermaksud anda boleh lulus

🎜pergi ujian🎜 🎜 untuk dijalankan suite ujian Ginkgo. Pada masa yang sama, ia juga serasi dengan suite penegasan dan olok-olok 🎜🎜testify🎜🎜 dan suite ujian kaya 🎜🎜go-check🎜🎜. Tetapi apa yang disyorkan oleh Ginkgo ialah menggunakannya dengan perpustakaan 🎜🎜gomega🎜🎜. 🎜🎜🎜🎜 Seterusnya, kami menggunakan Ginkgo untuk mengalami kod ujian mod BDD. 🎜🎜

Muat turun

🎜🎜Gunakan🎜🎜pergi dapatkan🎜🎜 dapatkan🎜🎜

$ go get github.com/onsi/ginkgo/ginkgo
$ go get github.com/onsi/gomega/...

该命令获取 ginkgo 并安装 <code style='font-size: 14px;overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;background: rgba(14, 210, 247, 0.15);'><span style="font-size: 15px;">ginkgo</span> 可执行文件到 <span style="font-size: 15px;">$GOPATH/bin</span> 。

创建套件

创建 gopher 库

$ cd path-to-package/gopher

在 <span style="font-size: 15px;">gopher.go</span> 文件中，有 <span style="font-size: 15px;">Gopher</span> 结构体与校验方法 <span style="font-size: 15px;">Validate</span> 如下

package gopher

import (
 "errors"
 "unicode/utf8"
)

type Gopher struct {
 Name   string
 Gender string
 Age    int
}

func Validate(g Gopher) error {
 if utf8.RuneCountInString(g.Name) < 3 {
  return errors.New("名字太短，不能小于3")
 }

 if g.Gender != "男" {
  return errors.New("只要男的")
 }

 if g.Age < 18 {
  return errors.New("岁数太小，不能小于18")
 }
 return nil
}

我们通过 <span style="font-size: 15px;">ginkgo bootstrap</span> 命令，来初始化一个 Ginkgo 测试套件。

$ ginkgo bootstrap
Generating ginkgo test suite bootstrap for gopher in:
        gopher_suite_test.go

此时在 <span style="font-size: 15px;">gopher.go</span> 同级目录中，生成了 <span style="font-size: 15px;">gopher_suite_test.go</span>ginkgo可执行文件到

🎜$GOPATH/bin🎜🎜 。🎜 🎜

创建套件

🎜🎜创建 gopher 🎜🎜 🎜在 🎜🎜gopher.go🎜🎜 文件中，有 🎜 🎜Gopher🎜🎜 结构体与校验柹法 style ="font-size: 14px;overflow-wrap: break-word; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;background: rgba(14, 210, 247, 0.15);">🎜Sahkan🎜🎜 如下🎜🎜

package gopher_test

import (
 "testing"

 . "github.com/onsi/ginkgo"
 . "github.com/onsi/gomega"
)

func TestGopher(t *testing.T) {
 RegisterFailHandler(Fail)
 RunSpecs(t, "Gopher Suite")
}

🎜🎜我仇 style "font-size: 14px;overflow-wrap: break-word; padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;font-family: "Operator Mono", Consolas, Monaco , Menlo, monospace;word-break: break-all;latar belakang: rgba(14, 210, 247, 0.15);">🎜ginkgo bootstrap🎜🎜 命令，来初始化一个 Ginkgo 。 术rr 个行🎜 🎜此时在 🎜🎜gopher.go🎜🎜 同级目录中，生成了 🎜🎜gopher_suite_test.go🎜🎜 文件，内容如下🎜🎜

package gopher_test

import (
 "testing"

 . "github.com/onsi/ginkgo"
 . "github.com/onsi/gomega"
)

func TestGopher(t *testing.T) {
 RegisterFailHandler(Fail)
 RunSpecs(t, "Gopher Suite")
}

此时，我们就可以运行测试套件了，通过命令 <span style="font-size: 15px;">go test</span> 或 <code style='font-size: 14px;overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;background: rgba(14, 210, 247, 0.15);'><span style="font-size: 15px;">ginkgo</span> 均可。

 $ go test
Running Suite: Gopher Suite
===========================
Random Seed: 1629621653
Will run 0 of 0 specs


Ran 0 of 0 Specs in 0.000 seconds
SUCCESS! -- 0 Passed | 0 Failed | 0 Pending | 0 Skipped
PASS
ok      ginkgo/gopher   0.018s

当然，空测试套件没有什么价值，我们需要在此套件下编写测试（Spec）用例。

我们可以在 <span style="font-size: 15px;">gopher_suite_test.go</span> 中编写测试，但是推荐分离到独立的文件中，特别是包中有多个需要被测试的源文件的情况下。

创建 Spec

执行 <span style="font-size: 15px;">ginkgo generate gopher</span>  可以生成一个 <span style="font-size: 15px;">gopher_test.go</span> 测试文件。

 $ ginkgo generate gopher
Generating ginkgo test for Gopher in:
  gopher_test.go

此时测试文件中的内容如下

package gopher_test

import (
 . "github.com/onsi/ginkgo"
)

var _ = Describe("Gopher", func() {

})

编写 Spec

我们基于此测试文件撰写实际的测试用例

package gopher_test

import (
 "ginkgo/gopher"
 . "github.com/onsi/ginkgo"
 "github.com/onsi/gomega"
)

func mockInputData() ([]gopher.Gopher, error) {
 inputData := []gopher.Gopher{
  {
   Name:   "菜刀",
   Gender: "男",
   Age:    18,
  },
  {
   Name:   "小西瓜",
   Gender: "女",
   Age:    19,
  },
  {
   Name:   "机器铃砍菜刀",
   Gender: "男",
   Age:    17,
  },
  {
   Name:   "小菜刀",
   Gender: "男",
   Age:    20,
  },
 }
 return inputData, nil
}

var _ = Describe("Gopher", func() {

 BeforeEach(func() {
  By("当测试不通过时，我会在这里打印一个消息 【BeforeEach】")
 })

 inputData, err := mockInputData()

 Describe("校验输入数据", func() {

  Context("当获取数据没有错误发生时", func() {
   It("它应该是接收数据成功了的", func() {
    gomega.Expect(err).Should(gomega.BeNil())
   })
  })

  Context("当获取的数据校验失败时", func() {
   It("当数据校验返回错误为：名字太短，不能小于3 时", func() {
    gomega.Expect(gopher.Validate(inputData[0])).Should(gomega.MatchError("名字太短，不能小于3"))
   })

   It("当数据校验返回错误为：只要男的 时", func() {
    gomega.Expect(gopher.Validate(inputData[1])).Should(gomega.MatchError("只要男的"))
   })

   It("当数据校验返回错误为：岁数太小，不能小于18 时", func() {
    gomega.Expect(gopher.Validate(inputData[2])).Should(gomega.MatchError("岁数太小，不能小于18"))
   })
  })

  Context("当获取的数据校验成功时", func() {
   It("通过了数据校验", func() {
    gomega.Expect(gopher.Validate(inputData[3])).Should(gomega.BeNil())
   })
  })
 })

 AfterEach(func() {
  By("当测试不通过时，我会在这里打印一个消息 【AfterEach】")
 })
})

可以看到，BDD 风格的测试案例在代码中就被描述地非常清晰。由于我们的测试用例与预期相符，执行 <span style="font-size: 15px;">go test</span> 执行测试套件会校验通过。

 $ go test
Running Suite: Gopher Suite
===========================
Random Seed: 1629625854
Will run 5 of 5 specs

•••••
Ran 5 of 5 Specs in 0.000 seconds
SUCCESS! -- 5 Passed | 0 Failed | 0 Pending | 0 Skipped
PASS
ok      ginkgo/gopher   0.013s

读者可自行更改数据致测试不通过，你会看到 Ginkgo 将打印出堆栈与错误描述性信息。

Ringkasan

TDD dan BDD biasanya disebut metodologi dalam pembangunan tangkas. Berbanding dengan TDD, BDD memacu pembangunan perisian dengan menulis kelakuan dan spesifikasi. Gelagat dan spesifikasi ini ditunjukkan dalam lebih banyak "verbose" maklumat perihalan dalam kod.

Ada cara lain untuk menyatakan intipati BDD: BDD membantu pembangun mereka bentuk perisian, dan TDD membantu pembangun menguji perisian.

Ginkgo ialah rangka kerja BDD yang sangat baik dalam bahasa Go Ia berkesan membantu pembangun mengatur dan mengatur kes ujian melalui sintaks DSL (Huraikan/Konteks/Ia). Artikel ini hanya menunjukkan kes penggunaan Ginkgo yang sangat mudah, dan harus digunakan sebagai titik permulaan.

Pembaca perlu memahami kitaran hayat pelaksanaannya apabila menggunakan Ginkgo Perkara utama termasuk <code style='font-size: 14px;overflow-wrap: break-word;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;font-family: "Operator Mono", Consolas, Monaco, Menlo, monospace;word-break: break-all;background: rgba(14, 210, 247, 0.15);'><span style="font-size: 15px;">It、Context、Describe、BeforeEach、AfterEach、JustBeforeEach、BeforeSuite、AfterSuite、By、Fail</span>It, Context, Describe, BeforeEach, AfterEach, JustBeforeEach, BeforeSuite, AfterSuite, By, Fail Urutan pelaksanaan dan logik semantik modul ini.

Ginkgo mempunyai banyak ciri yang tidak diliputi dalam artikel ini, seperti ujian tak segerak, ujian penanda aras, penyepaduan berterusan dan sokongan berkuasa lain. Gudangnya terletak di https://github.com/onsi/ginkgo. Ia juga menyediakan dokumentasi penggunaan versi Bahasa Inggeris dan Cina. Pembaca boleh menggunakan ini untuk mengetahui lebih lanjut tentang Ginkgo.

Akhir sekali, projek K8s juga menggunakan rangka kerja Ginkgo untuk menulis kes ujian hujung ke hujung (E2E), yang patut dipelajari.

🎜

Atas ialah kandungan terperinci Ginkgo: rangka kerja bahasa BDD Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!