From d668b0317534d4bb4b5e6dbc0baec9d5463915c5 Mon Sep 17 00:00:00 2001 From: yusing Date: Thu, 24 Apr 2025 15:09:46 +0800 Subject: [PATCH] fix: tests --- internal/gperr/error_test.go | 77 ++++++++++++++++---------------- internal/gperr/multiline_test.go | 15 ++----- internal/gperr/subject.go | 7 ++- internal/gperr/utils.go | 24 +++++----- 4 files changed, 57 insertions(+), 66 deletions(-) diff --git a/internal/gperr/error_test.go b/internal/gperr/error_test.go index 81d0139..a14527f 100644 --- a/internal/gperr/error_test.go +++ b/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) - ExpectEqual(t, withSubject.Error(), "foo: error") - ExpectTrue(t, withSubject.Is(err)) + expect.ErrorIs(t, err, withSubject) + expect.Equal(t, ansi.StripANSI(withSubject.Error()), "foo: error") + expect.True(t, withSubject.Is(err)) - ExpectError(t, err, withSubjectf) - ExpectEqual(t, withSubjectf.Error(), "foo bar: error") - ExpectTrue(t, withSubjectf.Is(err)) + expect.ErrorIs(t, err, withSubjectf) + expect.Equal(t, ansi.StripANSI(withSubjectf.Error()), "foo bar: error") + 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)) - ExpectTrue(t, withExtra.Is(err)) + expect.True(t, withExtra.Is(extra)) + expect.True(t, withExtra.Is(err)) - ExpectTrue(t, errors.Is(withExtra, extra)) - ExpectTrue(t, errors.Is(withExtra, err)) + expect.True(t, errors.Is(withExtra, extra)) + expect.True(t, errors.Is(withExtra, err)) - ExpectTrue(t, strings.Contains(withExtra.Error(), err.Error())) - ExpectTrue(t, strings.Contains(withExtra.Error(), extra.Error())) - ExpectTrue(t, strings.Contains(withExtra.Error(), "baz")) + expect.True(t, strings.Contains(withExtra.Error(), err.Error())) + expect.True(t, strings.Contains(withExtra.Error(), extra.Error())) + 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) - ExpectError(t, err2, wrapped) - ExpectEqual(t, len(unwrapper.Unwrap()), 2) + expect.ErrorIs(t, err, wrapped) + expect.ErrorIs(t, err2, wrapped) + 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)) - ExpectFalse(t, err.Is(New("error"))) + expect.True(t, err.Is(from)) + expect.False(t, err.Is(New("error"))) - ExpectTrue(t, errors.Is(err.Subject("foo"), from)) - ExpectTrue(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"), from)) + expect.True(t, errors.Is(err.Withf("foo"), 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")) - ExpectFalse(t, err.Is(err2)) + expect.False(t, strings.Contains(err.Error(), "extra")) + 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)) - ExpectTrue(t, err3.Is(err2)) + expect.True(t, err3.Is(err1)) + expect.True(t, err3.Is(err2)) _ = err2.Subject("foo") - ExpectTrue(t, err3.Is(err1)) - ExpectTrue(t, err3.Is(err2)) + expect.True(t, err3.Is(err1)) + 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) } diff --git a/internal/gperr/multiline_test.go b/internal/gperr/multiline_test.go index 8fb3a83..af87b85 100644 --- a/internal/gperr/multiline_test.go +++ b/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)) } diff --git a/internal/gperr/subject.go b/internal/gperr/subject.go index ffec455..1ef550c 100644 --- a/internal/gperr/subject.go +++ b/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)) - for i, s := range err.Subjects { - subjects[len(err.Subjects)-i-1] = s - } + subjects := slices.Clone(err.Subjects) + slices.Reverse(subjects) reversed := struct { Subjects []string `json:"subjects"` Err error `json:"err"` diff --git a/internal/gperr/utils.go b/internal/gperr/utils.go index 5c0776d..fb98d6e 100644 --- a/internal/gperr/utils.go +++ b/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: