go-testing-interface

go-testing-interface is a Go library that exports an interface that*testing.T implements as well as a runtime version you can use in itsplace.

The purpose of this library is so that you can export test helpers as apublic API without depending on the "testing" package, since you can'tcreate a*testing.T struct manually. This lets you, for example, use thepublic testing APIs to generate mock data at runtime, rather than just attest time.

Usage & Example

For usage and examples see theGodoc.

Given a test helper written usinggo-testing-interface like this:

import "github.com/mitchellh/go-testing-interface"func TestHelper(t testing.T) {    t.Fatal("I failed")}

You can call the test helper in a real test easily:

import "testing"func TestThing(t *testing.T) {    TestHelper(t)}

You can also call the test helper at runtime if needed:

import "github.com/mitchellh/go-testing-interface"func main() {    TestHelper(&testing.RuntimeT{})}

Versioning

The tagged version matches the version of Go that the interface iscompatible with. For example, the version "1.14.0" is for Go 1.14 andintroduced theCleanup function. The patch version (the ".0" in theprior example) is used to fix any bugs found in this library and has nocorrelation to the supported Go version.

Why?!

*Why would I call a test helper that takes atesting.T at runtime?

You probably shouldn't. The only use case I've seen (and I've had) for thisis to implement a "dev mode" for a service where the test helpers are usedto populate mock data, create a mock DB, perhaps run service dependenciesin-memory, etc.

Outside of a "dev mode", I've never seen a use case for this and I thinkthere shouldn't be one since the point of thetesting.T interface is thatyou can fail immediately.

Constants¶

Variables¶

Functions¶

Types¶

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

func (t *RuntimeT) Cleanup(func())

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

func (t *RuntimeT) Errorf(formatstring, args ...interface{})

func (t *RuntimeT) Fail()

func (t *RuntimeT) FailNow()

func (t *RuntimeT) Failed()bool

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

func (t *RuntimeT) Fatalf(formatstring, args ...interface{})

func (t *RuntimeT) Helper()

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

func (t *RuntimeT) Logf(formatstring, args ...interface{})

func (t *RuntimeT) Name()string

func (t *RuntimeT) Parallel()

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

func (t *RuntimeT) SkipNow()

func (t *RuntimeT) Skipf(formatstring, args ...interface{})

func (t *RuntimeT) Skipped()bool

type T interface {Cleanup(func())Error(args ...interface{})Errorf(formatstring, args ...interface{})Fail()FailNow()Failed()boolFatal(args ...interface{})Fatalf(formatstring, args ...interface{})Helper()Log(args ...interface{})Logf(formatstring, args ...interface{})Name()stringParallel()Skip(args ...interface{})SkipNow()Skipf(formatstring, args ...interface{})Skipped()bool}