mirror of https://github.com/stretchr/testify.git
99 lines
3.2 KiB
Go
99 lines
3.2 KiB
Go
package suite
|
|
|
|
import (
|
|
"testing"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
// This suite is intended to store values to make sure that only
|
|
// testing-suite-related methods are run. It's also a fully
|
|
// functional example of a testing suite, using setup/teardown methods
|
|
// and a helper method that is ignored by testify. To make this look
|
|
// more like a real world example, all tests in the suite perform some
|
|
// type of assertion.
|
|
type SuiteTester struct {
|
|
// Include our basic suite logic.
|
|
Suite
|
|
|
|
// Keep counts of how many times each method is run.
|
|
SetupSuiteRunCount int
|
|
TearDownSuiteRunCount int
|
|
SetupTestRunCount int
|
|
TearDownTestRunCount int
|
|
TestOneRunCount int
|
|
TestTwoRunCount int
|
|
NonTestMethodRunCount int
|
|
}
|
|
|
|
// The SetupSuite method will be run by testify once, at the very
|
|
// start of the testing suite, before any tests are run.
|
|
func (suite *SuiteTester) SetupSuite() {
|
|
suite.SetupSuiteRunCount++
|
|
}
|
|
|
|
// The TearDownSuite method will be run by testify once, at the very
|
|
// end of the testing suite, after all tests have been run.
|
|
func (suite *SuiteTester) TearDownSuite() {
|
|
suite.TearDownSuiteRunCount++
|
|
}
|
|
|
|
// The SetupTest method will be run before every test in the suite.
|
|
func (suite *SuiteTester) SetupTest() {
|
|
suite.SetupTestRunCount++
|
|
}
|
|
|
|
// The TearDownTest method will be run after every test in the suite.
|
|
func (suite *SuiteTester) TearDownTest() {
|
|
suite.TearDownTestRunCount++
|
|
}
|
|
|
|
// Every method in a testing suite that begins with "Test" will be run
|
|
// as a test. TestOne is an example of a test. For the purposes of
|
|
// this example, we've included assertions in the tests, since most
|
|
// tests will issue assertions.
|
|
func (suite *SuiteTester) TestOne() {
|
|
beforeCount := suite.TestOneRunCount
|
|
suite.TestOneRunCount++
|
|
assert.Equal(suite.T(), suite.TestOneRunCount, beforeCount + 1)
|
|
}
|
|
|
|
// TestTwo is another example of a test.
|
|
func (suite *SuiteTester) TestTwo() {
|
|
beforeCount := suite.TestTwoRunCount
|
|
suite.TestTwoRunCount++
|
|
assert.NotEqual(suite.T(), suite.TestTwoRunCount, beforeCount)
|
|
}
|
|
|
|
// NonTestMethod does not begin with "Test", so it will not be run by
|
|
// testify as a test in the suite. This is useful for creating helper
|
|
// methods for your tests.
|
|
func (suite *SuiteTester) NonTestMethod() {
|
|
suite.NonTestMethodRunCount++
|
|
}
|
|
|
|
// Make sure that the Run function runs all of the expected methods
|
|
// within a testing suite.
|
|
func TestRunSuite(t *testing.T) {
|
|
suiteTester := new(SuiteTester)
|
|
Run(t, suiteTester)
|
|
|
|
// The suite was only run once, so the SetupSuite and TearDownSuite
|
|
// methods should have each been run only once.
|
|
assert.Equal(t, suiteTester.SetupSuiteRunCount, 1)
|
|
assert.Equal(t, suiteTester.TearDownSuiteRunCount, 1)
|
|
|
|
// There are two test methods (TestOne and TestTwo), so the
|
|
// SetupTest and TearDownTest methods (which should be run once for
|
|
// each test) should have been run twice.
|
|
assert.Equal(t, suiteTester.SetupTestRunCount, 2)
|
|
assert.Equal(t, suiteTester.TearDownTestRunCount, 2)
|
|
|
|
// Each test should have been run once.
|
|
assert.Equal(t, suiteTester.TestOneRunCount, 1)
|
|
assert.Equal(t, suiteTester.TestTwoRunCount, 1)
|
|
|
|
// Methods that don't match the test method identifier shouldn't
|
|
// have been run at all.
|
|
assert.Equal(t, suiteTester.NonTestMethodRunCount, 0)
|
|
}
|