Add redundant-error-assertion checker for implied assert.Error / require.Error assertions

README.md

@@ -107,6 +107,7 @@ https://golangci-lint.run/docs/linters/configuration/#testifylint
 | [negative-positive](#negative-positive)             | ✅                  | ✅       |
 | [nil-compare](#nil-compare)                         | ✅                  | ✅       |
 | [regexp](#regexp)                                   | ✅                  | ✅       |
+| [redundant-error-assertion](#redundant-error-assertion) | ✅                  | ✅       |
 | [require-error](#require-error)                     | ✅                  | ❌       |
 | [suite-broken-parallel](#suite-broken-parallel)     | ✅                  | ✅       |
 | [suite-dont-use-pkg](#suite-dont-use-pkg)           | ✅                  | ✅       |
@@ -997,6 +998,35 @@ assert.NotRegexp(t, `\[.*\] TRACE message`, out)
 
 ---
 
+### redundant-error-assertion
+
+```go
+❌
+assert.Error(t, err)
+assert.ErrorContains(t, err, "not found")
+
+assert.Error(t, err)
+assert.ErrorIs(t, err, io.EOF)
+
+assert.Error(t, err)
+assert.ErrorAs(t, err, &target)
+
+assert.Error(t, err)
+assert.EqualError(t, err, "end of file")
+
+✅
+assert.ErrorContains(t, err, "not found")
+assert.ErrorIs(t, err, io.EOF)
+assert.ErrorAs(t, err, &target)
+assert.EqualError(t, err, "end of file")
+```
+
+**Autofix**: true. <br>
+**Enabled by default**: true. <br>
+**Reason**: Code simplification.
+
+---
+
 ### require-error
 
 ```go

analyzer/checkers_factory_test.go

@@ -61,6 +61,7 @@ func Test_newCheckers(t *testing.T) {
 	}
 
 	enabledByDefaultAdvancedCheckers := []checkers.AdvancedChecker{
+		checkers.NewRedundantErrorAssertion(),
 		checkers.NewBlankImport(),
 		checkers.NewGoRequire(),
 		checkers.NewMockExpect(),
@@ -70,6 +71,7 @@ func Test_newCheckers(t *testing.T) {
 		checkers.NewSuiteSubtestRun(),
 	}
 	allAdvancedCheckers := []checkers.AdvancedChecker{
+		checkers.NewRedundantErrorAssertion(),
 		checkers.NewBlankImport(),
 		checkers.NewGoRequire(),
 		checkers.NewMockExpect(),

analyzer/testdata/src/checkers-default/redundant-error-assertion/redundant_error_assertion_test.go

@@ -0,0 +1,115 @@
+package redundanterrorassertion
+
+import (
+	"errors"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRedundantErrorAssertion(t *testing.T) {
+	t.Parallel()
+
+	var (
+		errA   = errors.New("err A")
+		errB   = errors.New("err B")
+		target *os.PathError
+	)
+
+	assObj, reqObj := assert.New(t), require.New(t)
+
+	// Invalid.
+	{
+		assert.Error(t, errA) // want "redundant-error-assertion: remove assert\\.Error: assert\\.ErrorContains already asserts that the error is not nil"
+		assert.ErrorContains(t, errA, "err")
+	}
+
+	{
+		require.Error(t, errA) // want "redundant-error-assertion: remove require\\.Error: assert\\.ErrorContains already asserts that the error is not nil"
+		assert.ErrorContains(t, errA, "err")
+	}
+
+	{
+		require.Error(t, errA) // want "redundant-error-assertion: remove require\\.Error: require\\.ErrorContains already asserts that the error is not nil"
+		require.ErrorContains(t, errA, "err")
+	}
+
+	{
+		assert.Error(t, errA) // want "redundant-error-assertion: remove assert\\.Error: require\\.ErrorContains already asserts that the error is not nil"
+		require.ErrorContains(t, errA, "err")
+	}
+
+	{
+		assert.EqualError(t, errA, "err A")
+		assert.Error(t, errA) // want "redundant-error-assertion: remove assert\\.Error: assert\\.EqualError already asserts that the error is not nil"
+	}
+
+	{
+		require.EqualError(t, errA, "err A")
+		require.Error(t, errA) // want "redundant-error-assertion: remove require\\.Error: require\\.EqualError already asserts that the error is not nil"
+	}
+
+	{
+		assObj.Error(errA) // want "redundant-error-assertion: remove assObj\\.Error: assObj\\.ErrorAs already asserts that the error is not nil"
+		assObj.ErrorAs(errA, &target)
+	}
+
+	{
+		reqObj.Error(errA) // want "redundant-error-assertion: remove reqObj\\.Error: reqObj\\.ErrorAs already asserts that the error is not nil"
+		reqObj.ErrorAs(errA, &target)
+	}
+
+	{
+		assert.Errorf(t, errA, "msg") // want "redundant-error-assertion: remove assert\\.Errorf: reqObj\\.ErrorAs already asserts that the error is not nil"
+		reqObj.ErrorAs(errA, &target)
+	}
+
+	{
+		require.Errorf(t, errA, "msg") // want "redundant-error-assertion: remove require\\.Errorf: reqObj\\.ErrorAs already asserts that the error is not nil"
+		reqObj.ErrorAs(errA, &target)
+	}
+
+	{
+		require.Errorf(t, errA, "msg") // want "redundant-error-assertion: remove require\\.Errorf: require\\.ErrorIs already asserts that the error is not nil"
+		require.ErrorIs(t, errA, io.EOF)
+	}
+
+	// Valid.
+	{
+		{
+			assert.Error(t, errA)
+			assert.ErrorContains(t, errB, "err")
+		}
+
+		{
+			require.Error(t, errA)
+			assert.ErrorContains(t, errB, "err")
+		}
+
+		{
+			assert.Error(t, errA)
+		}
+
+		if assert.Error(t, errA) {
+			assert.ErrorContains(t, errA, "err")
+		}
+
+		{
+			{
+				assert.Error(t, errA)
+			}
+			assert.ErrorContains(t, errA, "err")
+		}
+
+		{
+			errA = errB
+			assert.Error(t, errA)
+
+			errA = io.EOF
+			assert.ErrorContains(t, errA, "EOF")
+		}
+	}
+}

analyzer/testdata/src/checkers-default/redundant-error-assertion/redundant_error_assertion_test.go.golden

@@ -0,0 +1,104 @@
+package redundanterrorassertion
+
+import (
+	"errors"
+	"io"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestRedundantErrorAssertion(t *testing.T) {
+	t.Parallel()
+
+	var (
+		errA   = errors.New("err A")
+		errB   = errors.New("err B")
+		target *os.PathError
+	)
+
+	assObj, reqObj := assert.New(t), require.New(t)
+
+	// Invalid.
+	{
+		assert.ErrorContains(t, errA, "err")
+	}
+
+	{
+		assert.ErrorContains(t, errA, "err")
+	}
+
+	{
+		require.ErrorContains(t, errA, "err")
+	}
+
+	{
+		require.ErrorContains(t, errA, "err")
+	}
+
+	{
+		assert.EqualError(t, errA, "err A")
+	}
+
+	{
+		require.EqualError(t, errA, "err A")
+	}
+
+	{
+		assObj.ErrorAs(errA, &target)
+	}
+
+	{
+		reqObj.ErrorAs(errA, &target)
+	}
+
+	{
+		reqObj.ErrorAs(errA, &target)
+	}
+
+	{
+		reqObj.ErrorAs(errA, &target)
+	}
+
+	{
+		require.ErrorIs(t, errA, io.EOF)
+	}
+
+	// Valid.
+	{
+		{
+			assert.Error(t, errA)
+			assert.ErrorContains(t, errB, "err")
+		}
+
+		{
+			require.Error(t, errA)
+			assert.ErrorContains(t, errB, "err")
+		}
+
+		{
+			assert.Error(t, errA)
+		}
+
+		if assert.Error(t, errA) {
+			assert.ErrorContains(t, errA, "err")
+		}
+
+		{
+			{
+				assert.Error(t, errA)
+			}
+			assert.ErrorContains(t, errA, "err")
+		}
+
+		{
+			errA = errB
+			assert.Error(t, errA)
+
+			errA = io.EOF
+			assert.ErrorContains(t, errA, "EOF")
+		}
+	}
+}

internal/checkers/checkers_registry.go

@@ -26,6 +26,7 @@ var registry = checkersRegistry{
 	{factory: asCheckerFactory(NewSuiteExtraAssertCall), enabledByDefault: true},
 	{factory: asCheckerFactory(NewSuiteDontUsePkg), enabledByDefault: true},
 	{factory: asCheckerFactory(NewUselessAssert), enabledByDefault: true},
+	{factory: asCheckerFactory(NewRedundantErrorAssertion), enabledByDefault: true},
 	{factory: asCheckerFactory(NewFormatter), enabledByDefault: true},
 	// Advanced checkers.
 	{factory: asCheckerFactory(NewBlankImport), enabledByDefault: true},

internal/checkers/checkers_registry_test.go

@@ -54,6 +54,7 @@ func TestAll(t *testing.T) {
 		"suite-extra-assert-call",
 		"suite-dont-use-pkg",
 		"useless-assert",
+		"redundant-error-assertion",
 		"formatter",
 		"blank-import",
 		"go-require",
@@ -96,6 +97,7 @@ func TestEnabledByDefault(t *testing.T) {
 		"suite-extra-assert-call",
 		"suite-dont-use-pkg",
 		"useless-assert",
+		"redundant-error-assertion",
 		"formatter",
 		"blank-import",
 		"go-require",