feat: add IsError.

Signed-off-by: ghosind <[email protected]>

Author: ghosind

builtin.go

@@ -494,6 +494,33 @@ func NotHasSuffixStringNow(t *testing.T, str, suffix string, message ...any) err
 	return tryNotHasSuffixString(t, true, str, suffix, message...)
 }
 
+// IsError tests whether the error matches the target or not. It'll set the result to fail if the
+// error does not match to the target error, and it doesn't stop the execution.
+//
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	assert.IsError(t, err1, err1) // success
+//	assert.IsError(t, err1, err2) // fail
+//	assert.IsError(t, errors.Join(err1, err2), err1) // success
+//	assert.IsError(t, errors.Join(err1, err2), err2) // success
+func IsError(t *testing.T, err, target error, message ...any) error {
+	return isError(t, false, err, target, message...)
+}
+
+// IsErrorNow tests whether the error matches the target or not. It'll set the result to fail and
+// stop the execution if the error does not match to the target error.
+//
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	assert.IsErrorNow(t, errors.Join(err1, err2), err1) // success
+//	assert.IsErrorNow(t, errors.Join(err1, err2), err2) // success
+//	assert.IsErrorNow(t, err1, err1) // success
+//	assert.IsErrorNow(t, err1, err2) // fail
+//	// never runs
+func IsErrorNow(t *testing.T, err, target error, message ...any) error {
+	return isError(t, true, err, target, message...)
+}
+
 // MapHasKey tests whether the map contains the specified key or not, it will fail if the map does
 // not contain the key, or the type of the key cannot assign to the type of the key of the map.
 //

error.go

@@ -34,6 +34,7 @@ const (
 	defaultErrMessageGte                string = "%v must greater than or equal to %v"
 	defaultErrMessageLt                 string = "%v must less then %v"
 	defaultErrMessageLte                string = "%v must less then or equal to %v"
+	defaultErrMessageIsError            string = "expect err matches %v, got %v"
 )
 
 var (

errors.go

@@ -0,0 +1,49 @@
+package assert
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+// IsError tests whether the error matches the target or not. It'll set the result to fail if the
+// error does not match to the target error, and it doesn't stop the execution.
+//
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	a := assert.New(t)
+//	a.IsError(err1, err1) // success
+//	a.IsError(err1, err2) // fail
+//	a.IsError(errors.Join(err1, err2), err1) // success
+//	a.IsError(errors.Join(err1, err2), err2) // success
+func (a *Assertion) IsError(err, target error, message ...any) error {
+	return isError(a.T, false, err, target, message...)
+}
+
+// IsErrorNow tests whether the error matches the target or not. It'll set the result to fail and
+// stop the execution if the error does not match to the target error.
+//
+//	err1 := errors.New("error 1")
+//	err2 := errors.New("error 2")
+//	a := assert.New(t)
+//	a.IsErrorNow(errors.Join(err1, err2), err1) // success
+//	a.IsErrorNow(errors.Join(err1, err2), err2) // success
+//	a.IsErrorNow(err1, err1) // success
+//	a.IsErrorNow(err1, err2) // fail
+//	// never runs
+func (a *Assertion) IsErrorNow(err, target error, message ...any) error {
+	return isError(a.T, true, err, target, message...)
+}
+
+// isError tests whether the error matches the target or not.
+func isError(t *testing.T, failedNow bool, err, target error, message ...any) error {
+	t.Helper()
+
+	return test(
+		t,
+		func() bool { return errors.Is(err, target) },
+		failedNow,
+		fmt.Sprintf(defaultErrMessageIsError, target, err),
+		message...,
+	)
+}

errors_test.go

@@ -0,0 +1,41 @@
+package assert
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestIsError(t *testing.T) {
+	a := New(t)
+	mockA := New(new(testing.T))
+
+	err1 := errors.New("error 1")
+	err2 := errors.New("error 2")
+	err3 := errors.New("error 3")
+
+	testIsError(a, mockA, errors.New("test"), err1, false)
+	testIsError(a, mockA, err1, err1, true)
+	testIsError(a, mockA, err1, err2, false)
+	testIsError(a, mockA, err1, err3, false)
+	testIsError(a, mockA, errors.Join(err1, err2), err1, true)
+	testIsError(a, mockA, errors.Join(err1, err2), err2, true)
+	testIsError(a, mockA, errors.Join(err1, err2), err3, false)
+}
+
+func testIsError(a, mockA *Assertion, err, target error, isError bool) {
+	a.T.Helper()
+
+	testAssertionFunction(a, "IsError", func() error {
+		return IsError(mockA.T, err, target)
+	}, isError)
+	testAssertionFunction(a, "Assertion.IsError", func() error {
+		return mockA.IsError(err, target)
+	}, isError)
+
+	testAssertionNowFunction(a, "IsErrorNow", func() {
+		IsErrorNow(mockA.T, err, target)
+	}, !isError)
+	testAssertionNowFunction(a, "Assertion.IsErrorNow", func() {
+		mockA.IsErrorNow(err, target)
+	}, !isError)
+}