Package suite
Package suite contains logic for creating testing suite structs
and running the methods on those structs as tests. The most useful
piece of this package is that you can create setup/teardown methods
on your testing suites, which will run before/after the whole suite
or individual tests (depending on which interface(s) you
implement).
A testing suite is usually built by first extending the built-in
suite functionality from suite.Suite in testify. Alternatively,
you could reproduce that logic on your own if you wanted (you
just need to implement the TestingSuite interface from
suite/interfaces.go).
After that, you can implement any of the interfaces in
suite/interfaces.go to add setup/teardown functionality to your
suite, and add any methods that start with "Test" to add tests.
Methods that do not match any suite interfaces and do not begin
with "Test" will not be run by testify, and can safely be used as
helper methods.
Once you've built your testing suite, you need to run the suite
(using suite.Run from testify) inside any function that matches the
identity that "go test" is already looking for (i.e.
func(*testing.T)).
Regular expression to select test suites specified command-line
argument "-run". Regular expression to select the methods
of test suites specified command-line argument "-m".
Suite object has assertion methods.
A crude example:
// Basic imports
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
)
// Define the suite, and absorb the built-in basic suite
// functionality from testify - including a T() method which
// returns the current testing context
type ExampleTestSuite struct {
suite.Suite
VariableThatShouldStartAtFive int
}
// Make sure that VariableThatShouldStartAtFive is set to five
// before each test
func (suite *ExampleTestSuite) SetupTest() {
suite.VariableThatShouldStartAtFive = 5
}
// All methods that begin with "Test" are run as tests within a
// suite.
func (suite *ExampleTestSuite) TestExample() {
assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive)
suite.Equal(5, suite.VariableThatShouldStartAtFive)
}
// In order for 'go test' to run this suite, we need to create
// a normal test function and pass our suite to suite.Run
func TestExampleTestSuite(t *testing.T) {
suite.Run(t, new(ExampleTestSuite))
}
In the call graph viewer below, each node
is a function belonging to this package
and its children are the functions it
calls—perhaps dynamically.
The root nodes are the entry points of the
package: functions that may be called from
outside the package.
There may be non-exported or anonymous
functions among them if they are called
dynamically from another package.
Click a node to visit that function's source code.
From there you can visit its callers by
clicking its declaring func
token.
Functions may be omitted if they were
determined to be unreachable in the
particular programs or tests that were
analyzed.
func Run(t *testing.T, suite TestingSuite)
Run takes a testing suite and runs all of the tests attached
to it.
SetupAllSuite has a SetupSuite method, which will run before the
tests in the suite are run.
type SetupAllSuite interface {
SetupSuite()
}
SetupTestSuite has a SetupTest method, which will run before each
test in the suite.
type SetupTestSuite interface {
SetupTest()
}
Suite is a basic testing suite with methods for storing and
retrieving the current *testing.T context.
type Suite struct {
*assert.Assertions
}
func (*Suite) Assert
¶
func (suite *Suite) Assert() *assert.Assertions
Assert returns an assert context for suite. Normally, you can call
`suite.NoError(expected, actual)`, but for situations where the embedded
methods are overridden (for example, you might want to override
assert.Assertions with require.Assertions), this method is provided so you
can call `suite.Assert().NoError()`.
func (suite *Suite) Require() *require.Assertions
Require returns a require context for suite.
func (*Suite) SetT
¶
func (suite *Suite) SetT(t *testing.T)
SetT sets the current *testing.T context.
func (*Suite) T
¶
func (suite *Suite) T() *testing.T
T retrieves the current *testing.T context.
TearDownAllSuite has a TearDownSuite method, which will run after
all the tests in the suite have been run.
type TearDownAllSuite interface {
TearDownSuite()
}
TearDownTestSuite has a TearDownTest method, which will run after
each test in the suite.
type TearDownTestSuite interface {
TearDownTest()
}
TestingSuite can store and return the current *testing.T context
generated by 'go test'.
type TestingSuite interface {
T() *testing.T
SetT(*testing.T)
}
ActiveGo 1.8