assert

package
v0.0.0-...-581c8d3 Latest Latest
Warning

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

Go to latest
Published: Mar 22, 2020 License: Apache-2.0, MIT Imports: 22 Imported by: 0

README

Go assertion library (fork of stretchr/testify/require)

This is a fork of stretchr's assertion library that does two things:

  1. It makes spotting differences in equality much easier. It uses repr and diffmatchpatch to display structural differences in colour.
  2. Aborts tests on first assertion failure (the same behaviour as stretchr/testify/require).
  3. CoreStore: The function CallerInfo reports correctly the line number in sub tests.

Example

Given the following test:

type Person struct {
  Name string
  Age  int
}

// Use github.com/alecthomas/assert
func TestDiff(t *testing.T) {
  expected := []*Person{{"Alec", 20}, {"Bob", 21}, {"Sally", 22}}
  actual := []*Person{{"Alex", 20}, {"Bob", 22}, {"Sally", 22}}
  assert.Equal(t, expected, actual)
}

// Use github.com/stretchr/testify/require
func TestTestifyDiff(t *testing.T) {
  expected := []*Person{{"Alec", 20}, {"Bob", 21}, {"Sally", 22}}
  actual := []*Person{{"Alex", 20}, {"Bob", 22}, {"Sally", 22}}
  require.Equal(t, expected, actual)
}

The following output illustrates the problems this solves. Firstly, it shows nested structures correctly, and secondly it highlights the differences between actual and expected text.

Documentation

Overview

Package assert provides a set of comprehensive testing tools for use with the normal Go testing system.

Example Usage

The following is a complete example using assert in a standard test function:

import (
  "testing"
  "github.com/weiwolves/pkg/util/assert"
)

func TestSomething(t *testing.T) {

  var a string = "Hello"
  var b string = "Hello"

  assert.Equal(t, a, b, "The two words should be the same.")

}

if you assert many times, use the format below:

import (
  "testing"
  "github.com/weiwolves/pkg/util/assert"
)

func TestSomething(t *testing.T) {
  assert := assert.New(t)

  var a string = "Hello"
  var b string = "Hello"

  assert.Equal(a, b, "The two words should be the same.")
}

Assertions

Assertions allow you to easily write test code, and are global funcs in the `assert` package. All assertion functions take, as the first argument, the `*testing.T` object provided by the testing framework. This allows the assertion funcs to write the failings and other details to the correct place.

Every assertion function also takes an optional string message as the final argument, allowing custom error messages to be appended to the message the assertion method outputs.

To enable HTTP assertions you must compile with build tag `csall` or `http`.

Index

Constants

This section is empty.

Variables

View Source
var AnError = errors.New("assert.AnError general error for testing")

AnError is an error instance useful for testing. If the code does not care about error specifics, and only needs to return the error for example, this error should be used to make the test code more readable.

Functions

func CallerInfo

func CallerInfo() []string

CallerInfo returns an array of strings containing the file and line number of each stack frame leading from the current test to the assert call that failed.

func Condition

func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{})

Condition uses a Comparison to assert a complex condition.

func Contains

func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{})

Contains asserts that the specified string, list(array, slice...) or map contains the specified substring or element.

assert.Contains(t, "Hello World", "World")
assert.Contains(t, ["Hello", "World"], "World")
assert.Contains(t, {"Hello": "World"}, "Hello")

func DiffValues

func DiffValues(a, b interface{}) string

func DiffValuesDefault

func DiffValuesDefault(a, b interface{}) string

func DirExists

func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool

DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists.

func ElementsMatch

func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{})

ElementsMatch asserts that the specified listA(array, slice...) is equal to specified listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, the number of appearances of each of them in both lists should match.

assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2])

func Empty

func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool

Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either a slice or a channel with len == 0.

assert.Empty(t, obj)

func Equal

func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})

Equal asserts that two objects are equal.

assert.Equal(t, 123, 123)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses). Function equality cannot be determined and will always fail.

func EqualError

func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool

EqualError asserts that a function returned an error (i.e. not `nil`) and that it is equal to the provided error.

actualObj, err := SomeFunction()
assert.EqualError(t, err,  expectedErrorString)

func EqualValues

func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})

EqualValues asserts that two objects are equal or convertable to the same types and equal.

assert.EqualValues(t, uint32(123), int32(123))

func Error

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

Error asserts that a function returned an error (i.e. not `nil`).

  actualObj, err := SomeFunction()
  if assert.Error(t, err) {
	   assert.Equal(t, expectedError, err)
  }

func ErrorIsKind

func ErrorIsKind(t TestingT, expected errors.Kind, err error, msgAndArgs ...interface{})

ErrorIsKind asserts that an error matches the expected Kind.

func Eventually

func Eventually(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Eventually asserts that given condition will be met in waitFor time, periodically checking target function each tick.

assert.Eventually(t, func() bool { return true; }, time.Second, 10*time.Millisecond)

func Exactly

func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})

Exactly asserts that two objects are equal in value and type.

assert.Exactly(t, int32(123), int64(123))

func ExactlyLength

func ExactlyLength(t TestingT, maxLength int, ptrExpected, ptrActual interface{}, msgAndArgs ...interface{})

ExactlyLength asserts that two objects with maximum length of their string fields are equal in value and type.

assert.ExactlyLength(t,2, "aa", "aaa")

Shorts aaa to aa and checks if aa is equal to aa. This function is needed when writing random strings to the database table with short column length.

func Fail

func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{})

Fail reports a failure through

func False

func False(t TestingT, value bool, msgAndArgs ...interface{})

False asserts that the specified value is false.

assert.False(t, myBool)

func FileExists

func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool

FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file.

func Implements

func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{})

Implements asserts that an object is implemented by the specified interface.

assert.Implements(t, (*MyInterface)(nil), new(MyObject))

func InDelta

func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{})

InDelta asserts that the two numerals are within delta of each other.

assert.InDelta(t, math.Pi, 22/7.0, 0.01)

func InDeltaMapValues

func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{})

InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys.

func InEpsilon

func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool

InEpsilon asserts that expected and actual have a relative error less than epsilon

func InEpsilonSlice

func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool

InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices.

func IsType

func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{})

IsType asserts that the specified objects are of the same type.

func JSONEq

func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{})

JSONEq asserts that two JSON strings are equivalent.

assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)

func Len

func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{})

Len asserts that the specified object has specific length. Len also fails if the object has a type that len() not accept.

assert.Len(t, mySlice, 3)

func LenBetween

func LenBetween(t TestingT, object interface{}, min, maxLength int, msgAndArgs ...interface{})

LenBetween asserts that the specified object has a length between a lower and an upper bound. LenBetween also fails if the object has a type that len() not accept.

assert.MaxLen(t, mySlice, 3, "The size of slice is not 3")
assert.MaxLen(t, myInt, 5, "The value of myInt is not smaller or equal to 5")

Returns whether the assertion was successful (true) or not (false).

func Never

func Never(t TestingT, condition func() bool, waitFor time.Duration, tick time.Duration, msgAndArgs ...interface{})

Never asserts that the given condition doesn't satisfy in waitFor time, periodically checking the target function each tick.

assert.Never(t, func() bool { return false; }, time.Second, 10*time.Millisecond)

func Nil

func Nil(t TestingT, object interface{}, msgAndArgs ...interface{})

Nil asserts that the specified object is nil.

assert.Nil(t, err)

func NoDirExists

func NoDirExists(t TestingT, path string, msgAndArgs ...interface{}) bool

NoDirExists checks whether a directory does not exist in the given path. It fails if the path points to an existing _directory_ only.

func NoError

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

NoError asserts that a function returned no error (i.e. `nil`).

  actualObj, err := SomeFunction()
  if assert.NoError(t, err) {
	   assert.Equal(t, expectedObj, actualObj)
  }

func NoFileExists

func NoFileExists(t TestingT, path string, msgAndArgs ...interface{})

NoFileExists checks whether a file does not exist in a given path. It fails if the path points to an existing _file_ only.

func NotContains

func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{})

NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the specified substring or element.

assert.NotContains(t, "Hello World", "Earth")
assert.NotContains(t, ["Hello", "World"], "Earth")
assert.NotContains(t, {"Hello": "World"}, "Earth")

func NotEmpty

func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool

NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either a slice or a channel with len == 0.

if assert.NotEmpty(t, obj) {
  assert.Equal(t, "two", obj[1])
}

func NotEqual

func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})

NotEqual asserts that the specified values are NOT equal.

assert.NotEqual(t, obj1, obj2)

Pointer variable equality is determined based on the equality of the referenced values (as opposed to the memory addresses).

func NotNil

func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{})

NotNil asserts that the specified object is not nil.

assert.NotNil(t, err)

func NotPanics

func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{})

NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic.

assert.NotPanics(t, func(){ RemainCalm() })

func NotRegexp

func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool

NotRegexp asserts that a specified regexp does not match a string.

assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting")
assert.NotRegexp(t, "^start", "it's not starting")

func NotSame

func NotSame(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})

NotSame asserts that two pointers do not reference the same object.

assert.NotSame(t, ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func NotSubset

func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{})

NotSubset asserts that the specified list(array, slice...) contains not all elements given in the specified subset(array, slice...).

assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]")

func NotZero

func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool

NotZero asserts that i is not the zero value for its type.

func ObjectsAreEqual

func ObjectsAreEqual(expected, actual interface{}) bool

ObjectsAreEqual determines if two objects are considered equal.

This function does no assertion of any kind.

func ObjectsAreEqualValues

func ObjectsAreEqualValues(expected, actual interface{}) bool

ObjectsAreEqualValues gets whether two objects are equal, or if their values are equal.

func Panics

func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{})

Panics asserts that the code inside the specified PanicTestFunc panics.

assert.Panics(t, func(){ GoCrazy() })

func PanicsWithError

func PanicsWithError(t TestingT, errString string, f PanicTestFunc, msgAndArgs ...interface{})

PanicsWithError asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value is an error that satisfies the EqualError comparison.

assert.PanicsWithError(t, "crazy error", func(){ GoCrazy() })

func PanicsWithValue

func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{})

PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that the recovered panic value equals the expected panic value.

assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() })

func Regexp

func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool

Regexp asserts that a specified regexp matches a string.

assert.Regexp(t, regexp.MustCompile("start"), "it's starting")
assert.Regexp(t, "start...$", "it's not starting")

func Same

func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})

Same asserts that two pointers reference the same object.

assert.Same(t, ptr1, ptr2)

Both arguments must be pointer variables. Pointer variable sameness is determined based on the equality of both type and value.

func Subset

func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{})

Subset asserts that the specified list(array, slice...) contains all elements given in the specified subset(array, slice...).

assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]")

func True

func True(t TestingT, value bool, msgAndArgs ...interface{})

True asserts that the specified value is true.

assert.True(t, myBool)

func WithinDuration

func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{})

WithinDuration asserts that the two times are within duration delta of each other.

assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second)

func Zero

func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool

Zero asserts that i is the zero value for its type.

Types

type Comparison

type Comparison func() (success bool)

Comparison a custom function that returns true on success and false on failure

type PanicTestFunc

type PanicTestFunc func()

PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics methods, and represents a simple func that takes no arguments, and returns nothing.

type TestingT

type TestingT interface {
	Errorf(format string, args ...interface{})
	FailNow()
}

TestingT is an interface wrapper around *testing.T

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL