test

package
v0.0.51 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 4, 2026 License: MIT Imports: 25 Imported by: 0

README

Package testing/test

The goal of this package is to provide a small framework to isolate the test execution and safely check whether a test succeeds or fails as expected. In combination with the mock package it ensures that a test finishes reliably and reports its failure even if a system under test is spawning go-routines.

Example usage

Use the following example to intercept and validate a panic using the isolated test environment.

func TestUnit(t *testing.T) {
    test.Run(test.Success, func(t test.Test){
        // Given
        mock.NewMocks(t).Expect(
            test.Panic("fail"),
        )

        // When
        panic("fail")
    ...
    })(t)
}

But there are many other supported use case, you can discover reading the below examples.

Isolated parameterized parallel test runner

The test framework supports to run isolated, parameterized, parallel tests using a lean test runner. The runner can be instantiated with a single test parameter set (test.Param), a slice of test parameter sets (test.Slice), or a map of test case name to test parameter sets (test.Map - preferred pattern). The test is started by Run that accepts a simple test function as input, using a test.Test interface, that is compatible with most tools, e.g. gomock.

func TestUnit(t *testing.T) {
    test.Param|Slice|Map|Any(t, unitTestCases).
        Filter("test-case-name", false|true).
        Timeout(5*time.Millisecond).
        StopEarly(time.Millisecond).
        Run|RunSeq(func(t test.Test, param UnitParams){
            // Given

            // When

            // Then
        }).Cleanup(func(){
            // clean test resources
        })
}

This creates and starts a lean test wrapper using a common interface, that isolates test execution and intercepts all failures (including panics), to either forward or suppress them. The result is controlled by providing a test parameter of type test.Expect (name expect) that supports test.Failure (false) and Success (true - default).

Similar a test case name can be provided using type test.Name (name name - default value unknown-%d) or as key using a test case name to parameter set mapping.

Note: See Parallel tests requirements for more information on requirements in parallel parameterized tests. If parallel parameterized test are undesired, RunSeq can be used to enforce a sequential test execution.

It is also possible to select a subset of tests for execution by setting up a Filter using a regular expression to match or filter by the normalized test name, or to set up a Timeout as well as a grace period to StopEarly for giving the Cleanup-functions sufficient time to free resources.

Isolated in-test environment setup

It is also possible to isolate only a single test step by setting up a small test function that is run in isolation.

func TestUnit(t *testing.T) {
    test.Map(t, unitTestCases).
        Run|RunSeq(func(t test.Test, param UnitParams){
            // Given

            // When
            test.InRun(test.Failure, func(t test.Test) {
                ...
            })(t)

            // Then
        })
}

Manual isolated test environment setup

If the above pattern is not sufficient, you can create your own customized parameterized, parallel, isolated test wrapper using the basic abstraction test.Run|RunSeq(test.Success|Failure, func (t test.Test) {}):

func TestUnit(t *testing.T) {
    t.Parallel()

    for name, param := range unitTestCases {
        t.Run(name, test.Run(param.expect, func(t test.Test) {
            t.Parallel()

            // Given

            // When

            // Then
        }))
    }
}

Or finally, use even more directly the flexible test.Context that is providing the features on top of the underlying test.Test interface abstraction, if you need more control about the test execution:

func TestUnit(t *testing.T) {
    t.Parallel()

    test.New(t, test.Success).
        Timeout(5*time.Millisecond).
        StopEarly(time.Millisecond).
        Run(func(t test.Test){
            // Given

            // When

            // Then
        })(t)
}

Isolated failure/panic validation

Besides just capturing the failure in the isolated test environment, it is also very simple possible to validate the failures/panics using the self installing validator that is tightly integrated with the mock framework.

func TestUnit(t *testing.T) {
    test.Run(func(t test.Test){
        // Given
        mock.NewMocks(t).Expect(mock.Setup(
            test.Errorf("fail"),
            test.Fatalf("fail"),
            test.FailNow(),
            test.Panic("fail"),
        ))

        // When
        t.Errorf("fail")
        ...
        // And one of the terminal calls.
        t.Fatalf("fail")
        t.FailNow()
        panic("fail")

        // Then
    })(t)
}

Note: To enable panic testing, the isolated test environment is recovering from all panics by default and converting them in fatal error messages. This is often most usable and sufficient to fix the issue. If you need to discover the source of the panic, you need to spawn a new unrecovered go-routine.

Hint: gomock uses very complicated reporting patterns that are hard to recreate. Do not try it.

Out-of-the-box test patterns

Currently, the package supports two out-of-the-box test patterns:

  1. test.Main(func()) - allows to test main methods by calling the main method with arguments in a well controlled test environment.
  2. test.Recover(Test,any) - allows to check the panic result in simple test scenarios where test.Panic(any) is not applicable.
Main method tests pattern

The test.Main(func()) pattern executes the main method in a separate test process to protect the test execution against os.Exit calls while allowing to capture and check the exit code against the expectation. The following example demonstrates how to use the pattern to test a main method:

mainTestCases := map[string]test.MainParams{
    "no mocks": {
        Args: []string{"mock", "arg1", "arg2"},
        Env: []string{"VAR=value"},
        ExitCode: 0,
    },
}

func TestMain(t *testing.T) {
    test.Map(t, mainTestCases).Run(test.TestMain(main))
}

If the test process is expected to run longer than the default test timeout, a context with timeout can be provided to interrupt the test process in time, e.g. as follows:

    Ctx: test.First(context.WithTimeout(context.Bachground(), time.Second))

Note: the general approach can be used to test any code calling os.Exit, however, it is focused on testing the main methods with and without parsing command line arguments.

Note: In certain situations, test.Main(func()) currently fails to obtain the coverage metrics for the test execution, since go test is using the standard output to collect results. We are investigating how we can separate these in the test execution from expected test output.

Convenience functions

The test package contains a number of convenience functions to simplify the test setup and apply certain test patterns. Currently, the following functions currently supported:

  • test.Must[T](T, error) T - a convenience method for fluent test case setup that converts an error into a panic.
  • test.Cast[T](T) T - a convenience method for fluent test case setup that converts an casting error into a panic compliant with linting requirements.
  • test.Ptr[T](T) *T - a convenience method for fluent test case setup that converts a literal value into a pointer.
  • test.First[T](T, ...any) - a convenience method for fluent test case setup that extracts the first value of a response ignoring the others.

Please also have a look at the convenience functions provided by the reflect package, that allows you to fluently access non-exported fields for setting up and checking.

Documentation

Overview

Package test contains the main collection of functions and types for setting up the basic isolated test environment. It is part of the public interface and starting to get stable, however, we are still experimenting to optimize the interface and the user experience.

Index

Constants

View Source 
const GoTestingRunVar = "GO_TESTING_RUN"

GoTestingRunVar is the environment variable used to signal the new process to execute the `main` method instead of spawning a new test process.

Variables

View Source 
var ErrInvalidType = errors.New("invalid type")

ErrInvalidType is an error for invalid types.

Functions

func Cast added in v0.0.35 

func Cast[T any](arg any) T

Cast is a convenience function to cast the given argument to the specified type or panic if the cast fails. The method allows to write concise test setup code granting meaningful type checks.

func ConsumedCall 

func ConsumedCall[T any](
	creator func(*gomock.Controller) *T,
	method, caller, ecaller string, args ...any,
) func(Test, *mock.Mocks) mock.SetupFunc

func DeepCopy added in v0.0.36 

func DeepCopy(t Test, p DeepCopyParams)

DeepCopy provides a test function that tests a the `DeepCopy*` functions generated by `k8s.io/code-generator/cmd/deepcopy-gen` as part of the type system.

The test function verifies that the copied value is equal to the original value but not the same reference. For simplicity, the function only requires a template to generate random non-zero test values that ensure covering all code paths. If this fails, you can vary the random seed, as well as the limits on the slice and map sizes (`size`) and string lengths (`len`).

The following code shows a quick example of how to use this function in a tests:

```go 

var deepCopyTestCases = DeepCopyTestCases(42, 3, 10,
	   &MyStruct{}, (*MyStruct)(nil), ...)

func TestDeepCopy(t *testing.T) {
	test.Map(t, deepCopyTestCases).Run(test.DeepCopy)
}

``` *Note:* the test cases can also be generated inside the `TestDeepCopy` function.

func DeepCopyTestCases added in v0.0.39 

func DeepCopyTestCases(
	seed int64, size, length int, args ...any,
) map[string]DeepCopyParams

DeepCopyTestCases creates the test cases from a list of types to be tested either given as value or as nil pointer. For each type two test cases are created:

* A non-nil random value, and * A nil pointer of the type.

The types must implement either the `DeepCopy` or the `DeepCopyObject` method generated by `k8s.io/code-generator/cmd/deepcopy-gen` to succeed.

func EqCall 

func EqCall(x any) gomock.Matcher

EqCall creates a new call matcher that allows to match calls by translating them to the string containing the core information instead of using the standard matcher using reflect.DeepEquals that fails for the contained actions.

func EqError 

func EqError(x any) gomock.Matcher

EqError creates a new error matcher that allows to match either the error or alternatively the string describing the error.

func Error added in v0.0.15 

func Error(args ...any) mock.SetupFunc

Error creates a validation method call setup for `Error`.

func Errorf 

func Errorf(format string, args ...any) mock.SetupFunc

Errorf creates a validation method call setup for `Errorf`.

func Fail added in v0.0.22 

func Fail() mock.SetupFunc

Fail creates a validation method call setup for `Fail`.

func FailNow 

func FailNow() mock.SetupFunc

FailNow creates a validation method call setup for `FailNow`.

func Fatal added in v0.0.22 

func Fatal(args ...any) mock.SetupFunc

Fatal creates a validation method call setup for `Fatal`.

func Fatalf 

func Fatalf(format string, args ...any) mock.SetupFunc

Fatalf creates a validation method call setup for `Fatalf`.

func First added in v0.0.30 

func First[T any](arg T, _ ...any) T

First is a convenience function to return the first argument and ignore all others arguments. The method allows to write concise test setup code.

func Log added in v0.0.45 

func Log(args ...any) mock.SetupFunc

Log creates a validation method call setup for `Log`.

func Logf added in v0.0.45 

func Logf(format string, args ...any) mock.SetupFunc

Logf creates a validation method call setup for `Logf`.

func Main added in v0.0.29 

func Main(main func()) func(t Test, param MainParams)

Main creates a test function that runs the given `main`-method in a separate test process to protect the test execution from `os.Exit` calls while allowing to capture and check the exit code against the expectation. The following example demonstrates how to use this method to test a `main`-method: 

 mainTestCases := map[string]test.MainParam{
	 "with args": {
		 Args: []string{"mock", "arg1", "arg2"},
		 Env:  []string{"VAR=value"},
		 ExitCode: 0,
	 },
 }

 func Main(t *testing.T) {
	 test.Map(t, mainTestCases).Run(test.Main(main))
 }

If the test process is expected to run longer than the default test timeout, a context with timeout can be provided to interrupt the test process in time. This e.g. can be done as follows using `test.First` to ignore the cancelFunc: 

Ctx: test.First(context.WithTimeout(context.Background(), time.Second))

func MissingCalls 

func MissingCalls(
	setups ...mock.SetupFunc,
) func(Test, *mock.Mocks) mock.SetupFunc

MissingCalls creates an expectation for all missing calls.

func Must added in v0.0.30 

func Must[T any](arg T, err error) T

Must is a convenience method returning the value of the first argument and that panics on any error in the second argument using the provided error. The method allows to write concise test setup code.

func NewErrInvalidType added in v0.0.22 

func NewErrInvalidType(value any) error

NewErrInvalidType creates a new invalid type error.

func Panic 

func Panic(arg any) mock.SetupFunc

Panic creates a validation method call setup for a panic. It allows to match the panic object, which usually is an error and alternatively the error string representing the error, since runtime errors may be irreproducible.

func Ptr added in v0.0.43 

func Ptr[T any](v T) *T

Ptr is a convenience function to obtain the pointer to the given value. This is particularly useful to create pointers to literal values in test setup code, e.g., `test.Ptr(42)` or `test.Ptr("value")`.

func Recover added in v0.0.44 

func Recover(t Test, expect any)

Recover is a convenience method to be used in deferred calls to verify that a panic occurred with the expected panic response. The function creates a test failure if no panic occurred or the panic response does not match the expected value.

func Run 

func Run(expect Expect, test Func) func(*testing.T)

Run creates an isolated (by default) parallel test context running the given test function with given expectation. If the expectation is not met, a test failure is created in the parent test context.

func RunSeq 

func RunSeq(expect Expect, test Func) func(*testing.T)

RunSeq creates an isolated, test context for the given test function with given expectation. If the expectation is not met, a test failure is created in the parent test context.

func UnexpectedCall 

func UnexpectedCall[T any](
	creator func(*gomock.Controller) *T,
	method, caller string, args ...any,
) func(Test, *mock.Mocks) mock.SetupFunc

UnexpectedCall creates expectation for unexpected calls. We only support one unexpected call since the test execution stops in this case.

Types

type CleanupFunc added in v0.0.28 

type CleanupFunc func()

CleanupFunc defines the common test cleanup function signature.

type Cleanuper 

type Cleanuper interface {
	Cleanup(cleanup func())
}

Cleanuper defines an interface to add a custom method that is called after the test execution to cleanup the test environment.

type Context added in v0.0.22 

type Context struct {
	sync.Synchronizer
	// contains filtered or unexported fields
}

Context is a test isolation environment based on the `Test` abstraction. It can be used as a drop in replacement for `testing.T` in various libraries to check for expected test failures.

func New 

func New(t Test, parallel bool) *Context

New creates a new minimal isolated test context based on the given test context with. The parent test context is used to delegate methods calls to the parent context to propagate test results.

func (*Context) Cleanup added in v0.0.22 

func (t *Context) Cleanup(cleanup func())

Cleanup is a function called to setup test cleanup after execution. This method is allowing `gomock` to register its `finish` method that reports the missing mock calls.

func (*Context) Deadline added in v0.0.22 

func (t *Context) Deadline() (time.Time, bool)

Deadline delegates request to the parent context. It returns the deadline of the test and a flag indicating whether the deadline is set.

func (*Context) Done added in v0.0.29 

func (t *Context) Done()

Done decrements the wait group of the test by one.

func (*Context) Error added in v0.0.22 

func (t *Context) Error(args ...any)

Error handles failure messages where the test is supposed to continue. On an expected success, the failure is also delegated to the parent test context. Else it delegates the request to the test reporter if available.

func (*Context) Errorf added in v0.0.22 

func (t *Context) Errorf(format string, args ...any)

Errorf handles failure messages where the test is supposed to continue. On an expected success, the failure is also delegated to the parent test context. Else it delegates the request to the test reporter if available.

func (*Context) Expect added in v0.0.45 

func (t *Context) Expect(expect Expect) *Context

Expect sets up a new test outcome.

func (*Context) Fail added in v0.0.22 

func (t *Context) Fail()

Fail handles a failure message that immediate aborts of the test execution. On an expected success, the failure handling is also delegated to the parent test context. Else it delegates the request to the test reporter if available.

func (*Context) FailNow added in v0.0.22 

func (t *Context) FailNow()

FailNow handles fatal failure notifications without log output that aborts test execution immediately. On an expected success, it the failure handling is also delegated to the parent test context. Else it delegates the request to the test reporter if available.

func (*Context) Failed added in v0.0.22 

func (t *Context) Failed() bool

Failed reports whether the test has failed.

func (*Context) Fatal added in v0.0.22 

func (t *Context) Fatal(args ...any)

Fatal handles a fatal failure message that immediate aborts of the test execution. On an expected success, the failure handling is also delegated to the parent test context. Else it delegates the request to the test reporter if available.

func (*Context) Fatalf added in v0.0.22 

func (t *Context) Fatalf(format string, args ...any)

Fatalf handles a fatal failure message that immediate aborts of the test execution. On an expected success, the failure handling is also delegated to the parent test context. Else it delegates the request to the test reporter if available.

func (*Context) Helper added in v0.0.22 

func (t *Context) Helper()

Helper delegates request to the parent test context.

func (*Context) Log added in v0.0.22 

func (t *Context) Log(args ...any)

Log delegates request to the parent context. It provides a logging function for the test.

func (*Context) Logf added in v0.0.22 

func (t *Context) Logf(format string, args ...any)

Logf delegates request to the parent context. It provides a logging function for the test.

func (*Context) Name added in v0.0.22 

func (t *Context) Name() string

Name delegates the request to the parent test context.

func (*Context) Panic added in v0.0.22 

func (t *Context) Panic(arg any)

Panic handles failure notifications of panics that also abort the test execution immediately.

func (*Context) Parallel added in v0.0.22 

func (t *Context) Parallel()

Parallel robustly delegates request to the parent context. It can be called multiple times, since it is swallowing the panic that is raised when calling `t.Parallel()` multiple times.

func (*Context) Reporter added in v0.0.22 

func (t *Context) Reporter(reporter Reporter)

Reporter sets up a test failure reporter. This can be used to validate the reported failures in a test environment.

func (*Context) Run added in v0.0.22 

func (t *Context) Run(test Func) Test

Run executes the test function in a safe detached environment and check the failure state after the test function has finished. If the test result is not according to expectation, a failure is created in the parent test context.

func (*Context) Setenv added in v0.0.22 

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

Setenv delegates request to the parent context, if it is of type `*testing.T`. Else it is swallowing the request silently.

func (*Context) Skip added in v0.0.22 

func (t *Context) Skip(args ...any)

Skip delegates request to the parent context. It is a helper method to skip the test.

func (*Context) SkipNow added in v0.0.22 

func (t *Context) SkipNow()

SkipNow delegates request to the parent context. It is a helper method to skip the test immediately.

func (*Context) Skipf added in v0.0.22 

func (t *Context) Skipf(format string, args ...any)

Skipf delegates request to the parent context. It is a helper method to skip the test with a formatted message.

func (*Context) Skipped added in v0.0.22 

func (t *Context) Skipped() bool

Skipped delegates request to the parent context. It reports whether the test has been skipped.

func (*Context) StopEarly added in v0.0.22 

func (t *Context) StopEarly(time time.Duration) *Context

StopEarly stops the test by the given duration ahead of the individual or global test deadline, to ensure that a cleanup function has sufficient time to finish before a global deadline exceeds. The method is not able to extend the test deadline. A negative or zero duration is ignored.

Warning: calling this method multiple times will also reduce the deadline step by step.

func (*Context) TempDir added in v0.0.22 

func (t *Context) TempDir() string

TempDir delegates the request to the parent test context.

func (*Context) Timeout added in v0.0.22 

func (t *Context) Timeout(timeout time.Duration) *Context

Timeout sets up an individual timeout for the test. This does not affect the global test timeout or a pending parent timeout that may abort the test, if the given duration is exceeding the timeout. A negative or zero duration is ignored and will not change the timeout.

func (*Context) WaitGroup added in v0.0.22 

func (t *Context) WaitGroup(wg sync.WaitGroup)

WaitGroup adds wait group to unlock in case of a failure.

type DeepCopyParams added in v0.0.36 

type DeepCopyParams struct {
	// Value is a template value used to generate random non-zero test values
	// for testing the `DeepCopy*` functions.
	Value any
}

DeepCopyParams provides test parameters for testing `DeepCopy*` functions generated by `k8s.io/code-generator/cmd/deepcopy-gen`, that unfortunately are part of the type system and thus should be unit tested for coverage.

type Expect 

type Expect bool

Expect the expectation whether a test will succeed or fail. 

const (
	// Success used to express that a test is supposed to succeed.
	Success Expect = true
	// Failure used to express that a test is supposed to fail.
	Failure Expect = false

	// Parallel is the global flag to switch test runs to be executed in
	// parallel instead of sequentially.
	Parallel = true
)

Constants to express test expectations.

type Factory added in v0.0.41 

type Factory[P any] interface {
	// Adds a generic filter function that allows to filter test cases based on
	// the name and the parameter set.
	Filter(filter FilterFunc[P]) Factory[P]
	// Timeout sets up a timeout for the test cases executed by the test runner.
	// Setting a timeout is useful to prevent the test execution from waiting
	// too long in case of deadlocks. The timeout is not affecting the global
	// test timeout that may only abort a test earlier. If the given duration is
	// zero or negative, the timeout is ignored.
	Timeout(timeout time.Duration) Factory[P]
	// StopEarly stops the test by the given duration ahead of an individual or
	// global test deadline. This is useful to ensure that resources can be
	// cleaned up before the global deadline is exceeded.
	StopEarly(time time.Duration) Factory[P]
	// Run runs all test parameter sets in parallel. If the test parameter sets
	// are provided as a map, the test case name is used as the test name. If
	// the test parameter sets are provided as a slice, the test case name is
	// created by appending the index to the test name. If the test parameter
	// sets are provided as a single parameter set, the test case name is used
	// as the test name. The test case name is normalized before being used.
	Run(call ParamFunc[P]) Factory[P]
	// RunSeq runs the test parameter sets in a sequence. If the test parameter
	// sets are provided as a map, the test case name is used as the test name.
	// If the test parameter sets are provided as a slice, the test case name is
	// created by appending the index to the test name. If the test parameter
	// sets are provided as a single parameter set, the test case name is used
	// as the test name. The test case name is normalized before being used.
	RunSeq(call ParamFunc[P]) Factory[P]
	// Cleanup register a function to be called to cleanup after all tests have
	// finished to remove the shared resources.
	Cleanup(call CleanupFunc)
}

Factory is a generic test factory interface.

func Any added in v0.0.22 

func Any[P any](t *testing.T, params any) Factory[P]

Any creates a new parallel test runner with given parameter set(s). The set can be a single test parameter set, a slice of test parameter sets, or a map of named test parameter sets. The test runner is looking into the parameter set to determine a suitable test case name, e.g. by using a `name` parameter.

func Map 

func Map[P any](t *testing.T, params ...map[string]P) Factory[P]

Map creates a new parallel test runner with given test parameter sets provided as a test case name to parameter sets mapping.

func Param added in v0.0.30 

func Param[P any](t *testing.T, params ...P) Factory[P]

Param creates a new parallel test runner with given test parameter sets provided as variadic arguments. The test runner is looking into the parameter set to find a suitable test case name.

func Slice 

func Slice[P any](t *testing.T, params ...[]P) Factory[P]

Slice creates a new parallel test runner with given test parameter sets provided as a slice. The test runner is looking into the parameter set to find a suitable test case name.

type FilterFunc added in v0.0.41 

type FilterFunc[P any] func(name string, param P) bool

FilterFunc defines the common test filter function signature.

func And added in v0.0.41 

func And[P any](filters ...FilterFunc[P]) FilterFunc[P]

And combines the given filter functions with a logical `and`.

func Arch added in v0.0.41 

func Arch[P any](arch string) FilterFunc[P]

Arch creates a filter function that matches the given architecture.

func Not added in v0.0.41 

func Not[P any](filter FilterFunc[P]) FilterFunc[P]

Not negates the given filter function.

func OS added in v0.0.41 

func OS[P any](os string) FilterFunc[P]

OS creates a filter function that matches the given operating system.

func Or added in v0.0.41 

func Or[P any](filters ...FilterFunc[P]) FilterFunc[P]

Or combines the given filter functions with a logical `or`.

func Pattern added in v0.0.41 

func Pattern[P any](pattern string) FilterFunc[P]

Pattern creates a filter function that matches the test case name against the given pattern. The pattern is adjusted to replace spaces with dashes before being compiled into a regular expression to account for the test name normalization.

type Func added in v0.0.28 

type Func func(Test)

Func defines the common test function signature.

func InRun 

func InRun(expect Expect, test Func) Func

InRun creates an isolated, (by default) sequential test context for the given test function with given expectation. If the expectation is not met, a test failure is created in the parent test context.

type MainParams added in v0.0.8 

type MainParams struct {
	// Ctx is the context to control the test process, e.g. for deadlines and
	// cancellations. If not set, a background context is used with unlimited
	// duration.
	Ctx context.Context //nolint:containedctx // only in test parameters.

	// Args are the command line arguments to provide to the test process. The
	// first argument is usually the program name, typically `os.Args[0]`. If
	// not provided, the `main`-method is called with no arguments at all.
	Args []string

	// Env are the additional environment variables that are provided to the
	// spawned test process. The existing environment variables are inherited
	// and an additional `GO_TESTING_TEST` variable is set to select the test
	// case.
	Env []string

	// ExitCode is the expected exit code when running the test process. If
	// the exit code is not `0`, the error must be of type `*exec.ExitError`.
	ExitCode int

	// Error is the expected error when running the test process. This is only
	// used in edge cases when the test error is not of type `*exec.ExitError`.
	Error error
}

MainParams provides the test parameters for testing a `main`-method.

type Panicer added in v0.0.45 

type Panicer interface {
	// Embeds the basic test reporter interface.
	Reporter
	// Panic reports a panic.
	Panic(arg any)
}

Panicer is a test reporter that supports in addition panic reporting.

type ParamFunc added in v0.0.28 

type ParamFunc[P any] func(t Test, param P)

ParamFunc defines the common parameterized test function signature.

type Recorder 

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

Recorder a test failure validator recorder.

func (*Recorder) Error added in v0.0.22 

func (r *Recorder) Error(args ...any) *gomock.Call

Error indicate an expected method call to `Error`.

func (*Recorder) Errorf 

func (r *Recorder) Errorf(format string, args ...any) *gomock.Call

Errorf indicate an expected method call to `Errorf`.

func (*Recorder) Fail added in v0.0.22 

func (r *Recorder) Fail() *gomock.Call

Fail indicate an expected method call to `Fail`.

func (*Recorder) FailNow 

func (r *Recorder) FailNow() *gomock.Call

FailNow indicate an expected method call to `FailNow`.

func (*Recorder) Fatal added in v0.0.22 

func (r *Recorder) Fatal(args ...any) *gomock.Call

Fatal indicate an expected method call to `Fatal`.

func (*Recorder) Fatalf 

func (r *Recorder) Fatalf(format string, args ...any) *gomock.Call

Fatalf indicate an expected method call to `Fatalf`.

func (*Recorder) Log added in v0.0.45 

func (r *Recorder) Log(args ...any) *gomock.Call

Log indicate an expected method call to `Log`.

func (*Recorder) Logf added in v0.0.45 

func (r *Recorder) Logf(format string, args ...any) *gomock.Call

Logf indicate an expected method call to `Logf`.

func (*Recorder) Panic 

func (r *Recorder) Panic(arg any) *gomock.Call

Panic indicate an expected method call from panic.

type Reporter 

type Reporter interface {
	// Log provides a logging function for the test.
	Log(args ...any)
	// Logf provides a logging function for the test.
	Logf(format string, args ...any)
	// Error reports a failure messages when a test is supposed to continue.
	Error(args ...any)
	// Errorf reports a failure messages when a test is supposed to continue.
	Errorf(format string, args ...any)
	// Fatal reports a fatal failure message that immediate aborts of the test
	// execution.
	Fatal(args ...any)
	// Fatalf reports a fatal failure message that immediate aborts of the test
	// execution.
	Fatalf(format string, args ...any)
	// Fail reports a failure message that immediate aborts of the test
	// execution.
	Fail()
	// FailNow reports fatal failure notifications without log output that
	// aborts test execution immediately.
	FailNow()
}

Reporter is a minimal interface for abstracting test report methods that are needed to setup an isolated test environment for GoMock and Testify.

type SetupFunc added in v0.0.28 

type SetupFunc func(Test)

SetupFunc defines the common test setup function signature.

type Test 

type Test interface {
	// Embeds the basic test reporter interface.
	Reporter
	// Name provides the test name.
	Name() string
	// Helper declares a test helper function.
	Helper()
	// Parallel declares that the test is to be run in parallel with (and only
	// with) other parallel tests.
	Parallel()
	// TempDir creates a new temporary directory for the test.
	TempDir() string
	// Setenv sets an environment variable for the test.
	Setenv(key, value string)
	// Deadline returns the deadline of the test and a flag indicating whether
	// the deadline is set.
	Deadline() (deadline time.Time, ok bool)
	// Skip is a helper method to skip the test.
	Skip(args ...any)
	// Skipf is a helper method to skip the test with a formatted message.
	Skipf(format string, args ...any)
	// SkipNow is a helper method to skip the test immediately.
	SkipNow()
	// Skipped reports whether the test has been skipped.
	Skipped() bool
	// Failed reports whether the test has failed.
	Failed() bool
	// Cleanup is a function called to setup test cleanup after execution.
	Cleanup(cleanup func())
}

Test is a minimal interface for abstracting test methods that are needed to setup an isolated test environment for GoMock and Testify.

type Validator 

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

Validator a test failure validator based on the test reporter interface.

func NewValidator 

func NewValidator(ctrl *gomock.Controller) *Validator

NewValidator creates a new test validator for validating error messages and panics created during test execution.

func (*Validator) EXPECT 

func (v *Validator) EXPECT() *Recorder

EXPECT implements the usual `gomock.EXPECT` call to request the recorder.

func (*Validator) Error added in v0.0.22 

func (v *Validator) Error(args ...any)

Error receive expected method call to `Error`.

func (*Validator) Errorf 

func (v *Validator) Errorf(format string, args ...any)

Errorf receive expected method call to `Errorf`.

func (*Validator) Fail added in v0.0.22 

func (v *Validator) Fail()

Fail receive expected method call to `Fail`.

func (*Validator) FailNow 

func (v *Validator) FailNow()

FailNow receive expected method call to `FailNow`.

func (*Validator) Fatal added in v0.0.22 

func (v *Validator) Fatal(args ...any)

Fatal receive expected method call to `Fatal`.

func (*Validator) Fatalf 

func (v *Validator) Fatalf(format string, args ...any)

Fatalf receive expected method call to `Fatalf`.

func (*Validator) Log added in v0.0.45 

func (v *Validator) Log(args ...any)

Log receive expected method call to `Log`.

func (*Validator) Logf added in v0.0.45 

func (v *Validator) Logf(format string, args ...any)

Logf receive expected method call to `Logf`.

func (*Validator) Panic 

func (v *Validator) Panic(arg any)

Panic receive expected method call indicating a panic.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.