Error

Asserting Errors

Assertions

All links point to https://pkg.go.dev/github.com/go-openapi/testify/v2

This domain exposes 8 functionalities.

EqualError

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

Examples

	actualObj, err := SomeFunction()
	assertions.EqualError(t, err,  expectedErrorString)
	success: ErrTest, "assert.ErrTest general error for testing"
	failure: ErrTest, "wrong error message"

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualError(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqualError(t *testing.T)
	success := assert.EqualError(t, assert.ErrTest, "assert.ErrTest general error for testing")
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestEqualError(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestEqualError(t *testing.T)
	require.EqualError(t, require.ErrTest, "assert.ErrTest general error for testing")
	fmt.Println("passed")

}

Signature	Usage
`assert.EqualError(t T, err error, errString string, msgAndArgs ...any) bool`	package-level function
`assert.EqualErrorf(t T, err error, errString string, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).EqualError(err error, errString string) bool`	method variant
`assert.(*Assertions).EqualErrorf(err error, errString string, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.EqualError(t T, err error, errString string, msgAndArgs ...any) bool`	package-level function
`require.EqualErrorf(t T, err error, errString string, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).EqualError(err error, errString string) bool`	method variant
`require.(*Assertions).EqualErrorf(err error, errString string, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.EqualError(t T, err error, errString string, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#EqualError

Error

Error asserts that a function returned a non-nil error (i.e. an error).

Examples

	actualObj, err := SomeFunction()
	assertions.Error(t, err)
	success: ErrTest
	failure: nil

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestError(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestError(t *testing.T)
	success := assert.Error(t, assert.ErrTest)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestError(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestError(t *testing.T)
	require.Error(t, require.ErrTest)
	fmt.Println("passed")

}

Signature	Usage
`assert.Error(t T, err error, msgAndArgs ...any) bool`	package-level function
`assert.Errorf(t T, err error, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).Error(err error) bool`	method variant
`assert.(*Assertions).Errorf(err error, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.Error(t T, err error, msgAndArgs ...any) bool`	package-level function
`require.Errorf(t T, err error, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).Error(err error) bool`	method variant
`require.(*Assertions).Errorf(err error, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.Error(t T, err error, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#Error

ErrorAs

ErrorAs asserts that at least one of the errors in err’s chain matches target, and if so, sets target to that error value.

This is a wrapper for errors.As.

Examples

	assertions.ErrorAs(t, err, &target)
	success: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)
	failure: ErrTest, new(*dummyError)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestErrorAs(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorAs(t *testing.T)
	success := assert.ErrorAs(t, fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError))
	fmt.Printf("success: %t\n", success)

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestErrorAs(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorAs(t *testing.T)
	require.ErrorAs(t, fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError))
	fmt.Println("passed")

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Signature	Usage
`assert.ErrorAs(t T, err error, target any, msgAndArgs ...any) bool`	package-level function
`assert.ErrorAsf(t T, err error, target any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).ErrorAs(err error, target any) bool`	method variant
`assert.(*Assertions).ErrorAsf(err error, target any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.ErrorAs(t T, err error, target any, msgAndArgs ...any) bool`	package-level function
`require.ErrorAsf(t T, err error, target any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).ErrorAs(err error, target any) bool`	method variant
`require.(*Assertions).ErrorAsf(err error, target any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.ErrorAs(t T, err error, target any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#ErrorAs

ErrorContains

ErrorContains asserts that a function returned a non-nil error (i.e. an error) and that the error contains the specified substring.

Examples

	actualObj, err := SomeFunction()
	assertions.ErrorContains(t, err,  expectedErrorSubString)
	success: ErrTest, "general error"
	failure: ErrTest, "not in message"

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestErrorContains(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorContains(t *testing.T)
	success := assert.ErrorContains(t, assert.ErrTest, "general error")
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestErrorContains(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorContains(t *testing.T)
	require.ErrorContains(t, require.ErrTest, "general error")
	fmt.Println("passed")

}

Signature	Usage
`assert.ErrorContains(t T, err error, contains string, msgAndArgs ...any) bool`	package-level function
`assert.ErrorContainsf(t T, err error, contains string, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).ErrorContains(err error, contains string) bool`	method variant
`assert.(*Assertions).ErrorContainsf(err error, contains string, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.ErrorContains(t T, err error, contains string, msgAndArgs ...any) bool`	package-level function
`require.ErrorContainsf(t T, err error, contains string, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).ErrorContains(err error, contains string) bool`	method variant
`require.(*Assertions).ErrorContainsf(err error, contains string, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.ErrorContains(t T, err error, contains string, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#ErrorContains

ErrorIs

ErrorIs asserts that at least one of the errors in err’s chain matches target.

This is a wrapper for errors.Is.

Examples

	assertions.ErrorIs(t, err, io.EOF)
	success: fmt.Errorf("wrap: %w", io.EOF), io.EOF
	failure: ErrTest, io.EOF

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestErrorIs(t *testing.T)
package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorIs(t *testing.T)
	success := assert.ErrorIs(t, fmt.Errorf("wrap: %w", io.EOF), io.EOF)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestErrorIs(t *testing.T)
package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestErrorIs(t *testing.T)
	require.ErrorIs(t, fmt.Errorf("wrap: %w", io.EOF), io.EOF)
	fmt.Println("passed")

}

Signature	Usage
`assert.ErrorIs(t T, err error, target error, msgAndArgs ...any) bool`	package-level function
`assert.ErrorIsf(t T, err error, target error, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).ErrorIs(err error, target error) bool`	method variant
`assert.(*Assertions).ErrorIsf(err error, target error, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.ErrorIs(t T, err error, target error, msgAndArgs ...any) bool`	package-level function
`require.ErrorIsf(t T, err error, target error, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).ErrorIs(err error, target error) bool`	method variant
`require.(*Assertions).ErrorIsf(err error, target error, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.ErrorIs(t T, err error, target error, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#ErrorIs

NoError

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

Examples

	actualObj, err := SomeFunction()
	if assert.NoError(t, err) {
		assertions.Equal(t, expectedObj, actualObj)
	}
	success: nil
	failure: ErrTest

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNoError(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNoError(t *testing.T)
	success := assert.NoError(t, nil)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNoError(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNoError(t *testing.T)
	require.NoError(t, nil)
	fmt.Println("passed")

}

Signature	Usage
`assert.NoError(t T, err error, msgAndArgs ...any) bool`	package-level function
`assert.NoErrorf(t T, err error, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NoError(err error) bool`	method variant
`assert.(*Assertions).NoErrorf(err error, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NoError(t T, err error, msgAndArgs ...any) bool`	package-level function
`require.NoErrorf(t T, err error, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NoError(err error) bool`	method variant
`require.(*Assertions).NoErrorf(err error, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NoError(t T, err error, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#NoError

NotErrorAs

NotErrorAs asserts that none of the errors in err’s chain matches target, but if so, sets target to that error value.

Examples

	assertions.NotErrorAs(t, err, &target)
	success: ErrTest, new(*dummyError)
	failure: fmt.Errorf("wrap: %w", &dummyError{}), new(*dummyError)

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotErrorAs(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotErrorAs(t *testing.T)
	success := assert.NotErrorAs(t, assert.ErrTest, new(*dummyError))
	fmt.Printf("success: %t\n", success)

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotErrorAs(t *testing.T)
package main

import (
	"fmt"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotErrorAs(t *testing.T)
	require.NotErrorAs(t, require.ErrTest, new(*dummyError))
	fmt.Println("passed")

}

type dummyError struct {
}

func (d *dummyError) Error() string {
	return "dummy error"
}

Signature	Usage
`assert.NotErrorAs(t T, err error, target any, msgAndArgs ...any) bool`	package-level function
`assert.NotErrorAsf(t T, err error, target any, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotErrorAs(err error, target any) bool`	method variant
`assert.(*Assertions).NotErrorAsf(err error, target any, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotErrorAs(t T, err error, target any, msgAndArgs ...any) bool`	package-level function
`require.NotErrorAsf(t T, err error, target any, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotErrorAs(err error, target any) bool`	method variant
`require.(*Assertions).NotErrorAsf(err error, target any, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotErrorAs(t T, err error, target any, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#NotErrorAs

NotErrorIs

NotErrorIs asserts that none of the errors in err’s chain matches target.

This is a wrapper for errors.Is.

Examples

	assertions.NotErrorIs(t, err, io.EOF)
	success: ErrTest, io.EOF
	failure: fmt.Errorf("wrap: %w", io.EOF), io.EOF

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotErrorIs(t *testing.T)
package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/assert"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotErrorIs(t *testing.T)
	success := assert.NotErrorIs(t, assert.ErrTest, io.EOF)
	fmt.Printf("success: %t\n", success)

}

Copy and click to open Go Playground

// real-world test would inject *testing.T from TestNotErrorIs(t *testing.T)
package main

import (
	"fmt"
	"io"
	"testing"

	"github.com/go-openapi/testify/v2/require"
)

func main() {
	t := new(testing.T) // should come from testing, e.g. func TestNotErrorIs(t *testing.T)
	require.NotErrorIs(t, require.ErrTest, io.EOF)
	fmt.Println("passed")

}

Signature	Usage
`assert.NotErrorIs(t T, err error, target error, msgAndArgs ...any) bool`	package-level function
`assert.NotErrorIsf(t T, err error, target error, msg string, args ...any) bool`	formatted variant
`assert.(*Assertions).NotErrorIs(err error, target error) bool`	method variant
`assert.(*Assertions).NotErrorIsf(err error, target error, msg string, args ..any)`	method formatted variant

Signature	Usage
`require.NotErrorIs(t T, err error, target error, msgAndArgs ...any) bool`	package-level function
`require.NotErrorIsf(t T, err error, target error, msg string, args ...any) bool`	formatted variant
`require.(*Assertions).NotErrorIs(err error, target error) bool`	method variant
`require.(*Assertions).NotErrorIsf(err error, target error, msg string, args ..any)`	method formatted variant

Signature	Usage
`assertions.NotErrorIs(t T, err error, target error, msgAndArgs ...any) bool`	internal implementation

Source: github.com/go-openapi/testify/v2/internal/assertions#NotErrorIs

Generated with github.com/go-openapi/testify/codegen/v2