Testify require and assert: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
Line 8: Line 8:
<code>require</code> and <code>assert</code> packages provide functions to evaluate arguments and establish whether the test passes or fails.  
<code>require</code> and <code>assert</code> packages provide functions to evaluate arguments and establish whether the test passes or fails.  


The major difference between <code>require</code> and <code>assert</code> is that <code>assert</code> means '''continue on error'''. If an assertion fails, the test reports it and '''continues'''. In the end, the test is accounted as "failed", but it keeps going on failed assertions. This is different from the behavior of <code>assert</code> in other languages and frameworks, where the first failed assertion stops the current test. This does not make too much sense - if an assertion is broken, I am not that interested in what comes after that, they are likely to be broken too, or at least, not trustworthy. If you want the test to exit after the first failed assertion, use <code>require</code>. <code>require</code> means '''exit on error'''.
The major difference between <code>require</code> and <code>assert</code> is that <code>assert</code> means '''continue on error'''. If an assertion fails, the test reports it and '''continues'''. In the end, the test is accounted as "failed", but it keeps going on failed assertions. This is different from the behavior of <code>assert</code> in other languages and frameworks, where the first failed assertion stops the current test. This does not make too much sense - if an assertion is broken, I am not that interested in what comes after that, they are likely to be broken too, or at least, not to be trusted. If you want the test to exit after the first failed assertion, use <code>require</code>. <code>require</code> means '''exit on error'''.


Internally, this is implemented by assert <code>calling</code> <code>Fail()</code> and <code>require</code> calling <code>FailNow()</code>.
Internally, this is implemented by assert <code>calling</code> <code>Fail()</code> and <code>require</code> calling <code>FailNow()</code>.

Revision as of 18:12, 12 March 2024

External

Internal

Overview

require and assert packages provide functions to evaluate arguments and establish whether the test passes or fails.

The major difference between require and assert is that assert means continue on error. If an assertion fails, the test reports it and continues. In the end, the test is accounted as "failed", but it keeps going on failed assertions. This is different from the behavior of assert in other languages and frameworks, where the first failed assertion stops the current test. This does not make too much sense - if an assertion is broken, I am not that interested in what comes after that, they are likely to be broken too, or at least, not to be trusted. If you want the test to exit after the first failed assertion, use require. require means exit on error.

Internally, this is implemented by assert calling Fail() and require calling FailNow().

What happens when an assert fails? How is the test state impacted? Debug and find out.

Calling assert and require from Goroutines

Equality and Non-Equality

In case the result is failure, Equal() and NotEqual() delegate to Fail().

package somepkg

import (
	"testing"

	testifyassert "github.com/stretchr/testify/assert"
    testifyrequire "github.com/stretchr/testify/require"
)

func TestSomething(t *testing.T) {
	assert := testifyassert.New(t)
    require := testifyrequire.New(t)
    assert.Equal(123, 123, "this message is displayed when the assertion fails, but the test continues %s", "because of inequality")
    require.Equal(123, 123, "this message is displayed when the test fails and exists %s", "because of inequality") 
	assert.NotEqual(123, 321, "this message is displayed when the test fails %s", "because of equality")
    require.NotEqual(123, 321, "this message is displayed when the test fails and exists %s", "because of inequality") 
}

Nil and Non-Nil

In case the result is failure, Nil() and NotNil() delegate to Fail().

package somepkg

import (
	"testing"

	testifyassert "github.com/stretchr/testify/assert"
    testifyrequire "github.com/stretchr/testify/require"
)

func TestSomething(t *testing.T) {
	assert := testifyassert.New(t)
    require := testifyrequire.New(t)
	someObj := &struct{}{}
	assert.NotNil(someObj, "someObj should not have been nil but it is %v, and the test continues", someObj)
	require.NotNil(someObj, "someObj should not have been nil but it is %v, and the test exits", someObj)
	someObj = nil
	assert.Nil(someObj, "someObj should have been nil but it is %v, and the test continues", someObj)
    require.Nil(someObj, "someObj should have been nil but it is %v, and the test exits", someObj)
}

Failing the Test

Fail()

Does not stop the test. It annotates its internal state that there was a failure, and let the test continue.

Failf()

FailNow()

Checking that an Error Has Expected Message

err := ...
assert.NotNil(err)
assert.Equal(err.Error(), "expected message")