require

Documentation

Overview

Alternative testing tools which stop test execution if test failed.

Example Usage

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

import (
  "testing"
  "github.com/stretchr/testify/require"
)

func TestSomething(t *testing.T) {

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

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

}

Assertions

The `require` package have same global functions as in the `assert` package, but instead of returning a boolean result they call `t.FailNow()`.

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.

Here is an overview of the assert functions:

   require.Equal(t, expected, actual [, message [, format-args])

   require.NotEqual(t, notExpected, actual [, message [, format-args]])

   require.True(t, actualBool [, message [, format-args]])

   require.False(t, actualBool [, message [, format-args]])

   require.Nil(t, actualObject [, message [, format-args]])

   require.NotNil(t, actualObject [, message [, format-args]])

   require.Empty(t, actualObject [, message [, format-args]])

   require.NotEmpty(t, actualObject [, message [, format-args]])

   require.Error(t, errorObject [, message [, format-args]])

   require.NoError(t, errorObject [, message [, format-args]])

   require.EqualError(t, theError, errString [, message [, format-args]])

   require.Implements(t, (*MyInterface)(nil), new(MyObject) [,message [, format-args]])

   require.IsType(t, expectedObject, actualObject [, message [, format-args]])

   require.Contains(t, string, substring [, message [, format-args]])

   require.NotContains(t, string, substring [, message [, format-args]])

   require.Panics(t, func(){

	    // call code that should panic

   } [, message [, format-args]])

   require.NotPanics(t, func(){

	    // call code that should not panic

   } [, message [, format-args]])

   require.WithinDuration(t, timeA, timeB, deltaTime, [, message [, format-args]])

   require.InDelta(t, numA, numB, delta, [, message [, format-args]])

   require.InEpsilon(t, numA, numB, epsilon, [, message [, format-args]])

Index

• func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{})
• func Contains(t TestingT, s, contains string, msgAndArgs ...interface{})
• func Empty(t TestingT, object interface{}, msgAndArgs ...interface{})
• func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})
• func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{})
• func Error(t TestingT, err error, msgAndArgs ...interface{})
• func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})
• func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{})
• func False(t TestingT, value bool, msgAndArgs ...interface{})
• func Implements(t TestingT, interfaceObject interface{}, object interface{}, ...)
• func InDelta(t TestingT, expected, actual interface{}, delta float64, ...)
• func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, ...)
• func IsType(t TestingT, expectedType interface{}, object interface{}, ...)
• func Nil(t TestingT, object interface{}, msgAndArgs ...interface{})
• func NoError(t TestingT, err error, msgAndArgs ...interface{})
• func NotContains(t TestingT, s, contains string, msgAndArgs ...interface{})
• func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{})
• func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{})
• func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{})
• func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{})
• func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{})
• func True(t TestingT, value bool, msgAndArgs ...interface{})
• func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, ...)
• type TestingT

Functions

func Condition

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

Condition uses a Comparison to assert a complex condition.

func Contains

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

Contains asserts that the specified string contains the specified substring.

require.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")

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

func Empty

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

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

require.Empty(t, obj)

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

func Equal

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

Equal asserts that two objects are equal.

require.Equal(t, 123, 123, "123 and 123 should be equal")

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

func EqualError

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

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

actualObj, err := SomeFunction()
require.Error(t, err, "An error was expected")
require.Equal(t, err, expectedError)
}

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

func Error

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

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

actualObj, err := SomeFunction()
require.Error(t, err, "An error was expected")
require.Equal(t, err, expectedError)
}

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

func Exactly

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

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

require.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal")

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

func FailNow

func FailNow(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 true.

require.False(t, myBool, "myBool should be false")

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

func Implements

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

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

require.Implements(t, (*MyInterface)(nil), new(MyObject), "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.

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

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

func InEpsilon

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

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

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

func IsType

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

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

func Nil

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

Nil asserts that the specified object is nil.

require.Nil(t, err, "err should be nothing")

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

func NoError

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

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

actualObj, err := SomeFunction()
require.NoError(t, err)
require.Equal(t, actualObj, expectedObj)

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

func NotContains

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

NotContains asserts that the specified string does NOT contain the specified substring.

require.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")

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

func NotEmpty

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

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.

require.NotEmpty(t, obj) require.Equal(t, "one", obj[0])

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

func NotEqual

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

NotEqual asserts that the specified values are NOT equal.

require.NotEqual(t, obj1, obj2, "two objects shouldn't be equal")

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

func NotNil

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

NotNil asserts that the specified object is not nil.

require.NotNil(t, err, "err should be something")

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

func NotPanics

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

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

require.NotPanics(t, func(){
  RemainCalm()
}, "Calling RemainCalm() should NOT panic")

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

func Panics

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

Panics asserts that the code inside the specified PanicTestFunc panics.

require.Panics(t, func(){
  GoCrazy()
}, "Calling GoCrazy() should panic")

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

func True

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

True asserts that the specified value is true.

require.True(t, myBool, "myBool should be true")

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

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.

require.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s")

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

Types

type TestingT

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