Ginkgo: ein BDD Go-Sprachframework

Der Schwerpunkt des Unit-Tests liegt auf der logischen Einheit des Codes, bei der es sich normalerweise um ein Objekt oder eine bestimmte Funktion handelt. Wir können genügend Unit-Tests schreiben, um die Qualität des Codes sicherzustellen. Wenn Funktionen geändert oder Code umgestaltet werden, können uns ausreichend Unit-Testfälle ausreichend Sicherheit geben.

Die oben genannten Unit-Tests sind Entwicklungsspezifikationen. In der agilen Softwareentwicklung gibt es zwei häufige Besucher: Test-Driven Development (TDD) und Behavior-Driven Development (BDD). Dabei handelt es sich um Praktiken und Techniken, aber auch um Designmethoden.

TDD

Die Grundidee von TDD besteht darin, die gesamte Entwicklung durch Tests voranzutreiben. Das Prinzip besteht darin, Unit-Testfälle zu schreiben, bevor Funktionscode entwickelt wird. Enthält die folgenden fünf Schritte:

• Entwickler schreiben zunächst einige Testfälle
• Führen Sie diese Tests aus, aber diese Tests schlagen offensichtlich fehl, da die Geschäftslogik in den Testfällen nicht implementiert wurde
• Details zum Implementierungscode
• Wenn der Entwickler den Code erfolgreich implementiert, werden alle Tests bestanden
• Refaktorieren Sie den Geschäftscode rechtzeitig. Wenn die neue Codefunktion falsch ist, wird die entsprechende Testdatei aktualisiert Es wird auch fehlschlagen

Wenn neue Funktionen entwickelt werden müssen, wiederholen Sie die oben genannten Schritte. Der Prozess ist in der folgenden Abbildung dargestellt durch Go.

BDD

TDD konzentriert sich auf die Entwicklung und verwendet Testfälle, um Entwickler zu regulieren und zu zwingen, qualitativ hochwertigeren und weniger fehlerhaften Code zu schreiben. BDD konzentriert sich mehr auf Design, das erfordert, dass das System beim Entwerfen von Testfällen definiert wird, befürwortet die Verwendung einer gemeinsamen Sprache zur Beschreibung des Verhaltens des Systems und die Kombination von Systemdesign und Testfällen, um die Entwicklungsarbeit voranzutreiben.

BDD ist von TDD abgeleitet, Der Hauptunterschied liegt in der Beschreibung des Tests. BDD verwendet eine verständlichere Sprache zur Beschreibung von Testfällen und konzentriert sich mehr auf die erforderliche Funktionalität als auf die tatsächlichen Ergebnisse.

Die von BDD verliehene Fähigkeit, Tests wie Sätze zu lesen, führt zu einer Veränderung der Wahrnehmung von Tests und hilft uns, darüber nachzudenken, wie wir Tests besser schreiben können.

Ginkgo

Ginkgo ist ein BDD-Testframework in der Go-Sprache, das Entwickler beim Schreiben ausdrucksstarker und umfassender Tests unterstützen soll.

Ginkgo integriert Gos natives <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 Bibliothek , was bedeutet, dass Sie

Herunterladen🎜🎜Verwenden🎜🎜go get🎜🎜 get🎜🎜

$ 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 库🎜🎜

package gopher_test

import (
 "testing"

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

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

🎜 🎜在 🎜🎜gopher.go🎜🎜 文件中，有 🎜 🎜Gopher🎜🎜 结构体与校验方法 🎜🎜Validate🎜🎜 如下🎜🎜

 $ 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

🎜🎜我们通过 🎜🎜ginkgo bootstrap🎜🎜 命令，来初始化一个 Ginkgo. 测试套件。🎜🎜

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

🎜 🎜此时在 🎜🎜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 将打印出堆栈与错误描述性信息。

Zusammenfassung

TDD und BDD sind Methoden, die in der agilen Entwicklung häufig erwähnt werden. Im Vergleich zu TDD treibt BDD die Softwareentwicklung voran, indem es „Verhaltensweisen und Spezifikationen“ schreibt. Diese Verhaltensweisen und Spezifikationen spiegeln sich in weiteren „ausführlichen“ Beschreibungsinformationen im Code wider. Es gibt eine andere Möglichkeit, die Essenz von BDD auszudrücken: BDD hilft Entwicklern beim Entwerfen von Software und TDD hilft Entwicklern beim Testen von Software

.

Ginkgo ist ein hervorragendes BDD-Framework in der Go-Sprache. Es hilft Entwicklern effektiv, Testfälle über die DSL-Syntax (Describe/Context/It) zu organisieren und zu orchestrieren. Dieser Artikel zeigt nur einen sehr einfachen Anwendungsfall von Ginkgo und sollte als Ausgangspunkt dienen.

Leser müssen den Ausführungslebenszyklus verstehen, wenn sie Ginkgo verwenden. Zu den wichtigsten Punkten gehören

It, Context, Describe, BeforeEach, AfterEach, JustBeforeEach, BeforeSuite, AfterSuite, By, Fail

Die Ausführungssequenz und semantische Logik dieser Module. <span style="font-size: 15px;">It、Context、Describe、BeforeEach、AfterEach、JustBeforeEach、BeforeSuite、AfterSuite、By、Fail</span>Ginkgo verfügt über viele Funktionen, die in diesem Artikel nicht behandelt werden, wie z. B. asynchrone Tests, Benchmark-Tests, kontinuierliche Integration und andere leistungsstarke Unterstützung. Das Lager befindet sich unter https://github.com/onsi/ginkgo. Es bietet auch englische und chinesische Versionen der Nutzungsdokumentation, um mehr über Ginkgo zu erfahren.

Schließlich wird das Ginkgo-Framework auch im

K8s-Projekt verwendet, um seine End-to-End-Testfälle (E2E) zu schreiben, von denen es sich zu lernen lohnt.

Das obige ist der detaillierte Inhalt vonGinkgo: ein BDD Go-Sprachframework. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!