6 Golang Testing Frameworks for Every Type of Test

If you’ve decided that a language-specific testing tool is the right choice for you, or if you’re merely looking to see what’s available, it’s time to see what your options are.

Below you’ll find the six most popular testing frameworks for Golang applications.

Go testing

While it was said in the beginning that the default testing package is fairly limited, it’s still important to keep the standard library in consideration.

Some key advantages of the default testing library are:

• Running benchmarks
• Sub-benchmarks
• SubtestsSupport for test skipping to limit scope
• Support for test setup and teardown

These features combine into a framework that’s simple to use and configure, making it easy to write quick tests to either verify simple behavior or benchmark your application.

However, it’s important to keep in mind that the package does not support assertions, something you may know from other testing packages in other languages.

Instead, the Go team recommends using table-driven tests, as they believe adding assertions and helper functions does not follow best practices.

The package is fairly simple to use, but you may find that tests written are readable but perhaps not as expressive as you may want.

After running the tests with go test you can generate reports using the go tool cover command; however, you may find them to be less descriptive than desired, especially when a test fails.

The package is well documented and the Go website offers FAQs, blog posts, and tutorials. You’ll also find several entries about the testing package on the Go wiki. The core Go team actively supports it, and the Go community provides plenty of help for beginners as well.

Go testing example

A simple example with the testing package can look like this:

func TestIntMinBasic(t *testing.T) {

   and := Intmin(2, -2)

   if ans != -2 {

       t.Errorf("IntMin(2, -2) = %d; want -2", and)

   }

}

Example borrowed from GoByExample

Testify

Testify is arguably the most popular Golang testing framework and offers a range of helpful features:

• Assertion functions
• Mock objects
• Test grouping
• Test setup and teardown

The inclusion of assertion and mock code makes testing much easier and faster. With the suite package, you can collect related tests and create a shared test setup and teardown.

Mock objects allow easy testing even with external dependencies.Testify’s test output is standard and not as detailed as other options. However, it does offer the option to annotate assertions with messages, making the tests more expressive. Testify’s assertion functions can help identify why a test fails, aiding developers in quickly pinpointing the issue.

If you’re a beginner, Testify will be very welcoming to you with its user-friendly interface for assert func and mock objects. It works well as a complement to the testing package and go test command.

It doesn’t offer its own custom coverage reporting, unlike other packages, instead relying on the same go tool cover command as the testing package. So if you’re unhappy with the reporting capabilities of the testing package, Testify may not be the right alternative for you.

All in all, Testify is a solid package depending on your needs. If you are happy with the default testing package but want more expressive tests as well as assertions, then Testify is likely to be a good choice for you.

There’s a large community of users and contributors for Testify, but updates and new features are few and far between. On the other hand, there are multiple Slack channels where users can interact and seek help, so finding support is fairly painless.

Testify example

A simple Testify example could look as follows:

func TestSomething(t *testing.T) {

 // assert equality

 assert.Equal(t, 123, 123, "they should be equal")

 // assert inequality

 assert.NotEqual(t, 123, 456, "they should not be equal")

 // assert for nil (good for errors)

 assert.Nil(t, object)

 // assert for not nil (good when you expect something)

 if assert.NotNil(t, object) {

   // now we know that object isn't nil, we are safe to make

   // further assertions without causing any errors

   assert.Equal(t, "Something", object.Value)

 }

}

Example borrowed from the Testify pkg page

GoConvey

GoConvey is a BDD testing framework (behavior driven development) that takes a somewhat different approach to other testing frameworks.

Some key features are:

• Using a domain-specific language (DSL)
• The ability to create self-documenting, highly readable tests
• Supports for contexts and scopesSupport for assertions
• Availability of web UI

Using the Convey function, you can set up contexts and scopes for a test, and with the So function, you can make assertions.

There are two main ways to get a test report output with GoConvey: in the terminal or through a web UI.

The terminal test output is detailed, colorized, and readable. Its web UI offers similar output in a more user-friendly way, with the addition of several themes and notifications options. This combination makes it useful for developers as well as managers. GoConvey’s detailed reports help identify why a test fails, ensuring that only relevant information about the failing test is presented.

With the wide range of assertion helpers provided by GoConvey, you should be able to validate and verify any value you may want.

It supports fine-grained control of test execution, allowing you to pause and resume tests. It even allows you to generate tests through the web UI.

GoConvey has a rather large community of contributors, although updates to its codebase are infrequent. Its GitHub Wiki is well documented, with more information available on the GoConvey pkg documentation page and GitHub Repo.

GoConvey example

A simple GoConvey test can look like this:

func TestSpec(t *testing.T) {

   // Only pass t into top-level Convey calls

   Convey("Given some integer with a starting value", t, func() {

       x := 1

       Convey("When the integer is incremented", func() {

           x++

           Convey("The value should be greater by one", func() {

               So(x, ShouldEqual, 2)

           })

       })

   })

}

Example borrowed from the GoConvey pkg pag