[tst] refactor interfaces (#28)

* [tst] refactor interfaces

* edge cases tests

Author: moukoublen

tst/errors.go

@@ -15,13 +15,21 @@ const expectedError = "Expected error but none received"
 type TestingT interface {
 	Errorf(format string, args ...interface{})
 	FailNow()
+	Helper()
 }
 
 type ErrorAssertionFunc func(t TestingT, err error) bool
 
 func (e ErrorAssertionFunc) AsRequire() require.ErrorAssertionFunc {
 	return func(tt require.TestingT, err error, _ ...any) {
-		if suc := e(tt, err); !suc {
+		t, is := tt.(TestingT)
+		if !is { // not possible
+			tt.Errorf("Wrong TestingT type %T", tt)
+			tt.FailNow()
+			return
+		}
+
+		if suc := e(t, err); !suc {
 			tt.FailNow()
 		}
 	}
@@ -30,21 +38,18 @@ func (e ErrorAssertionFunc) AsRequire() require.ErrorAssertionFunc {
 func (e ErrorAssertionFunc) AsAssert() assert.ErrorAssertionFunc {
 	return func(tt assert.TestingT, err error, _ ...any) bool {
 		t, is := tt.(TestingT)
-		if is {
-			return e(t, err)
+		if !is { // not possible
+			tt.Errorf("Wrong TestingT type %T", tt)
+			return false
 		}
 
-		// not possible
-		tt.Errorf("Wrong TestingT type %T", tt)
-		return false
+		return e(t, err)
 	}
 }
 
 func NoError() ErrorAssertionFunc {
 	return func(t TestingT, err error) bool {
-		if h, ok := t.(interface{ Helper() }); ok {
-			h.Helper()
-		}
+		t.Helper()
 
 		if err != nil {
 			t.Errorf("Expected nil error but received : %T(%s)", err, err.Error())
@@ -57,9 +62,7 @@ func NoError() ErrorAssertionFunc {
 
 func Error() ErrorAssertionFunc {
 	return func(t TestingT, err error) bool {
-		if h, ok := t.(interface{ Helper() }); ok {
-			h.Helper()
-		}
+		t.Helper()
 
 		if err == nil {
 			t.Errorf(expectedError)
@@ -76,9 +79,8 @@ func Error() ErrorAssertionFunc {
 // Returns false if the error is nil or doesn't match any expected errors.
 func ErrorIs(allExpectedErrors ...error) ErrorAssertionFunc {
 	return func(t TestingT, err error) bool {
-		if h, ok := t.(interface{ Helper() }); ok {
-			h.Helper()
-		}
+		t.Helper()
+
 		if err == nil {
 			t.Errorf(expectedError)
 			return false
@@ -121,9 +123,7 @@ func ErrorIs(allExpectedErrors ...error) ErrorAssertionFunc {
 
 func ErrorOfType[T error](typedAsserts ...func(TestingT, T)) ErrorAssertionFunc {
 	return func(t TestingT, err error) bool {
-		if h, ok := t.(interface{ Helper() }); ok {
-			h.Helper()
-		}
+		t.Helper()
 
 		if err == nil {
 			t.Errorf(expectedError)
@@ -152,9 +152,7 @@ func ErrorOfType[T error](typedAsserts ...func(TestingT, T)) ErrorAssertionFunc
 
 func ErrorStringContains(s string) ErrorAssertionFunc {
 	return func(t TestingT, err error) bool {
-		if h, ok := t.(interface{ Helper() }); ok {
-			h.Helper()
-		}
+		t.Helper()
 
 		if err == nil {
 			t.Errorf(expectedError)
@@ -173,9 +171,7 @@ func ErrorStringContains(s string) ErrorAssertionFunc {
 
 func All(expected ...ErrorAssertionFunc) ErrorAssertionFunc {
 	return func(t TestingT, err error) bool {
-		if h, ok := t.(interface{ Helper() }); ok {
-			h.Helper()
-		}
+		t.Helper()
 
 		ret := true
 		for _, fn := range expected {

tst/errors_test.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNoError(t *testing.T) {
@@ -249,6 +250,7 @@ func TestErrorOfType(t *testing.T) {
 		pathErr := &os.PathError{Op: "open", Path: "/test", Err: baseErr}
 
 		mt := NewMockTestingT(t)
+		mt.EXPECT().Helper().Maybe()
 		ma := &mockErrorTypedAssertionFunc{}
 		ma.OnAssert(mt, pathErr).Return(true).Times(3)
 
@@ -337,6 +339,7 @@ type errorAssertionFuncTestCase struct {
 
 func (tc errorAssertionFuncTestCase) Test(t *testing.T) {
 	mt := NewMockTestingT(t)
+	mt.EXPECT().Helper().Maybe()
 	if tc.initMock != nil {
 		tc.initMock(mt)
 	}
@@ -402,11 +405,29 @@ func TestTestifyIntegration(t *testing.T) {
 
 			// mock T init
 			mt := NewMockTestingT(t)
+			mt.EXPECT().Helper().Maybe()
 			tc.mockTInit(mt)
 
 			tc.run(t, mt, f)
 		})
 	}
+
+	t.Run("mismatch of T", func(t *testing.T) {
+		t.Run("require testingT", func(t *testing.T) {
+			mt := &testifyRequireTestingTMock{}
+			mt.On("Errorf", "Wrong TestingT type %T", mock.Anything).Once()
+			mt.On("FailNow").Once()
+
+			NoError().AsRequire()(mt, nil)
+		})
+		t.Run("assert testingT", func(t *testing.T) {
+			mt := &testifyAssertTestingTMock{}
+			mt.On("Errorf", "Wrong TestingT type %T", mock.Anything).Once()
+
+			got := NoError().AsAssert()(mt, nil)
+			assert.False(t, got)
+		})
+	})
 }
 
 func TestAll(t *testing.T) {
@@ -450,6 +471,7 @@ func TestAll(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			mt := NewMockTestingT(t)
+			mt.EXPECT().Helper().Maybe()
 			result := All(tt.assertionFuncs...)(mt, errors.New("test error"))
 			assert.Equal(t, tt.expectResult, result)
 		})
@@ -562,3 +584,35 @@ func TestFail(t *testing.T) {
 		})
 	}
 }
+
+var _ (assert.TestingT) = (*testifyAssertTestingTMock)(nil)
+
+type testifyAssertTestingTMock struct {
+	mock.Mock
+}
+
+func (m *testifyAssertTestingTMock) Errorf(format string, args ...any) {
+	if len(args) > 0 {
+		m.Called(format, args)
+	} else {
+		m.Called(format)
+	}
+}
+
+var _ (require.TestingT) = (*testifyRequireTestingTMock)(nil)
+
+type testifyRequireTestingTMock struct {
+	mock.Mock
+}
+
+func (m *testifyRequireTestingTMock) Errorf(format string, args ...any) {
+	if len(args) > 0 {
+		m.Called(format, args)
+	} else {
+		m.Called(format)
+	}
+}
+
+func (m *testifyRequireTestingTMock) FailNow() {
+	m.Called()
+}