http3: migrate the error tests away from Ginkgo (#4876)

http3/error_codes_test.go

@@ -7,33 +7,31 @@ import (
 	"path"
 	"runtime"
 	"strconv"
+	"testing"
 
-	. "github.com/onsi/ginkgo/v2"
+	"github.com/stretchr/testify/require"
-	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("error codes", func() {
+func TestErrorCodes(t *testing.T) {
-	It("has a string representation for every error code", func() {
 	// We parse the error code file, extract all constants, and verify that
 	// each of them has a string version. Go FTW!
 	_, thisfile, _, ok := runtime.Caller(0)
-		if !ok {
+	require.True(t, ok, "Failed to get current frame")
-			panic("Failed to get current frame")
+
-		}
 	filename := path.Join(path.Dir(thisfile), "error_codes.go")
 	fileAst, err := parser.ParseFile(token.NewFileSet(), filename, nil, 0)
-		Expect(err).NotTo(HaveOccurred())
+	require.NoError(t, err)
+
 	constSpecs := fileAst.Decls[2].(*ast.GenDecl).Specs
-		Expect(len(constSpecs)).To(BeNumerically(">", 4)) // at time of writing
+	require.Greater(t, len(constSpecs), 4) // at time of writing
+
 	for _, c := range constSpecs {
 		valString := c.(*ast.ValueSpec).Values[0].(*ast.BasicLit).Value
 		val, err := strconv.ParseInt(valString, 0, 64)
-			Expect(err).NotTo(HaveOccurred())
+		require.NoError(t, err)
-			Expect(ErrCode(val).String()).ToNot(Equal("unknown error code"))
+		require.NotEqual(t, "unknown error code", ErrCode(val).String())
 	}
-	})
 
-	It("has a string representation for unknown error codes", func() {
+	// Test unknown error code
-		Expect(ErrCode(0x1337).String()).To(Equal("unknown error code: 0x1337"))
+	require.Equal(t, "unknown error code: 0x1337", ErrCode(0x1337).String())
-	})
+}
-})

http3/error_test.go

@@ -2,40 +2,88 @@ package http3
 
 import (
 	"errors"
+	"testing"
 
 	"github.com/quic-go/quic-go"
 
-	. "github.com/onsi/ginkgo/v2"
+	"github.com/stretchr/testify/require"
-	. "github.com/onsi/gomega"
 )
 
-var _ = Describe("HTTP/3 errors", func() {
+func TestErrorConversion(t *testing.T) {
-	It("converts", func() {
+	regularErr := errors.New("foobar")
-		Expect(maybeReplaceError(nil)).To(BeNil())
-		Expect(maybeReplaceError(errors.New("foobar"))).To(MatchError("foobar"))
-		Expect(maybeReplaceError(&quic.StreamError{
-			ErrorCode: 1337,
-			Remote:    true,
-		})).To(Equal(&Error{
-			Remote:    true,
-			ErrorCode: 1337,
-		}))
-		Expect(maybeReplaceError(&quic.ApplicationError{
-			ErrorCode:    42,
-			Remote:       true,
-			ErrorMessage: "foobar",
-		})).To(Equal(&Error{
-			Remote:       true,
-			ErrorCode:    42,
-			ErrorMessage: "foobar",
-		}))
-	})
 
-	It("has a string representation", func() {
+	tests := []struct {
-		Expect((&Error{ErrorCode: 0x10c, Remote: true}).Error()).To(Equal("H3_REQUEST_CANCELLED"))
+		name     string
-		Expect((&Error{ErrorCode: 0x10c, Remote: true, ErrorMessage: "foobar"}).Error()).To(Equal("H3_REQUEST_CANCELLED: foobar"))
+		input    error
-		Expect((&Error{ErrorCode: 0x10c, Remote: false}).Error()).To(Equal("H3_REQUEST_CANCELLED (local)"))
+		expected error
-		Expect((&Error{ErrorCode: 0x10c, Remote: false, ErrorMessage: "foobar"}).Error()).To(Equal("H3_REQUEST_CANCELLED (local): foobar"))
+	}{
-		Expect((&Error{ErrorCode: 0x1337, Remote: true}).Error()).To(Equal("H3 error (0x1337)"))
+		{name: "nil error", input: nil, expected: nil},
+		{name: "regular error", input: regularErr, expected: regularErr},
+		{
+			name:     "stream error",
+			input:    &quic.StreamError{ErrorCode: 1337, Remote: true},
+			expected: &Error{Remote: true, ErrorCode: 1337},
+		},
+		{
+			name:     "application error",
+			input:    &quic.ApplicationError{ErrorCode: 42, Remote: true, ErrorMessage: "foobar"},
+			expected: &Error{Remote: true, ErrorCode: 42, ErrorMessage: "foobar"},
+		},
+		{
+			name:     "transport error",
+			input:    &quic.TransportError{ErrorCode: 42, Remote: true, ErrorMessage: "foobar"},
+			expected: &quic.TransportError{ErrorCode: 42, Remote: true, ErrorMessage: "foobar"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := maybeReplaceError(tt.input)
+			if tt.expected == nil {
+				require.Nil(t, result)
+			} else {
+				require.ErrorIs(t, tt.expected, result)
+			}
 		})
-})
+	}
+}
+
+func TestErrorString(t *testing.T) {
+	tests := []struct {
+		name     string
+		err      *Error
+		expected string
+	}{
+		{
+			name:     "remote error",
+			err:      &Error{ErrorCode: 0x10c, Remote: true},
+			expected: "H3_REQUEST_CANCELLED",
+		},
+		{
+			name:     "remote error with message",
+			err:      &Error{ErrorCode: 0x10c, Remote: true, ErrorMessage: "foobar"},
+			expected: "H3_REQUEST_CANCELLED: foobar",
+		},
+		{
+			name:     "local error",
+			err:      &Error{ErrorCode: 0x10c, Remote: false},
+			expected: "H3_REQUEST_CANCELLED (local)",
+		},
+		{
+			name:     "local error with message",
+			err:      &Error{ErrorCode: 0x10c, Remote: false, ErrorMessage: "foobar"},
+			expected: "H3_REQUEST_CANCELLED (local): foobar",
+		},
+		{
+			name:     "unknown error code",
+			err:      &Error{ErrorCode: 0x1337, Remote: true},
+			expected: "H3 error (0x1337)",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			require.Equal(t, tt.expected, tt.err.Error())
+		})
+	}
+}