github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/rpcclient/neptoken/base_test.go (about)

     1  package neptoken
     2  
     3  import (
     4  	"errors"
     5  	"math/big"
     6  	"testing"
     7  
     8  	"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
     9  	"github.com/nspcc-dev/neo-go/pkg/util"
    10  	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
    11  	"github.com/stretchr/testify/require"
    12  )
    13  
    14  type testInv struct {
    15  	err error
    16  	res *result.Invoke
    17  }
    18  
    19  func (t *testInv) Call(contract util.Uint160, operation string, params ...any) (*result.Invoke, error) {
    20  	return t.res, t.err
    21  }
    22  
    23  func TestBaseErrors(t *testing.T) {
    24  	ti := new(testInv)
    25  	base := New(ti, util.Uint160{1, 2, 3})
    26  
    27  	ti.err = errors.New("")
    28  	_, err := base.Decimals()
    29  	require.Error(t, err)
    30  	_, err = base.Symbol()
    31  	require.Error(t, err)
    32  	_, err = base.TotalSupply()
    33  	require.Error(t, err)
    34  	_, err = base.BalanceOf(util.Uint160{1, 2, 3})
    35  	require.Error(t, err)
    36  
    37  	ti.err = nil
    38  	ti.res = &result.Invoke{
    39  		State:          "FAULT",
    40  		FaultException: "bad thing happened",
    41  	}
    42  	_, err = base.Decimals()
    43  	require.Error(t, err)
    44  	_, err = base.Symbol()
    45  	require.Error(t, err)
    46  	_, err = base.TotalSupply()
    47  	require.Error(t, err)
    48  	_, err = base.BalanceOf(util.Uint160{1, 2, 3})
    49  	require.Error(t, err)
    50  
    51  	ti.res = &result.Invoke{
    52  		State: "HALT",
    53  	}
    54  	_, err = base.Decimals()
    55  	require.Error(t, err)
    56  	_, err = base.Symbol()
    57  	require.Error(t, err)
    58  	_, err = base.TotalSupply()
    59  	require.Error(t, err)
    60  	_, err = base.BalanceOf(util.Uint160{1, 2, 3})
    61  	require.Error(t, err)
    62  }
    63  
    64  func TestBaseDecimals(t *testing.T) {
    65  	ti := new(testInv)
    66  	base := New(ti, util.Uint160{1, 2, 3})
    67  
    68  	ti.res = &result.Invoke{
    69  		State: "HALT",
    70  		Stack: []stackitem.Item{
    71  			stackitem.Make(0),
    72  		},
    73  	}
    74  	dec, err := base.Decimals()
    75  	require.NoError(t, err)
    76  	require.Equal(t, 0, dec)
    77  
    78  	ti.res = &result.Invoke{
    79  		State: "HALT",
    80  		Stack: []stackitem.Item{
    81  			stackitem.Make(-1),
    82  		},
    83  	}
    84  	_, err = base.Decimals()
    85  	require.Error(t, err)
    86  
    87  	ti.res = &result.Invoke{
    88  		State: "HALT",
    89  		Stack: []stackitem.Item{
    90  			stackitem.Make(100500),
    91  		},
    92  	}
    93  	_, err = base.Decimals()
    94  	require.Error(t, err)
    95  }
    96  
    97  func TestBaseSymbol(t *testing.T) {
    98  	ti := new(testInv)
    99  	base := New(ti, util.Uint160{1, 2, 3})
   100  
   101  	ti.res = &result.Invoke{
   102  		State: "HALT",
   103  		Stack: []stackitem.Item{
   104  			stackitem.Make("SYM"),
   105  		},
   106  	}
   107  	sym, err := base.Symbol()
   108  	require.NoError(t, err)
   109  	require.Equal(t, "SYM", sym)
   110  
   111  	ti.res = &result.Invoke{
   112  		State: "HALT",
   113  		Stack: []stackitem.Item{
   114  			stackitem.Make("\xff"),
   115  		},
   116  	}
   117  	_, err = base.Symbol()
   118  	require.Error(t, err)
   119  }
   120  
   121  func TestBaseTotalSupply(t *testing.T) {
   122  	ti := new(testInv)
   123  	base := New(ti, util.Uint160{1, 2, 3})
   124  
   125  	ti.res = &result.Invoke{
   126  		State: "HALT",
   127  		Stack: []stackitem.Item{
   128  			stackitem.Make(100500),
   129  		},
   130  	}
   131  	ts, err := base.TotalSupply()
   132  	require.NoError(t, err)
   133  	require.Equal(t, big.NewInt(100500), ts)
   134  
   135  	ti.res = &result.Invoke{
   136  		State: "HALT",
   137  		Stack: []stackitem.Item{
   138  			stackitem.Make([]stackitem.Item{}),
   139  		},
   140  	}
   141  	_, err = base.TotalSupply()
   142  	require.Error(t, err)
   143  }
   144  
   145  func TestBaseBalanceOf(t *testing.T) {
   146  	ti := new(testInv)
   147  	base := New(ti, util.Uint160{1, 2, 3})
   148  
   149  	ti.res = &result.Invoke{
   150  		State: "HALT",
   151  		Stack: []stackitem.Item{
   152  			stackitem.Make(100500),
   153  		},
   154  	}
   155  	bal, err := base.BalanceOf(util.Uint160{1, 2, 3})
   156  	require.NoError(t, err)
   157  	require.Equal(t, big.NewInt(100500), bal)
   158  
   159  	ti.res = &result.Invoke{
   160  		State: "HALT",
   161  		Stack: []stackitem.Item{
   162  			stackitem.Make([]stackitem.Item{}),
   163  		},
   164  	}
   165  	_, err = base.BalanceOf(util.Uint160{1, 2, 3})
   166  	require.Error(t, err)
   167  }