require

package
v1.1.3 Latest Latest
Warning

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

 Go to latest Published: Feb 17, 2016 License: Apache-2.0 Imports: 2 Imported by: 0

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

Constants

This section is empty.

Variables

This section is empty.

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 interface{}, msgAndArgs ...interface{})

Contains asserts that the specified string contains the specified substring. 

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

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)

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")

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

func EqualValues 

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

EqualValues asserts that two objects are equal or convertable to each other. 

require.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal")

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

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")

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")

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)

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

func IsType 

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

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

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. 

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

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")

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 interface{}, 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'")

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])

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")

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")

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")

func NotRegexp 

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

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

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

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")

func Regexp 

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

Regexp asserts that a specified regexp matches a string. 

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

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")

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")

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 assert.Comparison, msgAndArgs ...interface{})

Uses a Comparison to assert a complex condition.

func (*Assertions) Contains 

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

Contains asserts that the specified string contains the specified substring. 

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

func (*Assertions) Empty 

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

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

require.Empty(obj)

func (*Assertions) Equal 

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

Equal asserts that two objects are equal. 

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

func (*Assertions) EqualError 

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

func (*Assertions) Error 

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

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

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

func (*Assertions) Exactly 

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

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

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

func (*Assertions) Fail 

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

Fail reports a failure through

func (*Assertions) False 

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

False asserts that the specified value is true. 

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

func (*Assertions) Implements 

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

func (*Assertions) InDelta 

func (a *Assertions) InDelta(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)

func (*Assertions) InEpsilon 

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

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

func (*Assertions) IsType 

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

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

func (*Assertions) Len 

func (a *Assertions) Len(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. 

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

func (*Assertions) Nil 

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

Nil asserts that the specified object is nil. 

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

func (*Assertions) NoError 

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

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

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

func (*Assertions) NotContains 

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

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

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

func (*Assertions) NotEmpty 

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

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

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

func (*Assertions) NotEqual 

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

NotEqual asserts that the specified values are NOT equal. 

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

func (*Assertions) NotNil 

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

NotNil asserts that the specified object is not nil. 

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

func (*Assertions) NotPanics 

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

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

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

func (*Assertions) NotRegexp 

func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

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

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

func (*Assertions) Panics 

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

Panics asserts that the code inside the specified PanicTestFunc panics. 

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

func (*Assertions) Regexp 

func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{})

Regexp asserts that a specified regexp matches a string. 

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

func (*Assertions) True 

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

True asserts that the specified value is true. 

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

func (*Assertions) WithinDuration 

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

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

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

type TestingT 

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.