suite

Documentation

Overview

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 defining a Suite struct that includes all fields that tests need.

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. Test methods must match signature: `func(*suite.T)`. The suite.T object passed may be used to run sub-tests, verify assertions and control test execution. 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/denist-huma/testify/v2/suite"
)

// Define the suite, which is simply a struct with all
// fields that tests need.
type ExampleTestSuite struct {
    VariableThatShouldStartAtFive int
}

// Make sure that VariableThatShouldStartAtFive is set to five
// before each test
func (suite *ExampleTestSuite) SetupTest(t *suite.T) {
    suite.VariableThatShouldStartAtFive = 5
}

// All methods that begin with "Test" are run as tests within a
// suite.
func (suite *ExampleTestSuite) TestExample(t *suite.T) {
    assert.Equal(t, 5, suite.VariableThatShouldStartAtFive)
    t.Equal(5, suite.VariableThatShouldStartAtFive)
}

// 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))
}

Index

• func Run(testingT *testing.T, suite interface{})
• type AfterTest
• type BeforeTest
• type SetupAllSuite
• type SetupTestSuite
• type SuiteInformation
  • func (s SuiteInformation) Passed() bool
• type T
  • func (t *T) Cleanup(f func())
  • func (t *T) Deadline() (deadline time.Time, ok bool)
  • func (t *T) Error(args ...interface{})
  • func (t *T) Errorf(format string, args ...interface{})
  • func (t *T) Fail()
  • func (t *T) FailNow()
  • func (t *T) Failed() bool
  • func (t *T) Fatal(args ...interface{})
  • func (t *T) Fatalf(format string, args ...interface{})
  • func (t *T) Helper()
  • func (t *T) Log(args ...interface{})
  • func (t *T) Logf(format string, args ...interface{})
  • func (t *T) Name() string
  • func (t *T) Parallel()
  • func (t *T) Require() *require.Assertions
  • func (t *T) Run(name string, subtest func(t *T)) bool
  • func (t *T) Setenv(key, value string)
  • func (t *T) Skip(args ...interface{})
  • func (t *T) SkipNow()
  • func (t *T) Skipf(format string, args ...interface{})
  • func (t *T) Skipped() bool
  • func (t *T) TempDir() string
• type TearDownAllSuite
• type TearDownTestSuite
• type TestInformation
• type WithStats

Functions

func Run

func Run(testingT *testing.T, suite interface{})

Run takes a testing suite and runs all of the tests attached to it.

Types

type AfterTest

type AfterTest interface {
	AfterTest(t *T, suiteName, testName string)
}

AfterTest has a function to be executed right after the test finishes and receives the suite and test names as input

type BeforeTest

type BeforeTest interface {
	BeforeTest(t *T, suiteName, testName string)
}

BeforeTest has a function to be executed right before the test starts and receives the suite and test names as input

type SetupAllSuite

type SetupAllSuite interface {
	SetupSuite(t *T)
}

SetupAllSuite has a SetupSuite method, which will run before the tests in the suite are run.

type SetupTestSuite

type SetupTestSuite interface {
	SetupTest(t *T)
}

SetupTestSuite has a SetupTest method, which will run before each test in the suite.

type SuiteInformation

type SuiteInformation struct {
	Start, End time.Time
	TestStats  map[string]*TestInformation
}

SuiteInformation stats stores stats for the whole suite execution.

func (SuiteInformation) Passed

func (s SuiteInformation) Passed() bool

type T

type T struct {
	*assert.Assertions
	// contains filtered or unexported fields
}

T is a basic testing suite with methods for accessing appropriate *testing.T objects in tests.

func (*T) Cleanup

func (t *T) Cleanup(f func())

func (*T) Deadline

func (t *T) Deadline() (deadline time.Time, ok bool)

func (*T) Error

func (t *T) Error(args ...interface{})

func (*T) Errorf

func (t *T) Errorf(format string, args ...interface{})

func (*T) Fail

func (t *T) Fail()

func (*T) FailNow

func (t *T) FailNow()

func (*T) Failed

func (t *T) Failed() bool

func (*T) Fatal

func (t *T) Fatal(args ...interface{})

func (*T) Fatalf

func (t *T) Fatalf(format string, args ...interface{})

func (*T) Helper

func (t *T) Helper()

func (*T) Log

func (t *T) Log(args ...interface{})

func (*T) Logf

func (t *T) Logf(format string, args ...interface{})

func (*T) Name

func (t *T) Name() string

func (*T) Parallel

func (t *T) Parallel()

func (*T) Require

func (t *T) Require() *require.Assertions

Require returns a require context for suite.

func (*T) Run

func (t *T) Run(name string, subtest func(t *T)) bool

Run provides suite functionality around golang subtests. It should be called in place of t.Run(name, func(t *testing.T)) in test suite code. The passed-in func will be executed as a subtest with a fresh instance of t. Provides compatibility with go test pkg -run TestSuite/TestName/SubTestName.

func (*T) Setenv

func (t *T) Setenv(key, value string)

func (*T) Skip

func (t *T) Skip(args ...interface{})

func (*T) SkipNow

func (t *T) SkipNow()

func (*T) Skipf

func (t *T) Skipf(format string, args ...interface{})

func (*T) Skipped

func (t *T) Skipped() bool

func (*T) TempDir

func (t *T) TempDir() string

type TearDownAllSuite

type TearDownAllSuite interface {
	TearDownSuite(t *T)
}

TearDownAllSuite has a TearDownSuite method, which will run after all the tests in the suite have been run.

type TearDownTestSuite

type TearDownTestSuite interface {
	TearDownTest(t *T)
}

TearDownTestSuite has a TearDownTest method, which will run after each test in the suite.

type TestInformation

type TestInformation struct {
	TestName   string
	Start, End time.Time
	Passed     bool
}

TestInformation stores information about the execution of each test.

type WithStats

type WithStats interface {
	HandleStats(t *T, suiteName string, stats *SuiteInformation)
}

WithStats implements HandleStats, a function that will be executed when a test suite is finished. The stats contain information about the execution of that suite and its tests.