golang类似Mocha的Go测试框架插件库goblin的使用

Golang类似Mocha的Go测试框架插件库goblin的使用

Goblin简介

Goblin是一个类似Mocha的BDD测试框架，不需要任何额外的依赖。它不需要复杂的文档或繁琐的步骤就能运行。

Goblin Logo

为什么选择Goblin？

受到Node BDD灵活性和简单性的启发，同时对Go严格的测试方式感到沮丧，我们想引入一个新工具来编写自描述和全面的代码。

Goblin提供哪些功能？

  • 使用go test运行测试
  • 彩色报告和美观的语法
  • 保持与Node的Mocha完全相同的语法和行为
  • 可以嵌套任意数量的Describe和It块
  • 使用Before、BeforeEach、After和AfterEach来设置和清理测试
  • 不需要记住Describe和It块中的混淆参数
  • 使用声明式和表达性语言编写测试
  • 可以插入不同的断言库
  • 支持Gomega
  • 可以像Mocha中一样跳过测试
  • 自动支持终端彩色输出
  • 只需两行设置即可运行

如何使用Goblin？

由于go test目前不够灵活，你需要将Goblin挂接到它。你需要在测试文件中添加一个测试方法。所有的goblin测试都将在这个函数中实现。

package foobar

import (
    "testing"
    . "github.com/franela/goblin"
)

func Test(t *testing.T) {
    g := Goblin(t)
    g.Describe("Numbers", func() {
        // 通过的测试
        g.It("Should add two numbers ", func() {
            g.Assert(1+1).Equal(2)
        })
        // 失败的测试
        g.It("Should match equal numbers", func() {
            g.Assert(2).Equal(4)
        })
        // 待定的测试
        g.It("Should substract two numbers")
        // 排除的测试
        g.Xit("Should add two numbers ", func() {
            g.Assert(3+1).Equal(4)
        })
    })
}

输出结果类似这样：

Goblin Output

简单易用，对吧？

如何进行异步测试？

可以！Goblin会帮助你测试异步操作，比如goroutines等。你只需要在It的处理函数中添加一个done参数。当测试通过时应该调用这个处理函数。

g.Describe("Numbers", func() {
    g.It("Should add two numbers asynchronously", func(done Done) {
        go func() {
            g.Assert(1+1).Equal(2)
            done()
        }()
    })
})

Goblin会等待done调用、Fail调用或任何错误的断言。

如何与Gomega一起使用？

Gomega是一个很好的断言框架。但它没有提供很好的方式来挂接到测试框架。它应该只是panic而不是需要一个fail函数。目前与Goblin一起使用Gomega的方式是：

package foobar

import (
    "testing"
    goblin "github.com/franela/goblin"
    . "github.com/onsi/gomega"
)

func Test(t *testing.T) {
    g := goblin.Goblin(t)

    // 为gomega的特殊钩子
    RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })

    g.Describe("lala", func() {
        g.It("lslslslsls", func() {
            Expect(1).To(Equal(10))
        })
    })
}

常见问题

如何运行特定测试？

如果在go test命令中提供-goblin.run=$REGES，则只有匹配提供的正则表达式的测试会运行。

贡献

我们有一些待解决的问题。欢迎贡献并发送PR（请附带测试 😄）。

特别感谢

特别感谢Leandro Reox（Leitan）设计的goblin logo。


更多关于golang类似Mocha的Go测试框架插件库goblin的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang类似Mocha的Go测试框架插件库goblin的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang测试框架Goblin使用指南

Goblin是一个受Mocha启发的Go测试框架，它提供了BDD(行为驱动开发)风格的测试语法。下面我将详细介绍Goblin的使用方法。

安装Goblin

首先安装Goblin包：

go get github.com/franela/goblin

基本用法

下面是一个基本的Goblin测试示例：

package main

import (
	"testing"
	"github.com/franela/goblin"
)

func Test(t *testing.T) {
	g := goblin.Goblin(t)

	g.Describe("Calculator", func() {
		g.It("Should add two numbers correctly", func() {
			g.Assert(1 + 1).Equal(2)
		})

		g.It("Should subtract two numbers correctly", func() {
			g.Assert(5 - 3).Equal(2)
		})
	})
}

主要特性

1. 描述块(Describe)

Describe用于组织相关测试用例：

g.Describe("User", func() {
	// 测试用例放在这里
})

2. 测试用例(It)

It定义单个测试用例：

g.It("should return user name", func() {
	// 断言放在这里
})

3. 钩子函数

Goblin支持Before、After、BeforeEach和AfterEach钩子：

g.Describe("Database", func() {
	var db *Database

	g.Before(func() {
		// 在所有测试前运行
		db = ConnectToDB()
	})

	g.BeforeEach(func() {
		// 在每个测试前运行
		db.Clear()
	})

	g.After(func() {
		// 在所有测试后运行
		db.Close()
	})

	g.It("should save data", func() {
		// 测试代码
	})
})

4. 断言

Goblin提供多种断言方法：

g.Assert(actual).Equal(expected)      // 等于
g.Assert(actual).IsTrue()             // 为真
g.Assert(actual).IsFalse()            // 为假
g.Assert(actual).IsNil()              // 为nil
g.Assert(actual).IsNotNil()          // 不为nil
g.Assert(actual).IsZero()            // 为零值
g.Assert(actual).IsNotZero()         // 不为零值
g.Assert(actual).Eql(expected)       // 深度相等
g.Assert(actual).NotEql(expected)    // 深度不相等
g.Assert(actual).Contains(substr)    // 包含子串
g.Assert(actual).HasField(fieldName) // 包含字段

5. 异步测试

Goblin支持异步测试：

g.It("Should work asynchronously", func(done Done) {
	go func() {
		g.Assert(true).IsTrue()
		done() // 调用done表示测试完成
	}()
})

完整示例

下面是一个更完整的示例，展示Goblin的各种功能：

package main

import (
	"testing"
	"github.com/franela/goblin"
)

type Calculator struct {
	result int
}

func (c *Calculator) Add(a, b int) int {
	c.result = a + b
	return c.result
}

func (c *Calculator) Subtract(a, b int) int {
	c.result = a - b
	return c.result
}

func (c *Calculator) GetLastResult() int {
	return c.result
}

func TestCalculator(t *testing.T) {
	g := goblin.Goblin(t)

	g.Describe("Calculator", func() {
		var calc *Calculator

		g.BeforeEach(func() {
			calc = &Calculator{}
		})

		g.Describe("#Add", func() {
			g.It("Should add two numbers correctly", func() {
				result := calc.Add(2, 3)
				g.Assert(result).Equal(5)
				g.Assert(calc.GetLastResult()).Equal(result)
			})

			g.It("Should handle negative numbers", func() {
				g.Assert(calc.Add(-1, -1)).Equal(-2)
			})
		})

		g.Describe("#Subtract", func() {
			g.It("Should subtract two numbers correctly", func() {
				g.Assert(calc.Subtract(5, 3)).Equal(2)
			})

			g.It("Should handle negative results", func() {
				g.Assert(calc.Subtract(3, 5)).Equal(-2)
			})
		})

		g.Describe("Async test", func() {
			g.It("Should work asynchronously", func(done Done) {
				go func() {
					g.Assert(calc.Add(1, 1)).Equal(2)
					done()
				}()
			})
		})
	})
}

与标准testing包的比较

Goblin相比标准testing包的主要优势：

  1. 更可读的BDD风格语法
  2. 更好的测试组织结构(Describe/It)
  3. 内置丰富的断言方法
  4. 支持异步测试
  5. 提供钩子函数支持

总结

Goblin为Go语言带来了类似Mocha的BDD测试体验，使得测试代码更加清晰和易于维护。它特别适合需要复杂测试组织和更丰富断言的场景。对于简单的单元测试，标准testing包可能更轻量，但对于大型项目或需要更表达性测试的场景，Goblin是一个很好的选择。

回到顶部