diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 9c7943f..6c44d3d 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -7,12 +7,16 @@ on: jobs: test-project: - runs-on: ubuntu-20.04 + runs-on: ubuntu-latest steps: + - run: uname -a + - run: lsb_release -a + - name: Setup uses: actions/setup-go@v4 with: - go-version: "1.21" + go-version: "1.25" + - run: go version - name: Checkout diff --git a/HISTORY.md b/HISTORY.md index 693472a..9e3b1f8 100644 --- a/HISTORY.md +++ b/HISTORY.md @@ -1,5 +1,11 @@ ## ✒ 历史版本的特性介绍 (Features in old versions) +### v0.8.0 + +> 此版本发布于 2026-01-26 + +* 废弃 Match 类函数，提供 Is 类函数 + ### v0.7.2 > 此版本发布于 2024-08-21 diff --git a/README.en.md b/README.en.md index 5393f45..6d49692 100644 --- a/README.en.md +++ b/README.en.md @@ -54,16 +54,13 @@ func main() { berr := errors.BadRequest("id is wrong") ferr := errors.Forbidden("user isn't allowed") nerr := errors.NotFound("book not found") - rerr := errors.RequireLogin("user requires login") - fmt.Printf("%+v\n%+v\n%+v\n%+v\n", berr, ferr, nerr, rerr) - - isBadRequest := errors.MatchBadRequest(berr) - isForbidden := errors.MatchForbidden(ferr) - isNotFound := errors.MatchNotFound(nerr) - isRequireLogin := errors.MatchRequireLogin(rerr) - fmt.Printf("isBadRequest: %+v\nisForbidden: %+v\nisNotFound: %+v\nisRequireLogin: %+v\n", isBadRequest, isForbidden, isNotFound, isRequireLogin) -} + fmt.Printf("%+v\n%+v\n%+v\n", berr, ferr, nerr) + isBadRequest := errors.IsBadRequest(berr) + isForbidden := errors.IsForbidden(ferr) + isNotFound := errors.IsNotFound(nerr) + fmt.Printf("isBadRequest: %+v\nisForbidden: %+v\nisNotFound: %+v\n", isBadRequest, isForbidden, isNotFound) +} ``` * [basic](_examples/basic.go) diff --git a/README.md b/README.md index 40d3f7c..f1e7f53 100644 --- a/README.md +++ b/README.md @@ -54,16 +54,13 @@ func main() { berr := errors.BadRequest("id is wrong") ferr := errors.Forbidden("user isn't allowed") nerr := errors.NotFound("book not found") - rerr := errors.RequireLogin("user requires login") - fmt.Printf("%+v\n%+v\n%+v\n%+v\n", berr, ferr, nerr, rerr) - - isBadRequest := errors.MatchBadRequest(berr) - isForbidden := errors.MatchForbidden(ferr) - isNotFound := errors.MatchNotFound(nerr) - isRequireLogin := errors.MatchRequireLogin(rerr) - fmt.Printf("isBadRequest: %+v\nisForbidden: %+v\nisNotFound: %+v\nisRequireLogin: %+v\n", isBadRequest, isForbidden, isNotFound, isRequireLogin) -} + fmt.Printf("%+v\n%+v\n%+v\n", berr, ferr, nerr) + isBadRequest := errors.IsBadRequest(berr) + isForbidden := errors.IsForbidden(ferr) + isNotFound := errors.IsNotFound(nerr) + fmt.Printf("isBadRequest: %+v\nisForbidden: %+v\nisNotFound: %+v\n", isBadRequest, isForbidden, isNotFound) +} ``` * [basic](_examples/basic.go) diff --git a/_examples/basic.go b/_examples/basic.go index b6b6c7a..83e6ff2 100644 --- a/_examples/basic.go +++ b/_examples/basic.go @@ -40,12 +40,10 @@ func main() { berr := errors.BadRequest("id is wrong") ferr := errors.Forbidden("user isn't allowed") nerr := errors.NotFound("book not found") - rerr := errors.RequireLogin("user requires login") - fmt.Printf("%+v\n%+v\n%+v\n%+v\n", berr, ferr, nerr, rerr) - - isBadRequest := errors.MatchBadRequest(berr) - isForbidden := errors.MatchForbidden(ferr) - isNotFound := errors.MatchNotFound(nerr) - isRequireLogin := errors.MatchRequireLogin(rerr) - fmt.Printf("isBadRequest: %+v\nisForbidden: %+v\nisNotFound: %+v\nisRequireLogin: %+v\n", isBadRequest, isForbidden, isNotFound, isRequireLogin) + fmt.Printf("%+v\n%+v\n%+v\n", berr, ferr, nerr) + + isBadRequest := errors.IsBadRequest(berr) + isForbidden := errors.IsForbidden(ferr) + isNotFound := errors.IsNotFound(nerr) + fmt.Printf("isBadRequest: %+v\nisForbidden: %+v\nisNotFound: %+v\n", isBadRequest, isForbidden, isNotFound) } diff --git a/_icons/coverage.svg b/_icons/coverage.svg index 7ec125b..a433fc7 100644 --- a/_icons/coverage.svg +++ b/_icons/coverage.svg @@ -10,7 +10,7 @@ coverage coverage - 91% - 91% + 87% + 87% \ No newline at end of file diff --git a/types.go b/types.go index c7cc3d0..4160279 100644 --- a/types.go +++ b/types.go @@ -5,10 +5,9 @@ package errors const ( - codeBadRequest = 400 - codeForbidden = 403 - codeNotFound = 404 - codeRequireLogin = 1000 + codeBadRequest = 400 + codeForbidden = 403 + codeNotFound = 404 ) // BadRequest returns *Error with bad request code. @@ -26,27 +25,35 @@ func NotFound(message string, args ...any) *Error { return Wrap(codeNotFound, message, args...) } -// RequireLogin returns *Error with require login code. -func RequireLogin(message string, args ...any) *Error { - return Wrap(codeRequireLogin, message, args...) +// IsBadRequest checks err with bad request code. +func IsBadRequest(err error) bool { + return IsCode(err, codeBadRequest) +} + +// IsForbidden checks err with forbidden code. +func IsForbidden(err error) bool { + return IsCode(err, codeForbidden) +} + +// IsNotFound checks err with not found code. +func IsNotFound(err error) bool { + return IsCode(err, codeNotFound) } // MatchBadRequest matches err with bad request code. +// Deprecated: Use IsBadRequest instead because this name is 'ugly' to me. func MatchBadRequest(err error) bool { - return Match(err, codeBadRequest) + return IsBadRequest(err) } // MatchForbidden matches err with forbidden code. +// Deprecated: Use IsForbidden instead because this name is 'ugly' to me. func MatchForbidden(err error) bool { - return Match(err, codeForbidden) + return IsForbidden(err) } // MatchNotFound matches err with not found code. +// Deprecated: Use IsNotFound instead because this name is 'ugly' to me. func MatchNotFound(err error) bool { - return Match(err, codeNotFound) -} - -// MatchRequireLogin matches err with require login code. -func MatchRequireLogin(err error) bool { - return Match(err, codeRequireLogin) + return IsNotFound(err) } diff --git a/types_test.go b/types_test.go index 06c9131..7fbddc4 100644 --- a/types_test.go +++ b/types_test.go @@ -126,48 +126,8 @@ func TestNotFound(t *testing.T) { } } -// go test -v -cover -count=1 -test.cpu=1 -run=^TestRequireLogin$ -func TestRequireLogin(t *testing.T) { - testCases := []struct { - message string - args []any - wantCode int32 - wantMessage string - }{ - { - message: "xxx", - args: nil, - wantCode: codeRequireLogin, - wantMessage: "xxx", - }, - { - message: "xxx %d%.2f", - args: nil, - wantCode: codeRequireLogin, - wantMessage: "xxx %d%.2f", - }, - { - message: "xxx %d%s%+v", - args: []any{1, ".", true}, - wantCode: codeRequireLogin, - wantMessage: "xxx 1.true", - }, - } - - for _, testCase := range testCases { - err := RequireLogin(testCase.message, testCase.args...) - if err.Code() != testCase.wantCode { - t.Errorf("err.Code() %d != testCase.wantCode %d", err.Code(), testCase.wantCode) - } - - if err.Message() != testCase.wantMessage { - t.Errorf("err.Message() %s != testCase.wantMessage %s", err.Message(), testCase.wantMessage) - } - } -} - -// go test -v -cover -count=1 -test.cpu=1 -run=^TestMatchBadRequest$ -func TestMatchBadRequest(t *testing.T) { +// go test -v -cover -count=1 -test.cpu=1 -run=^TestIsBadRequest$ +func TestIsBadRequest(t *testing.T) { testCases := []struct { message string }{ @@ -178,14 +138,14 @@ func TestMatchBadRequest(t *testing.T) { for _, testCase := range testCases { err := BadRequest(testCase.message) - if !MatchBadRequest(err) { - t.Errorf("err %+v not match code %d", err, err.Code()) + if !IsBadRequest(err) { + t.Errorf("err %+v not code %d", err, err.Code()) } } } -// go test -v -cover -count=1 -test.cpu=1 -run=^TestMatchForbidden$ -func TestMatchForbidden(t *testing.T) { +// go test -v -cover -count=1 -test.cpu=1 -run=^TestIsForbidden$ +func TestIsForbidden(t *testing.T) { testCases := []struct { message string }{ @@ -196,14 +156,14 @@ func TestMatchForbidden(t *testing.T) { for _, testCase := range testCases { err := Forbidden(testCase.message) - if !MatchForbidden(err) { - t.Errorf("err %+v not match code %d", err, err.Code()) + if !IsForbidden(err) { + t.Errorf("err %+v not code %d", err, err.Code()) } } } -// go test -v -cover -count=1 -test.cpu=1 -run=^TestMatchNotFound$ -func TestMatchNotFound(t *testing.T) { +// go test -v -cover -count=1 -test.cpu=1 -run=^TestIsNotFound$ +func TestIsNotFound(t *testing.T) { testCases := []struct { message string }{ @@ -214,26 +174,8 @@ func TestMatchNotFound(t *testing.T) { for _, testCase := range testCases { err := NotFound(testCase.message) - if !MatchNotFound(err) { - t.Errorf("err %+v not match code %d", err, err.Code()) - } - } -} - -// go test -v -cover -count=1 -test.cpu=1 -run=^TestMatchRequireLogin$ -func TestMatchRequireLogin(t *testing.T) { - testCases := []struct { - message string - }{ - { - message: "xxx", - }, - } - - for _, testCase := range testCases { - err := RequireLogin(testCase.message) - if !MatchRequireLogin(err) { - t.Errorf("err %+v not match code %d", err, err.Code()) + if !IsNotFound(err) { + t.Errorf("err %+v not code %d", err, err.Code()) } } } diff --git a/unwrap.go b/unwrap.go index 023604c..fc6d0b1 100644 --- a/unwrap.go +++ b/unwrap.go @@ -67,8 +67,8 @@ func CodeMessage(err error, defaultCode int32, defaultMessage string, args ...an return code, message } -// Match unwraps error and check if its code equals to code. -func Match(err error, code int32) bool { +// IsCode unwraps error and check if its code equals to code. +func IsCode(err error, code int32) bool { if err == nil { return code == 0 } @@ -87,3 +87,9 @@ func Match(err error, code int32) bool { return false } + +// Match unwraps error and check if its code equals to code. +// Deprecated: Use IsCode instead because this name is 'ugly' to me. +func Match(err error, code int32) bool { + return IsCode(err, code) +} diff --git a/unwrap_test.go b/unwrap_test.go index 2b91bd9..50df301 100644 --- a/unwrap_test.go +++ b/unwrap_test.go @@ -193,51 +193,51 @@ func TestCodeMessage(t *testing.T) { } } -// go test -v -cover -count=1 -test.cpu=1 -run=^TestMatch$ -func TestMatch(t *testing.T) { +// go test -v -cover -count=1 -test.cpu=1 -run=^TestIsCode$ +func TestIsCode(t *testing.T) { testErr := &testError{} testCases := []struct { - err error - code int32 - match bool + err error + code int32 + is bool }{ { - err: nil, - code: 0, - match: true, + err: nil, + code: 0, + is: true, }, { - err: nil, - code: 999, - match: false, + err: nil, + code: 999, + is: false, }, { - err: io.EOF, - code: 999, - match: false, + err: io.EOF, + code: 999, + is: false, }, { - err: testErr, - code: testErr.Code(), - match: true, + err: testErr, + code: testErr.Code(), + is: true, }, { - err: Wrap(1000, "wow"), - code: 1000, - match: true, + err: Wrap(1000, "wow"), + code: 1000, + is: true, }, { - err: Wrap(1000, "eof").With(io.EOF), - code: 1000, - match: true, + err: Wrap(1000, "eof").With(io.EOF), + code: 1000, + is: true, }, } for _, testCase := range testCases { - match := Match(testCase.err, testCase.code) - if match != testCase.match { - t.Errorf("match %+v != testCase.match %+v", match, testCase.match) + is := IsCode(testCase.err, testCase.code) + if is != testCase.is { + t.Errorf("got %+v != want %+v", is, testCase.is) } } }