Golang实现Cucumber BDD测试框架的插件库godog的使用

godog是Golang官方支持的Cucumber BDD框架，它将规范和测试文档合并为一个整体，使用Given/When/Then格式的Gherkin场景描述。

为什么选择Godog/Cucumber

单一真实来源

Godog将规范和测试文档合并为一个整体。

活文档

因为规范会被Godog自动测试，所以它们总是保持最新。

关注客户

业务和IT并不总是相互理解。Godog的可执行规范鼓励更紧密的协作，帮助团队始终牢记业务目标。

减少返工

当自动化测试如此有趣时，团队可以轻松保护自己免受昂贵的回归影响。

完整示例Demo

步骤1 - 创建Go模块

mkdir godogs
cd godogs
go mod init godogs

步骤2 - 创建Gherkin特性文件

创建features/godogs.feature文件：

Feature: eat godogs
  In order to be happy
  As a hungry gopher
  I need to be able to eat godogs

  Scenario: Eat 5 out of 12
    Given there are 12 godogs
    When I eat 5
    Then there should be 7 remaining

步骤3 - 创建godog步骤定义

创建godogs_test.go文件：

package main

import (
  "context"
  "errors"
  "fmt"
  "testing"

  "github.com/cucumber/godog"
)

// godogsCtxKey是用于在context.Context中存储可用godogs的键
type godogsCtxKey struct{}

func thereAreGodogs(ctx context.Context, available int) (context.Context, error) {
  return context.WithValue(ctx, godogsCtxKey{}, available), nil
}

func iEat(ctx context.Context, num int) (context.Context, error) {
  available, ok := ctx.Value(godogsCtxKey{}).(int)
  if !ok {
    return ctx, errors.New("there are no godogs available")
  }

  if available < num {
    return ctx, fmt.Errorf("you cannot eat %d godogs, there are %d available", num, available)
  }

  available -= num

  return context.WithValue(ctx, godogsCtxKey{}, available), nil
}

func thereShouldBeRemaining(ctx context.Context, remaining int) error {
  available, ok := ctx.Value(godogsCtxKey{}).(int)
  if !ok {
    return errors.New("there are no godogs available")
  }

  if available != remaining {
    return fmt.Errorf("expected %d godogs to be remaining, but there is %d", remaining, available)
  }

  return nil
}

func TestFeatures(t *testing.T) {
  suite := godog.TestSuite{
    ScenarioInitializer: InitializeScenario,
    Options: &godog.Options{
      Format:   "pretty",
      Paths:    []string{"features"},
      TestingT: t, // 将运行子测试的测试实例
    },
  }

  if suite.Run() != 0 {
    t.Fatal("non-zero status returned, failed to run feature tests")
  }
}

func InitializeScenario(sc *godog.ScenarioContext) {
  sc.Step(`^there are (\d+) godogs$`, thereAreGodogs)
  sc.Step(`^I eat (\d+)$`, iEat)
  sc.Step(`^there should be (\d+) remaining$`, thereShouldBeRemaining)
}

步骤4 - 创建主程序

创建godogs.go文件：

package main

// Godogs available to eat
var Godogs int

func main() { /* usual main func */ }

步骤5 - 运行测试

运行测试命令：

go test -v godogs_test.go

你应该看到类似以下的输出：

=== RUN   TestFeatures
Feature: eat godogs
  In order to be happy
  As a hungry gopher
  I need to be able to eat godogs
=== RUN   TestFeatures/Eat_5_out_of_12

  Scenario: Eat 5 out of 12          # features/godogs.feature:6
    Given there are 12 godogs        # godog_test.go:15 -> command-line-arguments.thereAreGodogs
    When I eat 5                     # godog_test.go:19 -> command-line-arguments.iEat
    Then there should be 7 remaining # godog_test.go:34 -> command-line-arguments.thereShouldBeRemaining

1 scenarios (1 passed)
3 steps (3 passed)
279.917µs
--- PASS: TestFeatures (0.00s)
    --- PASS: TestFeatures/Eat_5_out_of_12 (0.00s)
PASS
ok      command-line-arguments  0.164s

高级用法

使用TestMain运行测试套件

func TestMain(m *testing.M) {
  opts := godog.Options{
    Format:    "progress",
    Paths:     []string{"features"},
    Randomize: time.Now().UTC().UnixNano(), // 随机化场景执行顺序
  }

  status := godog.TestSuite{
    Name: "godogs",
    TestSuiteInitializer: InitializeTestSuite,
    ScenarioInitializer:  InitializeScenario,
    Options: &opts,
  }.Run()

  // 可选：除了godog外运行testing包的逻辑
  if st := m.Run(); st > status {
    status = st
  }

  os.Exit(status)
}

使用标签过滤场景

你可以使用-t=<expression>或--tags=<expression>来过滤场景：

• @wip - 运行所有带有wip标签的场景
• ~@wip - 排除所有带有wip标签的场景
• @wip && ~@new - 运行wip场景，但排除new场景
• @wip,@undone - 运行wip或undone场景

使用断言库

func thereShouldBeRemaining(ctx context.Context, remaining int) error {
  assert.Equal(
    godog.T(ctx), Godogs, remaining, 
    "Expected %d godogs to be remaining, but there is %d", remaining, Godogs,
  )
  return nil
}

总结

Godog提供了一个强大的BDD测试框架，可以帮助团队更好地协作开发。通过Gherkin语法编写的测试用例既可作为文档，又可作为自动化测试，确保系统行为符合预期。