gotest.tools: gotest.tools/assert Index | Examples | Files | Directories

package assert

import "gotest.tools/assert"

Package assert provides assertions for comparing expected values to actual values. When an assertion fails a helpful error message is printed.

Assert and Check

Assert() and Check() both accept a Comparison, and fail the test when the comparison fails. The one difference is that Assert() will end the test execution immediately (using t.FailNow()) whereas Check() will fail the test (using t.Fail()), return the value of the comparison, then proceed with the rest of the test case.

Example usage

The example below shows assert used with some common types.

import (
    "testing"

    "gotest.tools/assert"
    is "gotest.tools/assert/cmp"
)

func TestEverything(t *testing.T) {
    // booleans
    assert.Assert(t, ok)
    assert.Assert(t, !missing)

    // primitives
    assert.Equal(t, count, 1)
    assert.Equal(t, msg, "the message")
    assert.Assert(t, total != 10) // NotEqual

    // errors
    assert.NilError(t, closer.Close())
    assert.Error(t, err, "the exact error message")
    assert.ErrorContains(t, err, "includes this")
    assert.ErrorType(t, err, os.IsNotExist)

    // complex types
    assert.DeepEqual(t, result, myStruct{Name: "title"})
    assert.Assert(t, is.Len(items, 3))
    assert.Assert(t, len(sequence) != 0) // NotEmpty
    assert.Assert(t, is.Contains(mapping, "key"))

    // pointers and interface
    assert.Assert(t, is.Nil(ref))
    assert.Assert(t, ref != nil) // NotNil
}

Comparisons

Package http://gotest.tools/assert/cmp provides many common comparisons. Additional comparisons can be written to compare values in other ways. See the example Assert (CustomComparison).

Automated migration from testify

gty-migrate-from-testify is a command which translates Go source code from testify assertions to the assertions provided by this package.

See http://gotest.tools/assert/cmd/gty-migrate-from-testify.

Index

Examples

Package Files

assert.go result.go

func Assert Uses

func Assert(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{})

Assert performs a comparison. If the comparison fails, the test is marked as failed, a failure message is logged, and execution is stopped immediately.

The comparison argument may be one of three types:

bool

True is success. False is a failure. The failure message will contain the literal source code of the expression.

cmp.Comparison

Uses cmp.Result.Success() to check for success of failure. The comparison is responsible for producing a helpful failure message. http://gotest.tools/assert/cmp provides many common comparisons.

error

A nil value is considered success. A non-nil error is a failure, err.Error() is used as the failure message.

Code:

package main

import (
    "fmt"
    "regexp"
    "testing"

    "gotest.tools/v3/assert"
    "gotest.tools/v3/assert/cmp"
)

var t = &testing.T{}

func main() {
    regexPattern := func(value string, pattern string) cmp.Comparison {
        return func() cmp.Result {
            re := regexp.MustCompile(pattern)
            if re.MatchString(value) {
                return cmp.ResultSuccess
            }
            return cmp.ResultFailure(
                fmt.Sprintf("%q did not match pattern %q", value, pattern))
        }
    }
    assert.Assert(t, regexPattern("12345.34", `\d+.\d\d`))
}

func Check Uses

func Check(t TestingT, comparison BoolOrComparison, msgAndArgs ...interface{}) bool

Check performs a comparison. If the comparison fails the test is marked as failed, a failure message is logged, and Check returns false. Otherwise returns true.

See Assert for details about the comparison arg and failure messages.

func DeepEqual Uses

func DeepEqual(t TestingT, x, y interface{}, opts ...gocmp.Option)

DeepEqual uses google/go-cmp (https://godoc.org/github.com/google/go-cmp/cmp) to assert two values are equal and fails the test if they are not equal.

Package http://gotest.tools/assert/opt provides some additional commonly used Options.

This is equivalent to Assert(t, cmp.DeepEqual(x, y)).

func Equal Uses

func Equal(t TestingT, x, y interface{}, msgAndArgs ...interface{})

Equal uses the == operator to assert two values are equal and fails the test if they are not equal.

If the comparison fails Equal will use the variable names for x and y as part of the failure message to identify the actual and expected values.

If either x or y are a multi-line string the failure message will include a unified diff of the two values. If the values only differ by whitespace the unified diff will be augmented by replacing whitespace characters with visible characters to identify the whitespace difference.

This is equivalent to Assert(t, cmp.Equal(x, y)).

func Error Uses

func Error(t TestingT, err error, message string, msgAndArgs ...interface{})

Error fails the test if err is nil, or the error message is not the expected message. Equivalent to Assert(t, cmp.Error(err, message)).

func ErrorContains Uses

func ErrorContains(t TestingT, err error, substring string, msgAndArgs ...interface{})

ErrorContains fails the test if err is nil, or the error message does not contain the expected substring. Equivalent to Assert(t, cmp.ErrorContains(err, substring)).

func ErrorType Uses

func ErrorType(t TestingT, err error, expected interface{}, msgAndArgs ...interface{})

ErrorType fails the test if err is nil, or err is not the expected type. Equivalent to Assert(t, cmp.ErrorType(err, expected)).

Expected can be one of:

func(error) bool

Function should return true if the error is the expected type.

type struct{}, type &struct{}

A struct or a pointer to a struct. Fails if the error is not of the same type as expected.

type &interface{}

A pointer to an interface type. Fails if err does not implement the interface.

reflect.Type

Fails if err does not implement the reflect.Type

func NilError Uses

func NilError(t TestingT, err error, msgAndArgs ...interface{})

NilError fails the test immediately if err is not nil. This is equivalent to Assert(t, err)

type BoolOrComparison Uses

type BoolOrComparison interface{}

BoolOrComparison can be a bool, or cmp.Comparison. See Assert() for usage.

type TestingT Uses

type TestingT interface {
    FailNow()
    Fail()
    Log(args ...interface{})
}

TestingT is the subset of testing.T used by the assert package.

Directories

PathSynopsis
cmd/gty-migrate-from-testifyCommand gty-migrate-from-testify migrates packages from testify/assert and testify/require to gotest.tools/assert.
cmpPackage cmp provides Comparisons for Assert and Check
optPackage opt provides common go-cmp.Options for use with assert.DeepEqual.

Package assert imports 7 packages (graph) and is imported by 42 packages. Updated 2019-09-16. Refresh now. Tools for package owners.