github.com/gnolang/gno@v0.0.0-20240520182011-228e9d0192ce/tm2/pkg/errors/errors_test.go (about)

     1  package errors
     2  
     3  import (
     4  	"errors"
     5  	fmt "fmt"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  )
    10  
    11  func TestErrorPanic(t *testing.T) {
    12  	t.Parallel()
    13  
    14  	type pnk struct {
    15  		msg string
    16  	}
    17  
    18  	capturePanic := func() (err Error) {
    19  		defer func() {
    20  			if r := recover(); r != nil {
    21  				err = Wrap(r, "This is the message in Wrap(r, message).")
    22  			}
    23  		}()
    24  		panic(pnk{"something"})
    25  	}
    26  
    27  	err := capturePanic()
    28  
    29  	assert.Equal(t, pnk{"something"}, err.Data())
    30  	assert.Equal(t, "{something}", fmt.Sprintf("%v", err))
    31  	assert.Contains(t, fmt.Sprintf("%#v", err), "This is the message in Wrap(r, message).")
    32  	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
    33  }
    34  
    35  func TestWrapSomething(t *testing.T) {
    36  	t.Parallel()
    37  
    38  	err := Wrap("something", "formatter%v%v", 0, 1)
    39  
    40  	assert.Equal(t, "something", err.Data())
    41  	assert.Equal(t, "something", fmt.Sprintf("%v", err))
    42  	assert.Regexp(t, `formatter01\n`, fmt.Sprintf("%#v", err))
    43  	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
    44  }
    45  
    46  func TestWrapNothing(t *testing.T) {
    47  	t.Parallel()
    48  
    49  	err := Wrap(nil, "formatter%v%v", 0, 1)
    50  
    51  	assert.Equal(t,
    52  		FmtError{"formatter%v%v", []interface{}{0, 1}},
    53  		err.Data())
    54  	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
    55  	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: errors.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
    56  	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
    57  }
    58  
    59  func TestErrorNew(t *testing.T) {
    60  	t.Parallel()
    61  
    62  	err := New("formatter%v%v", 0, 1)
    63  
    64  	assert.Equal(t,
    65  		FmtError{"formatter%v%v", []interface{}{0, 1}},
    66  		err.Data())
    67  	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
    68  	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: errors.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
    69  	assert.NotContains(t, fmt.Sprintf("%#v", err), "Stack Trace")
    70  }
    71  
    72  func TestErrorNewWithDetails(t *testing.T) {
    73  	t.Parallel()
    74  
    75  	err := New("formatter%v%v", 0, 1)
    76  	err.Trace(0, "trace %v", 1)
    77  	err.Trace(0, "trace %v", 2)
    78  	err.Trace(0, "trace %v", 3)
    79  	assert.Contains(t, fmt.Sprintf("%+v", err), `Data: formatter01`)
    80  	assert.Contains(t, fmt.Sprintf("%+v", err), "Msg Traces:\n    0")
    81  }
    82  
    83  func TestErrorNewWithStacktrace(t *testing.T) {
    84  	t.Parallel()
    85  
    86  	err := New("formatter%v%v", 0, 1).Stacktrace()
    87  
    88  	assert.Equal(t,
    89  		FmtError{"formatter%v%v", []interface{}{0, 1}},
    90  		err.Data())
    91  	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
    92  	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: errors.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
    93  	assert.Contains(t, fmt.Sprintf("%#v", err), "Stack Trace:\n    0")
    94  }
    95  
    96  func TestErrorNewWithTrace(t *testing.T) {
    97  	t.Parallel()
    98  
    99  	err := New("formatter%v%v", 0, 1)
   100  	err.Trace(0, "trace %v", 1)
   101  	err.Trace(0, "trace %v", 2)
   102  	err.Trace(0, "trace %v", 3)
   103  
   104  	assert.Equal(t,
   105  		FmtError{"formatter%v%v", []interface{}{0, 1}},
   106  		err.Data())
   107  	assert.Equal(t, "formatter01", fmt.Sprintf("%v", err))
   108  	assert.Contains(t, fmt.Sprintf("%#v", err), `Data: errors.FmtError{format:"formatter%v%v", args:[]interface {}{0, 1}}`)
   109  	dump := fmt.Sprintf("%#v", err)
   110  	assert.NotContains(t, dump, "Stack Trace")
   111  	assert.Regexp(t, `errors/errors_test\.go:[0-9]+ - trace 1`, dump)
   112  	assert.Regexp(t, `errors/errors_test\.go:[0-9]+ - trace 2`, dump)
   113  	assert.Regexp(t, `errors/errors_test\.go:[0-9]+ - trace 3`, dump)
   114  }
   115  
   116  func TestWrapError(t *testing.T) {
   117  	t.Parallel()
   118  
   119  	var err1 error = New("my message")
   120  	var err2 error = Wrap(err1, "another message")
   121  	assert.Equal(t, err1, err2)
   122  	assert.True(t, errors.Is(err2, err1))
   123  
   124  	err1 = fmt.Errorf("my message")
   125  	err2 = Wrap(err1, "another message")
   126  	assert.NotEqual(t, err1, err2)
   127  	assert.True(t, errors.Is(err2, err1))
   128  }