github.com/sohaha/zlsgo@v1.7.13-0.20240501141223-10dd1a906f76/zerror/error_test.go (about)

     1  package zerror_test
     2  
     3  import (
     4  	"errors"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/sohaha/zlsgo"
     9  	"github.com/sohaha/zlsgo/zerror"
    10  )
    11  
    12  const (
    13  	ErrCode200 = zerror.ErrCode(200)
    14  	ErrCode500 = zerror.ErrCode(500)
    15  	ErrCode404 = zerror.ErrCode(404)
    16  	ErrCode401 = zerror.ErrCode(401)
    17  )
    18  
    19  func TestError(t *testing.T) {
    20  	tt := zlsgo.NewTest(t)
    21  
    22  	err500 := zerror.New(ErrCode500, "The is 500")
    23  
    24  	var (
    25  		err404 error
    26  		err401 error
    27  	)
    28  	tt.Run("Wrap", func(tt *zlsgo.TestUtil) {
    29  		err404 = zerror.Wrap(err500, ErrCode404, "The is 404")
    30  		t.Log(err404)
    31  		err401 = zerror.Wrap(err404, ErrCode401, "The is 401")
    32  		t.Log(err401)
    33  	})
    34  
    35  	tt.Run("Is", func(tt *zlsgo.TestUtil) {
    36  		tt.EqualTrue(zerror.Is(err401, ErrCode401))
    37  		tt.EqualTrue(zerror.Is(err401, ErrCode404))
    38  		tt.EqualTrue(zerror.Is(err401, ErrCode500))
    39  		tt.EqualTrue(!zerror.Is(err401, ErrCode200))
    40  	})
    41  
    42  	var (
    43  		rawErr401     error
    44  		rawErr404     error
    45  		rawErr500     error
    46  		rawErr404T500 error
    47  		ok            bool
    48  	)
    49  
    50  	tt.Run("Unwrap", func(tt *zlsgo.TestUtil) {
    51  		rawErr401, ok = zerror.Unwrap(err401, ErrCode401)
    52  		tt.Equal(err401.Error(), rawErr401.Error())
    53  
    54  		rawErr404, ok = zerror.Unwrap(err401, ErrCode404)
    55  		tt.EqualTrue(ok)
    56  		tt.Equal(err404.Error(), rawErr404.Error())
    57  
    58  		rawErr500, ok = zerror.Unwrap(err401, ErrCode500)
    59  		tt.EqualTrue(ok)
    60  		tt.Equal(err500.Error(), rawErr500.Error())
    61  
    62  		rawErr404T500, ok := zerror.Unwrap(err404, ErrCode500)
    63  		tt.EqualTrue(ok)
    64  		tt.Equal(err500.Error(), rawErr404T500.Error())
    65  
    66  		rawErr401T404, ok := zerror.Unwrap(err401, ErrCode404)
    67  		tt.EqualTrue(ok)
    68  		tt.Equal(err404.Error(), rawErr401T404.Error())
    69  
    70  		rawErr404T401, ok := zerror.Unwrap(err404, ErrCode401)
    71  		tt.EqualTrue(!ok)
    72  		tt.EqualNil(rawErr404T401)
    73  	})
    74  
    75  	tt.Run("UnwrapCode", func(tt *zlsgo.TestUtil) {
    76  		code, ok := zerror.UnwrapCode(rawErr404T500)
    77  		tt.Equal(zerror.ErrCode(0), code)
    78  		tt.EqualTrue(!ok)
    79  
    80  		code, ok = zerror.UnwrapCode(err500)
    81  		tt.Equal(ErrCode500, code)
    82  		tt.EqualTrue(ok)
    83  
    84  		code, ok = zerror.UnwrapCode(err404)
    85  		tt.Equal(ErrCode404, code)
    86  		tt.EqualTrue(ok)
    87  
    88  		code, ok = zerror.UnwrapCode(err401)
    89  		tt.Equal(ErrCode401, code)
    90  		tt.EqualTrue(ok)
    91  	})
    92  
    93  	tt.Run("UnwrapCodes", func(tt *zlsgo.TestUtil) {
    94  		tt.Equal([]zerror.ErrCode{ErrCode401, ErrCode404, ErrCode500}, zerror.UnwrapCodes(err401))
    95  		tt.Equal([]zerror.ErrCode{ErrCode404, ErrCode500}, zerror.UnwrapCodes(err404))
    96  		tt.Equal([]zerror.ErrCode{ErrCode500}, zerror.UnwrapCodes(err500))
    97  	})
    98  
    99  	tt.Run("UnwrapErrors", func(tt *zlsgo.TestUtil) {
   100  		errs := zerror.UnwrapErrors(err401)
   101  		t.Log(strings.Join(errs, ", "))
   102  		tt.Equal([]string{err401.Error(), err404.Error(), err500.Error()}, errs)
   103  		tt.Equal([]string{err404.Error(), err500.Error()}, zerror.UnwrapErrors(err404))
   104  		tt.Equal([]string{err500.Error()}, zerror.UnwrapErrors(err500))
   105  	})
   106  }
   107  
   108  func TestRawErr(t *testing.T) {
   109  	err := errors.New("is error")
   110  	err = zerror.Reuse(err)
   111  	err = zerror.Wrap(err, -1, "The is Wrap")
   112  
   113  	t.Log(err)
   114  	t.Logf("%+v", err)
   115  
   116  	err = errors.New("is error")
   117  	err = zerror.Wrap(err, -1, "The is Wrap")
   118  
   119  	t.Log(err)
   120  	t.Logf("%+v", err)
   121  
   122  	err = errors.New("is error")
   123  	err = zerror.SupText(err, "The is Wrap")
   124  
   125  	t.Log(err)
   126  	t.Logf("%+v", err)
   127  
   128  	err = zerror.New(-1, "is error")
   129  	err = zerror.SupText(err, "The is Wrap")
   130  
   131  	t.Log(err)
   132  	t.Logf("%+v", err)
   133  }
   134  
   135  func TestFirst(t *testing.T) {
   136  	tt := zlsgo.NewTest(t)
   137  	err := zerror.Wrap(errors.New("original"), ErrCode401, "The is 401")
   138  	err = zerror.Wrap(err, ErrCode404, "404")
   139  	err = zerror.Wrap(err, ErrCode500, "500")
   140  
   141  	ferr := zerror.UnwrapFirst(err)
   142  	tt.Equal("original", ferr.Error())
   143  	fcode := zerror.UnwrapFirstCode(err)
   144  	tt.Equal(ErrCode401, fcode)
   145  }