assert

package
Version: v0.0.0-...-d580ecf Latest Latest
Warning

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

Go to latest
Published: Jul 14, 2015 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Overview

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/stretchr/testify/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 below:

import (
  "testing"
  "github.com/stretchr/testify/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.

Here is an overview of the assert functions:

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

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

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

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

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

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

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

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

   assert.Len(t, actualObject, expectedLength, [, message [, format-args]])

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

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

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

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

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

   assert.Contains(t, stringOrSlice, substringOrElement [, message [, format-args]])

   assert.NotContains(t, stringOrSlice, substringOrElement [, message [, format-args]])

   assert.Panics(t, func(){

	    // call code that should panic

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

   assert.NotPanics(t, func(){

	    // call code that should not panic

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

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

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

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

assert package contains Assertions object. it has assertion methods.

Here is an overview of the assert functions:

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

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

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

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

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

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

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

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

   assert.Len(actualObject, expectedLength, [, message [, format-args]])

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

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

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

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

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

   assert.Contains(stringOrSlice, substringOrElement [, message [, format-args]])

   assert.NotContains(stringOrSlice, substringOrElement [, message [, format-args]])

   assert.Panics(func(){

	    // call code that should panic

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

   assert.NotPanics(func(){

	    // call code that should not panic

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

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

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

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

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 a string containing the file and line number of the assert call that failed.

func Condition

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

Condition uses a Comparison to assert a complex condition.

func Contains

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

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

assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'")
assert.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{}) 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)

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

func Equal

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

Equal asserts that two objects are equal.

assert.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{}) 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()
  if assert.Error(t, err, "An error was expected") {
	   assert.Equal(t, err, expectedError)
  }

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

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, "An error was expected") {
	   assert.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{}) bool

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

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

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

func Fail

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

Fail reports a failure through

func False

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

False asserts that the specified value is true.

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

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

func HTTPBodyContains

func HTTPBodyContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool

HTTPBodyContains asserts that a specified handler returns a body that contains a string.

assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")

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

func HTTPBodyNotContains

func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string.

assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")

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

func HTTPError

func HTTPError(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool

HTTPError asserts that a specified handler returns an error status code.

assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func HTTPRedirect

func HTTPRedirect(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool

HTTPRedirect asserts that a specified handler returns a redirect status code.

assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func HTTPSuccess

func HTTPSuccess(t TestingT, handler http.HandlerFunc, mode, url string, values url.Values) bool

HTTPSuccess asserts that a specified handler returns a success status code.

assert.HTTPSuccess(t, myHandler, "POST", http://www.google.com", nil)

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

func HttpBody

func HttpBody(handler http.HandlerFunc, mode, url string, values url.Values) string

HttpBody is a helper that returns HTTP body of the response. It returns empty string if building a new request fails.

func Implements

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

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

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

func InDelta

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

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

assert.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{}) bool

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{}) bool

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

func Len

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

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, "The size of slice is not 3")

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

func Nil

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

Nil asserts that the specified object is nil.

assert.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{}) bool

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

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

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

func NotContains

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

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

assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'")
assert.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{}) 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])

}

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

func NotEqual

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

NotEqual asserts that the specified values are NOT equal.

assert.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{}) bool

NotNil asserts that the specified object is not nil.

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

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

func NotPanics

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

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

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

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

func NotRegexp

func NotRegexp(t TestingT, rx interface{}, str 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")

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

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 Panics

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

Panics asserts that the code inside the specified PanicTestFunc panics.

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

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

func Regexp

func Regexp(t TestingT, rx interface{}, str 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")

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

func True

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

True asserts that the specified value is true.

assert.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{}) bool

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

assert.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 Assertions

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

func New

func New(t TestingT) *Assertions

func (*Assertions) Condition

func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool

Uses a Comparison to assert a complex condition.

func (*Assertions) Contains

func (a *Assertions) Contains(s, contains interface{}, msgAndArgs ...interface{}) bool

Contains asserts that the specified string contains the specified substring.

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

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

func (*Assertions) Empty

func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool

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

assert.Empty(obj)

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

func (*Assertions) Equal

func (a *Assertions) Equal(expected, actual interface{}, msgAndArgs ...interface{}) bool

Equal asserts that two objects are equal.

assert.Equal(123, 123, "123 and 123 should be equal")

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

func (*Assertions) EqualError

func (a *Assertions) EqualError(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()
  if assert.Error(err, "An error was expected") {
	   assert.Equal(err, expectedError)
  }

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

func (*Assertions) Error

func (a *Assertions) Error(theError error, msgAndArgs ...interface{}) bool

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

  actualObj, err := SomeFunction()
  if assert.Error(err, "An error was expected") {
	   assert.Equal(err, expectedError)
  }

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

func (*Assertions) Exactly

func (a *Assertions) Exactly(expected, actual interface{}, msgAndArgs ...interface{}) bool

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

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

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

func (*Assertions) Fail

func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool

Fail reports a failure through

func (*Assertions) False

func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool

False asserts that the specified value is true.

assert.False(myBool, "myBool should be false")

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

func (*Assertions) HTTPBodyContains

func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool

HTTPBodyContains asserts that a specified handler returns a body that contains a string.

assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")

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

func (*Assertions) HTTPBodyNotContains

func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, mode, url string, values url.Values, str interface{}) bool

HTTPBodyNotContains asserts that a specified handler returns a body that does not contain a string.

assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky")

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

func (*Assertions) HTTPError

func (a *Assertions) HTTPError(handler http.HandlerFunc, mode, url string, values url.Values) bool

HTTPError asserts that a specified handler returns an error status code.

assert.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func (*Assertions) HTTPRedirect

func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, mode, url string, values url.Values) bool

HTTPRedirect asserts that a specified handler returns a redirect status code.

assert.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}}

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

func (*Assertions) HTTPSuccess

func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, mode, url string, values url.Values) bool

HTTPSuccess asserts that a specified handler returns a success status code.

assert.HTTPSuccess(myHandler, "POST", http://www.google.com", nil)

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

func (*Assertions) Implements

func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool

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

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

func (*Assertions) InDelta

func (a *Assertions) InDelta(expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool

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

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

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

func (*Assertions) InEpsilon

func (a *Assertions) InEpsilon(expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool

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

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

func (*Assertions) IsType

func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool

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

func (*Assertions) Len

func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool

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

assert.Len(mySlice, 3, "The size of slice is not 3")

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

func (*Assertions) Nil

func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool

Nil asserts that the specified object is nil.

assert.Nil(err, "err should be nothing")

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

func (*Assertions) NoError

func (a *Assertions) NoError(theError error, msgAndArgs ...interface{}) bool

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

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

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

func (*Assertions) NotContains

func (a *Assertions) NotContains(s, contains interface{}, msgAndArgs ...interface{}) bool

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

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

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

func (*Assertions) NotEmpty

func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool

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

if assert.NotEmpty(obj) {

assert.Equal("two", obj[1])

}

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

func (*Assertions) NotEqual

func (a *Assertions) NotEqual(expected, actual interface{}, msgAndArgs ...interface{}) bool

NotEqual asserts that the specified values are NOT equal.

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

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

func (*Assertions) NotNil

func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool

NotNil asserts that the specified object is not nil.

assert.NotNil(err, "err should be something")

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

func (*Assertions) NotPanics

func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool

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

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

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

func (*Assertions) NotRegexp

func (a *Assertions) NotRegexp(rx interface{}, str 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")

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

func (*Assertions) Panics

func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool

Panics asserts that the code inside the specified PanicTestFunc panics.

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

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

func (*Assertions) Regexp

func (a *Assertions) Regexp(rx interface{}, str 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")

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

func (*Assertions) True

func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool

True asserts that the specified value is true.

assert.True(myBool, "myBool should be true")

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

func (*Assertions) WithinDuration

func (a *Assertions) WithinDuration(expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool

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

assert.WithinDuration(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).

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{})
}

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