TrueCloudLab/neo-go
8
0
Fork 0
mirror of https://github.com/nspcc-dev/neo-go.git synced 2024-11-27 03:58:06 +00:00
Code Issues Projects Releases Packages Wiki Activity
neo-go/pkg/rpcclient/unwrap/unwrap_test.go

423 lines
16 KiB
Go
Raw Normal View History

rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
package unwrap
import (
"errors"
"math"
"math/big"
"testing"
"github.com/google/uuid"
unwrap: add ArrayOfPublicKeys() This type of result is also popular in the NEO contract.
2022-08-16 19:32:46 +00:00
"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
"github.com/nspcc-dev/neo-go/pkg/util"
"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
"github.com/stretchr/testify/require"
)
func TestStdErrors(t *testing.T) {
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
funcs := []func(r *result.Invoke, err error) (any, error){
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return BigInt(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Bool(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Int64(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return LimitedInt64(r, err, 0, 1)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Bytes(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return UTF8String(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return PrintableASCIIString(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Uint160(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Uint256(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add PublicKey to unwrap public keys We have this type in NEP-14 directly.
2022-10-27 11:45:40 +00:00
return PublicKey(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
_, _, err = SessionIterator(r, err)
return nil, err
},
unwrap: Add ArrayAndSessionIterator(), close #3272 It can be used to work with the results of CreateCallAndPrefetchIteratorScript() execution. The first item must be an array and the optional second item must be an iterator, containing remaining elements. Signed-off-by: Evgenii Stratonikov <fyfyrchik@runbox.com>
2023-12-29 07:50:39 +00:00
func(r *result.Invoke, err error) (any, error) {
_, _, _, err = ArrayAndSessionIterator(r, err)
return nil, err
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Array(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
return ArrayOfBools(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
return ArrayOfBigInts(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return ArrayOfBytes(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
return ArrayOfUTF8Strings(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
return ArrayOfUint160(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
return ArrayOfUint256(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
unwrap: add ArrayOfPublicKeys() This type of result is also popular in the NEO contract.
2022-08-16 19:32:46 +00:00
return ArrayOfPublicKeys(r, err)
},
*: replace `interface{}` with `any` keyword Everywhere including examples, external interop APIs, bindings generators code and in other valuable places. A couple of `interface{}` usages are intentionally left in the CHANGELOG.md, documentation and tests.
2023-04-03 10:34:24 +00:00
func(r *result.Invoke, err error) (any, error) {
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
return Map(r, err)
},
}
t.Run("error on input", func(t *testing.T) {
for _, f := range funcs {
_, err := f(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, errors.New("some"))
require.Error(t, err)
}
})
t.Run("FAULT state", func(t *testing.T) {
for _, f := range funcs {
_, err := f(&result.Invoke{State: "FAULT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
}
})
t.Run("nothing returned", func(t *testing.T) {
for _, f := range funcs {
_, err := f(&result.Invoke{State: "HALT"}, errors.New("some"))
require.Error(t, err)
}
})
t.Run("multiple return values", func(t *testing.T) {
for _, f := range funcs {
_, err := f(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42), stackitem.Make(42)}}, nil)
require.Error(t, err)
}
})
}
func TestBigInt(t *testing.T) {
_, err := BigInt(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{})}}, nil)
require.Error(t, err)
i, err := BigInt(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.NoError(t, err)
require.Equal(t, big.NewInt(42), i)
}
func TestBool(t *testing.T) {
_, err := Bool(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("0x03c564ed28ba3d50beb1a52dcb751b929e1d747281566bd510363470be186bc0")}}, nil)
require.Error(t, err)
b, err := Bool(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(true)}}, nil)
require.NoError(t, err)
require.True(t, b)
}
unwrap: add `Nothing` function The `Nothing` function expects zero stack items and a successful invocation (HALT state). Signed-off-by: Tatiana Nesterenko <tatiana@nspcc.io>
2023-09-03 15:54:50 +00:00
func TestNothing(t *testing.T) {
// Error on input.
err := Nothing(&result.Invoke{State: "HALT", Stack: []stackitem.Item{}}, errors.New("some"))
require.Error(t, err)
// Nonempty stack.
err = Nothing(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
// FAULT state.
err = Nothing(&result.Invoke{State: "FAULT", Stack: []stackitem.Item{}}, nil)
require.Error(t, err)
// Positive.
err = Nothing(&result.Invoke{State: "HALT", Stack: []stackitem.Item{}}, nil)
require.NoError(t, err)
}
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
func TestInt64(t *testing.T) {
_, err := Int64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("0x03c564ed28ba3d50beb1a52dcb751b929e1d747281566bd510363470be186bc0")}}, nil)
require.Error(t, err)
_, err = Int64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(uint64(math.MaxUint64))}}, nil)
require.Error(t, err)
i, err := Int64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.NoError(t, err)
require.Equal(t, int64(42), i)
}
func TestLimitedInt64(t *testing.T) {
_, err := LimitedInt64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("0x03c564ed28ba3d50beb1a52dcb751b929e1d747281566bd510363470be186bc0")}}, nil, math.MinInt64, math.MaxInt64)
require.Error(t, err)
_, err = LimitedInt64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(uint64(math.MaxUint64))}}, nil, math.MinInt64, math.MaxInt64)
require.Error(t, err)
_, err = LimitedInt64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil, 128, 256)
require.Error(t, err)
_, err = LimitedInt64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil, 0, 40)
require.Error(t, err)
i, err := LimitedInt64(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil, 0, 128)
require.NoError(t, err)
require.Equal(t, int64(42), i)
}
func TestBytes(t *testing.T) {
_, err := Bytes(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{})}}, nil)
require.Error(t, err)
b, err := Bytes(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]byte{1, 2, 3})}}, nil)
require.NoError(t, err)
require.Equal(t, []byte{1, 2, 3}, b)
}
func TestUTF8String(t *testing.T) {
_, err := UTF8String(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{})}}, nil)
require.Error(t, err)
_, err = UTF8String(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("\xff")}}, nil)
require.Error(t, err)
s, err := UTF8String(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("value")}}, nil)
require.NoError(t, err)
require.Equal(t, "value", s)
}
func TestPrintableASCIIString(t *testing.T) {
_, err := PrintableASCIIString(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{})}}, nil)
require.Error(t, err)
_, err = PrintableASCIIString(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("\xff")}}, nil)
require.Error(t, err)
_, err = PrintableASCIIString(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("\n\r")}}, nil)
require.Error(t, err)
s, err := PrintableASCIIString(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make("value")}}, nil)
require.NoError(t, err)
require.Equal(t, "value", s)
}
func TestUint160(t *testing.T) {
_, err := Uint160(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(util.Uint256{1, 2, 3}.BytesBE())}}, nil)
require.Error(t, err)
u, err := Uint160(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(util.Uint160{1, 2, 3}.BytesBE())}}, nil)
require.NoError(t, err)
require.Equal(t, util.Uint160{1, 2, 3}, u)
}
func TestUint256(t *testing.T) {
_, err := Uint256(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(util.Uint160{1, 2, 3}.BytesBE())}}, nil)
require.Error(t, err)
u, err := Uint256(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(util.Uint256{1, 2, 3}.BytesBE())}}, nil)
require.NoError(t, err)
require.Equal(t, util.Uint256{1, 2, 3}, u)
}
unwrap: add PublicKey to unwrap public keys We have this type in NEP-14 directly.
2022-10-27 11:45:40 +00:00
func TestPublicKey(t *testing.T) {
k, err := keys.NewPrivateKey()
require.NoError(t, err)
_, err = PublicKey(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(util.Uint160{1, 2, 3}.BytesBE())}}, nil)
require.Error(t, err)
pk, err := PublicKey(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(k.PublicKey().Bytes())}}, nil)
require.NoError(t, err)
require.Equal(t, k.PublicKey(), pk)
}
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
func TestSessionIterator(t *testing.T) {
_, _, err := SessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, _, err = SessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.NewInterop(42)}}, nil)
require.Error(t, err)
iid := uuid.New()
iter := result.Iterator{ID: &iid}
unwrap: perform consistency check in SessionIterator C# servers with SessionEnabled=false will return iterator IDs and no session IDs which can be reported as an error immediately because the iterator can't be traversed.
2022-08-17 12:08:24 +00:00
_, _, err = SessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.NewInterop(iter)}}, nil)
require.Error(t, err)
sid := uuid.New()
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
rs, ri, err := SessionIterator(&result.Invoke{Session: sid, State: "HALT", Stack: []stackitem.Item{stackitem.NewInterop(iter)}}, nil)
require.NoError(t, err)
require.Equal(t, sid, rs)
require.Equal(t, iter, ri)
}
unwrap: Add ArrayAndSessionIterator(), close #3272 It can be used to work with the results of CreateCallAndPrefetchIteratorScript() execution. The first item must be an array and the optional second item must be an iterator, containing remaining elements. Signed-off-by: Evgenii Stratonikov <fyfyrchik@runbox.com>
2023-12-29 07:50:39 +00:00
func TestArraySessionIterator(t *testing.T) {
_, _, _, err := ArrayAndSessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, _, _, err = ArrayAndSessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.NewInterop(42)}}, nil)
require.Error(t, err)
arr := stackitem.NewArray([]stackitem.Item{stackitem.Make(42)})
ra, rs, ri, err := ArrayAndSessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{arr}}, nil)
require.NoError(t, err)
require.Equal(t, arr.Value(), ra)
require.Empty(t, rs)
require.Empty(t, ri)
_, _, _, err = ArrayAndSessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{arr, stackitem.NewInterop(42)}}, nil)
require.Error(t, err)
iid := uuid.New()
iter := result.Iterator{ID: &iid}
_, _, _, err = ArrayAndSessionIterator(&result.Invoke{State: "HALT", Stack: []stackitem.Item{arr, stackitem.NewInterop(iter)}}, nil)
require.ErrorIs(t, err, ErrNoSessionID)
sid := uuid.New()
_, rs, ri, err = ArrayAndSessionIterator(&result.Invoke{Session: sid, State: "HALT", Stack: []stackitem.Item{arr, stackitem.NewInterop(iter)}}, nil)
require.NoError(t, err)
require.Equal(t, arr.Value(), ra)
require.Equal(t, sid, rs)
require.Equal(t, iter, ri)
_, _, _, err = ArrayAndSessionIterator(&result.Invoke{Session: sid, State: "HALT", Stack: []stackitem.Item{arr, stackitem.NewInterop(iter), stackitem.Make(42)}}, nil)
require.Error(t, err)
}
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
func TestArray(t *testing.T) {
_, err := Array(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
a, err := Array(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make(42)})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(a))
require.Equal(t, stackitem.Make(42), a[0])
}
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
func TestArrayOfBools(t *testing.T) {
_, err := ArrayOfBools(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfBools(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make("reallybigstringthatcantbeanumberandthuscantbeconvertedtobool")})}}, nil)
require.Error(t, err)
a, err := ArrayOfBools(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make(true)})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(a))
require.Equal(t, true, a[0])
}
func TestArrayOfBigInts(t *testing.T) {
_, err := ArrayOfBigInts(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfBigInts(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]stackitem.Item{})})}}, nil)
require.Error(t, err)
a, err := ArrayOfBigInts(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make(42)})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(a))
require.Equal(t, big.NewInt(42), a[0])
}
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
func TestArrayOfBytes(t *testing.T) {
_, err := ArrayOfBytes(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfBytes(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]stackitem.Item{})})}}, nil)
require.Error(t, err)
a, err := ArrayOfBytes(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]byte("some"))})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(a))
require.Equal(t, []byte("some"), a[0])
}
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
func TestArrayOfUTF8Strings(t *testing.T) {
_, err := ArrayOfUTF8Strings(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfUTF8Strings(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]stackitem.Item{})})}}, nil)
require.Error(t, err)
_, err = ArrayOfUTF8Strings(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]byte{0, 0xff})})}}, nil)
require.Error(t, err)
a, err := ArrayOfUTF8Strings(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make("some")})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(a))
require.Equal(t, "some", a[0])
}
unwrap: provide ArrayOfUint160 It's a popular type as well.
2022-08-19 07:36:44 +00:00
func TestArrayOfUint160(t *testing.T) {
_, err := ArrayOfUint160(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfUint160(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]stackitem.Item{})})}}, nil)
require.Error(t, err)
_, err = ArrayOfUint160(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]byte("some"))})}}, nil)
require.Error(t, err)
u160 := util.Uint160{1, 2, 3}
uints, err := ArrayOfUint160(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make(u160.BytesBE())})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(uints))
require.Equal(t, u160, uints[0])
}
unwrap: add a complete set of simple array unwrappers Arrays of basic types should be covered completely.
2022-11-14 09:45:47 +00:00
func TestArrayOfUint256(t *testing.T) {
_, err := ArrayOfUint256(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfUint256(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]stackitem.Item{})})}}, nil)
require.Error(t, err)
_, err = ArrayOfUint256(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]byte("some"))})}}, nil)
require.Error(t, err)
u256 := util.Uint256{1, 2, 3}
uints, err := ArrayOfUint256(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make(u256.BytesBE())})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(uints))
require.Equal(t, u256, uints[0])
}
unwrap: add ArrayOfPublicKeys() This type of result is also popular in the NEO contract.
2022-08-16 19:32:46 +00:00
func TestArrayOfPublicKeys(t *testing.T) {
_, err := ArrayOfPublicKeys(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
_, err = ArrayOfPublicKeys(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]stackitem.Item{})})}}, nil)
require.Error(t, err)
_, err = ArrayOfPublicKeys(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make([]byte("some"))})}}, nil)
require.Error(t, err)
k, err := keys.NewPrivateKey()
require.NoError(t, err)
pks, err := ArrayOfPublicKeys(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make([]stackitem.Item{stackitem.Make(k.PublicKey().Bytes())})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, len(pks))
require.Equal(t, k.PublicKey(), pks[0])
}
rpcclient: move result processing code into unwrap package Which will be reused by upper-layer packages. It can be extended with more types in future.
2022-08-09 12:18:16 +00:00
func TestMap(t *testing.T) {
_, err := Map(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.Make(42)}}, nil)
require.Error(t, err)
m, err := Map(&result.Invoke{State: "HALT", Stack: []stackitem.Item{stackitem.NewMapWithValue([]stackitem.MapElement{{Key: stackitem.Make(42), Value: stackitem.Make("string")}})}}, nil)
require.NoError(t, err)
require.Equal(t, 1, m.Len())
require.Equal(t, 0, m.Index(stackitem.Make(42)))
}
Reference in a new issue Copy permalink