Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/pavlo/gosuite
Test suites support for standard Go1.7 "testing" by leveraging Subtests feature
https://github.com/pavlo/gosuite
Last synced: 10 days ago
JSON representation
Test suites support for standard Go1.7 "testing" by leveraging Subtests feature
- Host: GitHub
- URL: https://github.com/pavlo/gosuite
- Owner: pavlo
- License: mit
- Created: 2016-10-15T19:28:14.000Z (about 8 years ago)
- Default Branch: master
- Last Pushed: 2016-10-18T16:53:21.000Z (about 8 years ago)
- Last Synced: 2024-10-25T05:25:01.499Z (11 days ago)
- Language: Go
- Homepage:
- Size: 19.5 KB
- Stars: 12
- Watchers: 2
- Forks: 4
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-go - gosuite - Brings lightweight test suites with setup/teardown facilities to `testing` by leveraging Go1.7's Subtests. (Testing / Testing Frameworks)
- awesome-go - gosuite - Test suites support for standard Go1.7 "testing" by leveraging Subtests feature - ★ 7 (Testing)
- awesome-go-extra - gosuite - 10-15T19:28:14Z|2016-10-18T16:53:21Z| (Testing / Testing Frameworks)
README
# Go Suite
[](https://semaphoreci.com/pavlikus/gosuite) [](https://codecov.io/gh/pavlo/gosuite)
The support for test suites for Golang 1.7 and later.
Golang 1.7 featured [Subtests](https://golang.org/pkg/testing/) that allowed you to group tests in order to share common setup and teardown logic. While that was a great addition to the `testing` package, it was a bit clunky syntactically. The GoSuite package leverages Golang's 1.7 Subtests feature, defines a simple `TestSuite` interface and runs test cases inside of them keeping setup/teardown logic for the whole suite and for single cases in place.
## Quick Start
To start with, create a struct with the four methods implemented:
```go
type MyTestSuite struct {
// DB connection
// etc
}
// SetUpSuite is called once before the very first test in suite runs
func (s *MyTestSuite) SetUpSuite() {
}
// TearDownSuite is called once after thevery last test in suite runs
func (s *MyTestSuite) TearDownSuite() {
}
// SetUp is called before each test method
func (s *MyTestSuite) SetUp() {
}
// TearDown is called after each test method
func (s *MyTestSuite) TearDown() {
}
```
Then add one or more test methods to it, prefixing them with `Test` prefix:
```go
func (s *MyTestSuite) TestMyFirstTestCase(t *testing.T) {
if !someJob {
t.Fail("Unexpected failure!")
}
}
```
Almost done! The only piece that remains is to run the suite! You do this by calling the `Run` method. Note, the enclosing `TestIt` method is a normal testing method you usually write in Go, nothing fancy at all!
```go
func TestIt(t *testing.T) {
Run(t, &MyTestSuite{})
}
```
## Installation
To install Go Suite, use `go get`:
```
go get github.com/pavlo/gosuite
```
The import the `pavlo/gosuite` package into your code like this:
```go
package yours
import (
"testing"
"github.com/pavlo/gosuite"
)
...
```
## Complete Example
The complete example is shown to help you to see the whole thing on the same page. Note, it leverages the [Is](https://github.com/tylerb/is) package for assertions... the package is great though indeed it is not required to use with Go Suite. *The example however demonstrates a slick technique making the assertion methods available on the suite itself!*
```go
import (
"testing"
"github.com/pavlo/gosuite"
)
type Suite struct {
*is.Is
setUpSuiteCalledTimes int
tearDownSuiteCalledTimes int
setUpCalledTimes int
tearDownUpCalledTimes int
}
func (s *Suite) SetUpSuite() {
s.setUpSuiteCalledTimes++
}
func (s *Suite) TearDownSuite() {
s.tearDownSuiteCalledTimes++
}
func (s *Suite) SetUp() {
s.setUpCalledTimes++
}
func (s *Suite) TearDown() {
s.tearDownUpCalledTimes++
}
func TestIt(t *testing.T) {
s := &Suite{Is: is.New(s.t)}
gosuite.Run(t, s)
s.Equal(1, s.setUpSuiteCalledTimes)
s.Equal(1, s.tearDownSuiteCalledTimes)
s.Equal(2, s.setUpCalledTimes)
s.Equal(2, s.tearDownUpCalledTimes)
}
func (s *Suite) TestFirstTestMethod(t *testing.T) {
s.Equal(1, s.setUpSuiteCalledTimes)
s.Equal(0, s.tearDownSuiteCalledTimes)
s.Equal(1, s.setUpCalledTimes)
s.Equal(0, s.tearDownUpCalledTimes)
}
func (s *Suite) TestSecondTestMethod(t *testing.T) {
s.Equal(1, s.setUpSuiteCalledTimes)
s.Equal(0, s.tearDownSuiteCalledTimes)
s.Equal(2, s.setUpCalledTimes)
s.Equal(1, s.tearDownUpCalledTimes)
}
```
Running it with `go test -v` would emit this:
```
> go test -v
=== RUN TestIt
=== RUN TestIt/TestFirstTestMethod
=== RUN TestIt/TestSecondTestMethod
--- PASS: TestIt (0.00s)
--- PASS: TestIt/TestFirstTestMethod (0.00s)
--- PASS: TestIt/TestSecondTestMethod (0.00s)
PASS
ok github.com/pavlo/gosuite 0.009s
Success: Tests passed.
```
## License
`Go Suite` is released under the [MIT License](http://www.opensource.org/licenses/MIT).