Implement action test suite helper

chaintest/action_test_helpers.go

@@ -0,0 +1,85 @@
+// Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package chaintest
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ava-labs/avalanchego/database"
+	"github.com/ava-labs/avalanchego/ids"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/hypersdk/chain"
+	"github.com/ava-labs/hypersdk/codec"
+	"github.com/ava-labs/hypersdk/state"
+)
+
+var _ state.Mutable = (*InMemoryStore)(nil)
+
+// InMemoryStore is a storage that acts as a wrapper around a map and implements state.Mutable.
+type InMemoryStore struct {
+	Storage map[string][]byte
+}
+
+func NewInMemoryStore() *InMemoryStore {
+	return &InMemoryStore{
+		Storage: make(map[string][]byte),
+	}
+}
+
+func (i *InMemoryStore) GetValue(_ context.Context, key []byte) ([]byte, error) {
+	val, ok := i.Storage[string(key)]
+	if !ok {
+		return nil, database.ErrNotFound
+	}
+	return val, nil
+}
+
+func (i *InMemoryStore) Insert(_ context.Context, key []byte, value []byte) error {
+	i.Storage[string(key)] = value
+	return nil
+}
+
+func (i *InMemoryStore) Remove(_ context.Context, key []byte) error {
+	delete(i.Storage, string(key))
+	return nil
+}
+
+// ActionTest is a single parameterized test. It calls Execute on the action with the passed parameters
+// and checks that all assertions pass.
+type ActionTest struct {
+	Name string
+
+	Action chain.Action
+
+	Rules     chain.Rules
+	State     state.Mutable
+	Timestamp int64
+	Actor     codec.Address
+	ActionID  ids.ID
+
+	ExpectedOutputs [][]byte
+	ExpectedErr     error
+
+	Assertion func(state.Mutable) bool
+}
+
+// Run execute all tests from the test suite and make sure all assertions pass.
+func Run(t *testing.T, tests []ActionTest) {
+	for _, test := range tests {
+		t.Run(test.Name, func(t *testing.T) {
+			require := require.New(t)
+
+			output, err := test.Action.Execute(context.TODO(), test.Rules, test.State, test.Timestamp, test.Actor, test.ActionID)
+
+			require.ErrorIs(err, test.ExpectedErr)
+			require.Equal(output, test.ExpectedOutputs)
+
+			if test.Assertion != nil {
+				require.True(test.Assertion(test.State))
+			}
+		})
+	}
+}

examples/morpheusvm/actions/transfer_test.go

@@ -0,0 +1,126 @@
+// Copyright (C) 2023, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package actions
+
+import (
+	"context"
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/hypersdk/chaintest"
+	"github.com/ava-labs/hypersdk/codec"
+	"github.com/ava-labs/hypersdk/examples/morpheusvm/storage"
+	"github.com/ava-labs/hypersdk/state"
+	"github.com/ava-labs/hypersdk/tstate"
+)
+
+func TestTransferAction(t *testing.T) {
+	require := require.New(t)
+	ts := tstate.New(1)
+	emptyBalanceKey := storage.BalanceKey(codec.EmptyAddress)
+	addrSlice := make([]byte, codec.AddressLen)
+	for i := range addrSlice {
+		addrSlice[i] = 1
+	}
+	oneAddr, err := codec.ToAddress(addrSlice)
+	require.NoError(err)
+
+	tests := []chaintest.ActionTest{
+		{
+			Name:  "ZeroTransfer",
+			Actor: codec.EmptyAddress,
+			Action: &Transfer{
+				To:    codec.EmptyAddress,
+				Value: 0,
+			},
+			ExpectedErr: ErrOutputValueZero,
+		},
+		{
+			Name:  "InvalidStateKey",
+			Actor: codec.EmptyAddress,
+			Action: &Transfer{
+				To:    codec.EmptyAddress,
+				Value: 1,
+			},
+			State:       ts.NewView(make(state.Keys), map[string][]byte{}),
+			ExpectedErr: tstate.ErrInvalidKeyOrPermission,
+		},
+		{
+			Name:  "NotEnoughBalance",
+			Actor: codec.EmptyAddress,
+			Action: &Transfer{
+				To:    codec.EmptyAddress,
+				Value: 1,
+			},
+			State: func() state.Mutable {
+				keys := make(state.Keys)
+				keys.Add(string(emptyBalanceKey), state.Read)
+				tsv := ts.NewView(keys, map[string][]byte{})
+				return tsv
+			}(),
+			ExpectedErr: storage.ErrInvalidBalance,
+		},
+		{
+			Name:  "SimpleZeroTransfer",
+			Actor: codec.EmptyAddress,
+			Action: &Transfer{
+				To:    codec.EmptyAddress,
+				Value: 1,
+			},
+			State: func() state.Mutable {
+				keys := make(state.Keys)
+				store := chaintest.NewInMemoryStore()
+				require.NoError(storage.SetBalance(context.Background(), store, codec.EmptyAddress, 1))
+				keys.Add(string(emptyBalanceKey), state.All)
+				return ts.NewView(keys, store.Storage)
+			}(),
+			Assertion: func(store state.Mutable) bool {
+				balance, err := storage.GetBalance(context.Background(), store, codec.EmptyAddress)
+				require.NoError(err)
+				return balance == 1
+			},
+		},
+		{
+			Name:  "OverflowBalance",
+			Actor: codec.EmptyAddress,
+			Action: &Transfer{
+				To:    codec.EmptyAddress,
+				Value: math.MaxUint64,
+			},
+			State: func() state.Mutable {
+				keys := make(state.Keys)
+				store := chaintest.NewInMemoryStore()
+				require.NoError(storage.SetBalance(context.Background(), store, codec.EmptyAddress, 1))
+				keys.Add(string(emptyBalanceKey), state.All)
+				return ts.NewView(keys, store.Storage)
+			}(),
+			ExpectedErr: storage.ErrInvalidBalance,
+		},
+		{
+			Name:  "SimpleTransfer",
+			Actor: codec.EmptyAddress,
+			Action: &Transfer{
+				To:    oneAddr,
+				Value: 1,
+			},
+			State: func() state.Mutable {
+				keys := make(state.Keys)
+				store := chaintest.NewInMemoryStore()
+				require.NoError(storage.SetBalance(context.Background(), store, codec.EmptyAddress, 1))
+				keys.Add(string(emptyBalanceKey), state.All)
+				keys.Add(string(storage.BalanceKey(oneAddr)), state.All)
+				return ts.NewView(keys, store.Storage)
+			}(),
+			Assertion: func(store state.Mutable) bool {
+				balance, err := storage.GetBalance(context.Background(), store, oneAddr)
+				require.NoError(err)
+				return balance == 1
+			},
+		},
+	}
+
+	chaintest.Run(t, tests)
+}