fix: tests

internal/gperr/error_test.go

@@ -5,11 +5,12 @@ import (
 	"strings"
 	"testing"
 
-	. "github.com/yusing/go-proxy/internal/utils/testing"
+	"github.com/yusing/go-proxy/internal/utils/strutils/ansi"
+	expect "github.com/yusing/go-proxy/internal/utils/testing"
 )
 
 func TestBaseString(t *testing.T) {
-	ExpectEqual(t, New("error").Error(), "error")
+	expect.Equal(t, New("error").Error(), "error")
 }
 
 func TestBaseWithSubject(t *testing.T) {
@@ -17,13 +18,13 @@ func TestBaseWithSubject(t *testing.T) {
 	withSubject := err.Subject("foo")
 	withSubjectf := err.Subjectf("%s %s", "foo", "bar")
 
-	ExpectError(t, err, withSubject)
+	expect.ErrorIs(t, err, withSubject)
-	ExpectEqual(t, withSubject.Error(), "foo: error")
+	expect.Equal(t, ansi.StripANSI(withSubject.Error()), "foo: error")
-	ExpectTrue(t, withSubject.Is(err))
+	expect.True(t, withSubject.Is(err))
 
-	ExpectError(t, err, withSubjectf)
+	expect.ErrorIs(t, err, withSubjectf)
-	ExpectEqual(t, withSubjectf.Error(), "foo bar: error")
+	expect.Equal(t, ansi.StripANSI(withSubjectf.Error()), "foo bar: error")
-	ExpectTrue(t, withSubjectf.Is(err))
+	expect.True(t, withSubjectf.Is(err))
 }
 
 func TestBaseWithExtra(t *testing.T) {
@@ -31,22 +32,22 @@ func TestBaseWithExtra(t *testing.T) {
 	extra := New("bar").Subject("baz")
 	withExtra := err.With(extra)
 
-	ExpectTrue(t, withExtra.Is(extra))
+	expect.True(t, withExtra.Is(extra))
-	ExpectTrue(t, withExtra.Is(err))
+	expect.True(t, withExtra.Is(err))
 
-	ExpectTrue(t, errors.Is(withExtra, extra))
+	expect.True(t, errors.Is(withExtra, extra))
-	ExpectTrue(t, errors.Is(withExtra, err))
+	expect.True(t, errors.Is(withExtra, err))
 
-	ExpectTrue(t, strings.Contains(withExtra.Error(), err.Error()))
+	expect.True(t, strings.Contains(withExtra.Error(), err.Error()))
-	ExpectTrue(t, strings.Contains(withExtra.Error(), extra.Error()))
+	expect.True(t, strings.Contains(withExtra.Error(), extra.Error()))
-	ExpectTrue(t, strings.Contains(withExtra.Error(), "baz"))
+	expect.True(t, strings.Contains(withExtra.Error(), "baz"))
 }
 
 func TestBaseUnwrap(t *testing.T) {
 	err := errors.New("err")
 	wrapped := Wrap(err)
 
-	ExpectError(t, err, errors.Unwrap(wrapped))
+	expect.ErrorIs(t, err, errors.Unwrap(wrapped))
 }
 
 func TestNestedUnwrap(t *testing.T) {
@@ -55,24 +56,24 @@ func TestNestedUnwrap(t *testing.T) {
 	wrapped := Wrap(err).Subject("foo").With(err2.Subject("bar"))
 
 	unwrapper, ok := wrapped.(interface{ Unwrap() []error })
-	ExpectTrue(t, ok)
+	expect.True(t, ok)
 
-	ExpectError(t, err, wrapped)
+	expect.ErrorIs(t, err, wrapped)
-	ExpectError(t, err2, wrapped)
+	expect.ErrorIs(t, err2, wrapped)
-	ExpectEqual(t, len(unwrapper.Unwrap()), 2)
+	expect.Equal(t, len(unwrapper.Unwrap()), 2)
 }
 
 func TestErrorIs(t *testing.T) {
 	from := errors.New("error")
 	err := Wrap(from)
-	ExpectError(t, from, err)
+	expect.ErrorIs(t, from, err)
 
-	ExpectTrue(t, err.Is(from))
+	expect.True(t, err.Is(from))
-	ExpectFalse(t, err.Is(New("error")))
+	expect.False(t, err.Is(New("error")))
 
-	ExpectTrue(t, errors.Is(err.Subject("foo"), from))
+	expect.True(t, errors.Is(err.Subject("foo"), from))
-	ExpectTrue(t, errors.Is(err.Withf("foo"), from))
+	expect.True(t, errors.Is(err.Withf("foo"), from))
-	ExpectTrue(t, errors.Is(err.Subject("foo").Withf("bar"), from))
+	expect.True(t, errors.Is(err.Subject("foo").Withf("bar"), from))
 }
 
 func TestErrorImmutability(t *testing.T) {
@@ -82,14 +83,14 @@ func TestErrorImmutability(t *testing.T) {
 	for range 3 {
 		// t.Logf("%d: %v %T %s", i, errors.Unwrap(err), err, err)
 		_ = err.Subject("foo")
-		ExpectFalse(t, strings.Contains(err.Error(), "foo"))
+		expect.False(t, strings.Contains(err.Error(), "foo"))
 
 		_ = err.With(err2)
-		ExpectFalse(t, strings.Contains(err.Error(), "extra"))
+		expect.False(t, strings.Contains(err.Error(), "extra"))
-		ExpectFalse(t, err.Is(err2))
+		expect.False(t, err.Is(err2))
 
 		err = err.Subject("bar").Withf("baz")
-		ExpectTrue(t, err != nil)
+		expect.True(t, err != nil)
 	}
 }
 
@@ -99,24 +100,24 @@ func TestErrorWith(t *testing.T) {
 
 	err3 := err1.With(err2)
 
-	ExpectTrue(t, err3.Is(err1))
+	expect.True(t, err3.Is(err1))
-	ExpectTrue(t, err3.Is(err2))
+	expect.True(t, err3.Is(err2))
 
 	_ = err2.Subject("foo")
 
-	ExpectTrue(t, err3.Is(err1))
+	expect.True(t, err3.Is(err1))
-	ExpectTrue(t, err3.Is(err2))
+	expect.True(t, err3.Is(err2))
 
 	// check if err3 is affected by err2.Subject
-	ExpectFalse(t, strings.Contains(err3.Error(), "foo"))
+	expect.False(t, strings.Contains(err3.Error(), "foo"))
 }
 
 func TestErrorStringSimple(t *testing.T) {
 	errFailure := New("generic failure")
 	ne := errFailure.Subject("foo bar")
-	ExpectEqual(t, ne.Error(), "foo bar: generic failure")
+	expect.Equal(t, ansi.StripANSI(ne.Error()), "foo bar: generic failure")
 	ne = ne.Subject("baz")
-	ExpectEqual(t, ne.Error(), "baz > foo bar: generic failure")
+	expect.Equal(t, ansi.StripANSI(ne.Error()), "baz > foo bar: generic failure")
 }
 
 func TestErrorStringNested(t *testing.T) {
@@ -153,5 +154,5 @@ func TestErrorStringNested(t *testing.T) {
       • action 3 > inner3: generic failure
         • 3
         • 3`
-	ExpectEqual(t, ne.Error(), want)
+	expect.Equal(t, ansi.StripANSI(ne.Error()), want)
 }

internal/gperr/multiline_test.go

@@ -4,18 +4,9 @@ import (
 	"net"
 	"testing"
 
-	"github.com/stretchr/testify/require"
+	expect "github.com/yusing/go-proxy/internal/utils/testing"
 )
 
-func TestMultiline(t *testing.T) {
-	multiline := Multiline()
-	multiline.Addf("line 1 %s", "test")
-	multiline.Adds("line 2")
-	multiline.AddLines([]any{1, "2", 3.0, net.IPv4(127, 0, 0, 1)})
-	t.Error(New("result").With(multiline))
-	t.Error(multiline.Subject("subject").Withf("inner"))
-}
-
 func TestWrapMultiline(t *testing.T) {
 	multiline := Multiline()
 	var wrapper error = wrap(multiline)
@@ -32,7 +23,7 @@ func TestPrependSubjectMultiline(t *testing.T) {
 	multiline.AddLines([]any{1, "2", 3.0, net.IPv4(127, 0, 0, 1)})
 	multiline.Subject("subject")
 
-	builder := NewBuilder("")
+	builder := NewBuilder()
 	builder.Add(multiline)
-	require.Equal(t, len(builder.errs), len(multiline.Extras), builder.errs)
+	expect.Equal(t, len(multiline.Extras), len(builder.errs))
 }

internal/gperr/subject.go

@@ -3,6 +3,7 @@ package gperr
 import (
 	"encoding/json"
 	"errors"
+	"slices"
 	"strings"
 
 	"github.com/yusing/go-proxy/internal/utils/strutils/ansi"
@@ -90,10 +91,8 @@ func (err *withSubject) Error() string {
 
 // MarshalJSON implements the json.Marshaler interface.
 func (err *withSubject) MarshalJSON() ([]byte, error) {
-	subjects := make([]string, len(err.Subjects))
+	subjects := slices.Clone(err.Subjects)
-	for i, s := range err.Subjects {
+	slices.Reverse(subjects)
-		subjects[len(err.Subjects)-i-1] = s
-	}
 	reversed := struct {
 		Subjects []string `json:"subjects"`
 		Err      error    `json:"err"`

internal/gperr/utils.go

@@ -41,18 +41,6 @@ func Wrap(err error, message ...string) Error {
 	return &baseError{fmt.Errorf("%s: %w", message[0], err)}
 }
 
-func wrap(err error) Error {
-	if err == nil {
-		return nil
-	}
-	//nolint:errorlint
-	switch err := err.(type) {
-	case Error:
-		return err
-	}
-	return &baseError{err}
-}
-
 func Unwrap(err error) Error {
 	//nolint:errorlint
 	switch err := err.(type) {
@@ -65,6 +53,18 @@ func Unwrap(err error) Error {
 	}
 }
 
+func wrap(err error) Error {
+	if err == nil {
+		return nil
+	}
+	//nolint:errorlint
+	switch err := err.(type) {
+	case Error:
+		return err
+	}
+	return &baseError{err}
+}
+
 func IsJSONMarshallable(err error) bool {
 	switch err := err.(type) {
 	case *nestedError, *withSubject: