stdtest

type Assert ¶

type Assert struct {
	// contains filtered or unexported fields
}

Assert implements helpers for common assertion patterns.

func (a *Assert) Equal(got, want any) bool

func (a *Assert) ErrorEqual(got, want error) bool

func (a *Assert) False(condition bool, format string, args ...any) bool

func (a *Assert) Match(got, wantPattern string) bool

func (a *Assert) NotOK(err error) bool

func (a *Assert) OK(err error) bool

func (a *Assert) Panic(got func()) bool

func (a *Assert) PointerEqual(got, want any) bool

func (a *Assert) True(condition bool, format string, args ...any) bool

type Asserter ¶

type Asserter interface {
	True(condition bool, format string, args ...any) bool
	False(condition bool, format string, args ...any) bool
	OK(err error) bool
	NotOK(err error) bool
	Match(got, want string) bool
	Equal(got, want any) bool
	PointerEqual(got, want any) bool
	ErrorEqual(got, want error) bool
	Panic(got func()) bool
}

Asserter defines common test assertions.

type Check ¶

type Check struct {
	// contains filtered or unexported fields
}

Check implements property testing via the "testing/quick" package.

func (c *Check) Check(fn any) bool

func (c *Check) CheckEqual(fn1, fn2 any) bool

type Checker ¶

type Checker interface {
	Check(fn any) bool
	CheckEqual(fn1, fn2 any) bool
}

Checker defines common quick tests.

type Logf ¶

type Logf func(format string, args ...any)

Logf is the func called when a boolean condition is not met as part of an assertion. It's responsible for generating output to a user indicating the test failure and either allowing the test to continue or immediately stop execution.

type Table ¶

type Table[TGot any, TWant any] map[string]Testcase[TGot, TWant]

Table represents a collection of "table tests" in the form of named test cases.

type Test ¶

type Test struct {
	testing.TB
	Asserter
	Checker
}

Test merges the stdlib 'testing.TB' with our test helpers into a single implementation.

By using this 'Test' instead of the `testing` structs (T, B, F) we can automatically handle many common assertion patterns and preconditions for different test types (functional, fuzz, or integration).

func BenchmarkTest(t *testing.B, options ...stdlib.Option[*TestConfig]) *Test

func FuzzTest(t *testing.F, options ...stdlib.Option[*TestConfig]) *Test

func IntegrationTest(t *testing.T, options ...stdlib.Option[*TestConfig]) *Test

func PropertyTest(t testing.TB, options ...stdlib.Option[*TestConfig]) *Test

func UnitTest(t testing.TB, options ...stdlib.Option[*TestConfig]) *Test

func (t *Test) Sub(
	name string,
	fn func(subtest *Test),
	options ...stdlib.Option[*TestConfig],
) bool

type TestConfig ¶

type TestConfig struct {
	// Logf is called when condition of test assertion is not met.
	Logf Logf
	// Parallel enables/disables Parallel test execution.
	Parallel bool
	// Precondition is called before test execution to determine if test should
	// be skipped and the reason for it.
	Precondition TestPrecondition
	// QuickConfig modifies of how quick test (property tests) are executed.
	QuickConfig *quick.Config
}

TestConfig defines config options for test.

func NewTestConfig(options ...stdlib.Option[*TestConfig]) (*TestConfig, error)

type TestFunc ¶

type TestFunc[TGot any, TWant any] func(t *Test, tc Testcase[TGot, TWant])

TestFunc is a function that executes a single test for the given testcase.

Note: The benefit of passing in an isolated function for the test is that we can avoid issues with closures when t.Run(...) is called in parallel with the testcase.

type TestPrecondition ¶

type TestPrecondition func() (bool, string)

TestPrecondition is a func called prior to test execution to determine if the test should be skipped and the reason for it.

type Testcase ¶

type Testcase[TGot any, TWant any] struct {
	// Got stores inputs for the testcase.
	Got TGot
	// Want stores the expectations for the testcase.
	Want TWant
	// WantErr stores the optional error expectation for the testcase.
	WantErr error
	// Options are custom options for test execution specific to this case.
	Options []stdlib.Option[*TestConfig]
}

Testcase encapsulates the inputs and expectations of a single testcase.