README
¶
Documentation
¶
Overview ¶
Package is provides a lightweight extension to the standard library's testing capabilities.
Comments on the assertion lines are used to add a description.
The following failing test:
func Test(t *testing.T) {
tst := tst.New(t)
a, b := 1, 2
tst.Equal(a, b) // expect to be the same
}
Will output:
your_test.go:123: 1 != 2 // expect to be the same
Usage ¶
The following code shows a range of useful ways you can use the helper methods:
func Test(t *testing.T) {
// always start tests with this
tst := tst.New(t)
signedin, err := isSignedIn(ctx)
tst.NoErr(err) // isSignedIn error
tst.Equal(signedin, true) // must be signed in
body := readBody(r)
tst.True(strings.Contains(body, "Hi there"))
}
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type T ¶
type T interface {
// Fail indicates that the test has failed but
// allowed execution to continue.
// Fail is called in relaxed mode (via NewRelaxed).
Fail()
// FailNow indicates that the test has failed and
// aborts the test.
// FailNow is called in strict mode (via New).
FailNow()
}
T reports when failures occur. testing.T implements this interface.
type Tst ¶
type Tst struct {
// contains filtered or unexported fields
}
Tst is the test helper harness.
func New ¶
New makes a new testing helper using the specified T through which failures will be reported. In strict mode, failures call T.FailNow causing the test to be aborted. See NewRelaxed for alternative behavior.
func (*Tst) Equal ¶
Equal asserts that a and b are equal.
func Test(t *testing.T) {
tst := tst.New(t)
a := greet("Mat")
tst.Equal(a, "Hi Mat") // greeting
}
Will output:
your_test.go:123: Hey Mat != Hi Mat // greeting
func (*Tst) Err ¶
Err asserts that err is not nil.
func Test(t *testing.T) {
tst := tst.New(t)
val, err := getVal()
tst.Err(err) // getVal error
tst.True(val == nil) // val cannot be short
}
Will output:
your_test.go:123: err: not found // getVal error
func (*Tst) Fail ¶
func (tst *Tst) Fail()
Fail immediately fails the test.
func Test(t *testing.T) {
tst := tst.New(t)
tst.Fail() // TODO: write this test
}
In relaxed mode, execution will continue after a call to Fail, but that test will still fail.
func (*Tst) False ¶
False asserts that the expression is false. The expression code itself will be reported if the assertion fails.
func Test(t *testing.T) {
tst := tst.New(t)
val := method()
tst.False(val == nil) // val is always nil
}
Will output:
your_test.go:123: not false: val == nil
func (*Tst) Helper ¶
func (tst *Tst) Helper()
Helper marks the calling function as a test helper function. When printing file and line information, that function will be skipped.
Available with Go 1.7 and later.
func (*Tst) New ¶
New is a method wrapper around the New function. It allows you to write subtests using a similar pattern:
func Test(t *testing.T) {
tst := tst.New(t)
t.Run("sub", func(t *testing.T) {
tst := tst.New(t)
// TODO: test
})
}
func (*Tst) NoErr ¶
NoErr asserts that err is nil.
func Test(t *testing.T) {
tst := tst.New(t)
val, err := getVal()
tst.NoErr(err) // getVal error
tst.True(len(val) > 10) // val cannot be short
}
Will output:
your_test.go:123: err: not found // getVal error
Source Files