github.com/sttk/sabi@v0.5.0/err_test.go (about)

     1  package sabi_test
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/sttk/sabi"
    10  )
    11  
    12  type /* error reasons */ (
    13  	InvalidValue struct {
    14  		Value string
    15  	}
    16  	FailToGetValue struct {
    17  		Name string
    18  	}
    19  )
    20  
    21  type InvalidValueError struct {
    22  	Value string
    23  }
    24  
    25  func (e InvalidValueError) Error() string {
    26  	return "InvalidValue{Value=" + e.Value + "}"
    27  }
    28  
    29  func TestNewErr_reasonIsValue(t *testing.T) {
    30  	err := sabi.NewErr(InvalidValue{Value: "abc"})
    31  
    32  	assert.Equal(t, err.Error(), "{reason=InvalidValue, Value=abc}")
    33  
    34  	switch err.Reason().(type) {
    35  	case InvalidValue:
    36  	default:
    37  		assert.Fail(t, err.Error())
    38  	}
    39  
    40  	assert.False(t, err.IsOk())
    41  	assert.True(t, err.IsNotOk())
    42  	assert.Equal(t, err.ReasonName(), "InvalidValue")
    43  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi_test")
    44  	assert.Equal(t, err.Get("Value"), "abc")
    45  	assert.Nil(t, err.Get("value"))
    46  	assert.Nil(t, err.Get("Name"))
    47  
    48  	m := err.Situation()
    49  	assert.Equal(t, len(m), 1)
    50  	assert.Equal(t, m["Value"], "abc")
    51  	assert.Nil(t, m["value"])
    52  
    53  	assert.Nil(t, err.Cause())
    54  	assert.Nil(t, err.Unwrap())
    55  	assert.Nil(t, errors.Unwrap(err))
    56  
    57  	assert.True(t, errors.Is(err, err))
    58  	assert.True(t, errors.As(err, &err))
    59  
    60  	e := InvalidValueError{Value: "aaa"}
    61  	assert.False(t, errors.Is(err, e))
    62  	assert.False(t, errors.As(err, &e))
    63  }
    64  
    65  func TestNewErr_reasonIsPointer(t *testing.T) {
    66  	err := sabi.NewErr(&InvalidValue{Value: "abc"})
    67  
    68  	assert.Equal(t, err.Error(), "{reason=InvalidValue, Value=abc}")
    69  
    70  	switch err.Reason().(type) {
    71  	case *InvalidValue:
    72  	default:
    73  		assert.Fail(t, err.Error())
    74  	}
    75  
    76  	assert.False(t, err.IsOk())
    77  	assert.True(t, err.IsNotOk())
    78  	assert.Equal(t, err.ReasonName(), "InvalidValue")
    79  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi_test")
    80  	assert.Equal(t, err.Get("Value"), "abc")
    81  	assert.Nil(t, err.Get("value"))
    82  	assert.Nil(t, err.Get("Name"))
    83  
    84  	m := err.Situation()
    85  	assert.Equal(t, len(m), 1)
    86  	assert.Equal(t, m["Value"], "abc")
    87  	assert.Nil(t, m["value"])
    88  
    89  	assert.Nil(t, err.Cause())
    90  	assert.Nil(t, err.Unwrap())
    91  	assert.Nil(t, errors.Unwrap(err))
    92  
    93  	assert.True(t, errors.Is(err, err))
    94  	assert.True(t, errors.As(err, &err))
    95  
    96  	e := InvalidValueError{Value: "aaa"}
    97  	assert.False(t, errors.Is(err, e))
    98  	assert.False(t, errors.As(err, &e))
    99  }
   100  
   101  func TestNewErr_withCause(t *testing.T) {
   102  	cause := errors.New("def")
   103  	err := sabi.NewErr(InvalidValue{Value: "abc"}, cause)
   104  
   105  	assert.Equal(t, err.Error(), "{reason=InvalidValue, Value=abc, cause=def}")
   106  
   107  	switch err.Reason().(type) {
   108  	case InvalidValue:
   109  	default:
   110  		assert.Fail(t, err.Error())
   111  	}
   112  
   113  	assert.False(t, err.IsOk())
   114  	assert.True(t, err.IsNotOk())
   115  	assert.Equal(t, err.ReasonName(), "InvalidValue")
   116  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi_test")
   117  	assert.Equal(t, err.Get("Value"), "abc")
   118  	assert.Nil(t, err.Get("value"))
   119  	assert.Nil(t, err.Get("Name"))
   120  
   121  	m := err.Situation()
   122  	assert.Equal(t, len(m), 1)
   123  	assert.Equal(t, m["Value"], "abc")
   124  
   125  	assert.Equal(t, err.Cause(), cause)
   126  	assert.Equal(t, err.Unwrap(), cause)
   127  	assert.Equal(t, errors.Unwrap(err), cause)
   128  
   129  	assert.True(t, errors.Is(err, err))
   130  	assert.True(t, errors.As(err, &err))
   131  
   132  	assert.True(t, errors.Is(err, cause))
   133  	//assert.True(t, errors.As(err, cause)) --> compile error
   134  
   135  	e := InvalidValueError{Value: "aaa"}
   136  	assert.False(t, errors.Is(err, e))
   137  	assert.False(t, errors.As(err, &e))
   138  }
   139  
   140  func TestNewErr_causeIsAlsoErr(t *testing.T) {
   141  	cause := sabi.NewErr(FailToGetValue{Name: "foo"})
   142  	err := sabi.NewErr(InvalidValue{Value: "abc"}, cause)
   143  
   144  	assert.Equal(t, err.Error(), "{reason=InvalidValue, Value=abc, cause={reason=FailToGetValue, Name=foo}}")
   145  
   146  	switch err.Reason().(type) {
   147  	case InvalidValue:
   148  	default:
   149  		assert.Fail(t, err.Error())
   150  	}
   151  
   152  	assert.False(t, err.IsOk())
   153  	assert.True(t, err.IsNotOk())
   154  	assert.Equal(t, err.ReasonName(), "InvalidValue")
   155  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi_test")
   156  
   157  	assert.Equal(t, err.Get("Value"), "abc")
   158  	assert.Equal(t, err.Get("Name"), "foo")
   159  	assert.Nil(t, err.Get("value"))
   160  
   161  	m := err.Situation()
   162  	assert.Equal(t, len(m), 2)
   163  	assert.Equal(t, m["Value"], "abc")
   164  	assert.Equal(t, m["Name"], "foo")
   165  
   166  	assert.Equal(t, err.Cause(), cause)
   167  	assert.Equal(t, err.Unwrap(), cause)
   168  	assert.Equal(t, errors.Unwrap(err), cause)
   169  
   170  	assert.True(t, errors.Is(err, err))
   171  	assert.True(t, errors.As(err, &err))
   172  
   173  	assert.True(t, errors.Is(err, cause))
   174  	assert.True(t, errors.As(err, &cause))
   175  
   176  	e := InvalidValueError{Value: "aaa"}
   177  	assert.False(t, errors.Is(err, e))
   178  	assert.False(t, errors.As(err, &e))
   179  }
   180  
   181  func TestOk(t *testing.T) {
   182  	err := sabi.Ok()
   183  
   184  	assert.Equal(t, err.Error(), "{reason=nil}")
   185  	assert.Nil(t, err.Reason())
   186  
   187  	switch err.Reason().(type) {
   188  	case nil:
   189  	default:
   190  		assert.Fail(t, err.Error())
   191  	}
   192  
   193  	assert.True(t, err.IsOk())
   194  	assert.False(t, err.IsNotOk())
   195  	assert.Equal(t, err.ReasonName(), "")
   196  	assert.Equal(t, err.ReasonPackage(), "")
   197  	assert.Nil(t, err.Get("Value"))
   198  	assert.Nil(t, err.Get("value"))
   199  	assert.Nil(t, err.Get("Name"))
   200  
   201  	m := err.Situation()
   202  	assert.Equal(t, len(m), 0)
   203  
   204  	assert.Nil(t, err.Cause())
   205  	assert.Nil(t, err.Unwrap())
   206  	assert.Nil(t, errors.Unwrap(err))
   207  
   208  	assert.True(t, errors.Is(err, err))
   209  	assert.True(t, errors.As(err, &err))
   210  
   211  	e := InvalidValueError{Value: "aaa"}
   212  	assert.False(t, errors.Is(err, e))
   213  	assert.False(t, errors.As(err, &e))
   214  }
   215  
   216  func TestErr_IfOk_ok(t *testing.T) {
   217  	err := sabi.Ok()
   218  
   219  	s := ""
   220  	err2 := err.IfOk(func() sabi.Err {
   221  		s = "executed."
   222  		return sabi.NewErr(InvalidValue{Value: "x"})
   223  	})
   224  
   225  	assert.Equal(t, s, "executed.")
   226  	assert.True(t, err.IsOk())
   227  	assert.True(t, err2.IsNotOk())
   228  	switch err2.Reason().(type) {
   229  	case InvalidValue:
   230  	default:
   231  		assert.Fail(t, err2.Error())
   232  	}
   233  }
   234  
   235  func TestErr_IfOk_err(t *testing.T) {
   236  	err := sabi.NewErr(InvalidValue{Value: "x"})
   237  
   238  	s := ""
   239  	err2 := err.IfOk(func() sabi.Err {
   240  		s = "executed."
   241  		return sabi.Ok()
   242  	})
   243  
   244  	assert.Equal(t, s, "")
   245  	assert.True(t, err.IsNotOk())
   246  	assert.True(t, err2.IsNotOk())
   247  	switch err2.Reason().(type) {
   248  	case InvalidValue:
   249  	default:
   250  		assert.Fail(t, err2.Error())
   251  	}
   252  }