Add UTs for PreExecutor.PreExecute()

chain/pre_executor_test.go

@@ -0,0 +1,207 @@
+// Copyright (C) 2024, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package chain_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/ava-labs/avalanchego/database"
+	"github.com/ava-labs/avalanchego/database/memdb"
+	"github.com/ava-labs/avalanchego/trace"
+	"github.com/ava-labs/avalanchego/utils/set"
+	"github.com/ava-labs/avalanchego/x/merkledb"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ava-labs/hypersdk/chain"
+	"github.com/ava-labs/hypersdk/genesis"
+	"github.com/ava-labs/hypersdk/internal/validitywindow"
+	"github.com/ava-labs/hypersdk/state"
+	"github.com/ava-labs/hypersdk/state/metadata"
+	"github.com/ava-labs/hypersdk/utils"
+)
+
+var (
+	feeKey = string(chain.FeeKey([]byte{2}))
+
+	errMockAuth           = errors.New("mock auth error")
+	errMockValidityWindow = errors.New("mock validity window error")
+
+	_ chain.Auth           = (*mockAuth)(nil)
+	_ chain.BalanceHandler = (*mockBalanceHandler)(nil)
+	_ chain.ValidityWindow = (*mockValidityWindow)(nil)
+)
+
+type mockValidityWindow struct {
+	isRepeatError error
+	setBits       []int
+}
+
+func (*mockValidityWindow) Accept(validitywindow.ExecutionBlock[*chain.Transaction]) {
+	panic("unimplemented")
+}
+
+func (m *mockValidityWindow) IsRepeat(context.Context, validitywindow.ExecutionBlock[*chain.Transaction], []*chain.Transaction, int64) (set.Bits, error) {
+	return set.NewBits(m.setBits...), m.isRepeatError
+}
+
+func (*mockValidityWindow) VerifyExpiryReplayProtection(context.Context, validitywindow.ExecutionBlock[*chain.Transaction], int64) error {
+	panic("unimplemented")
+}
+
+func TestPreExecutor(t *testing.T) {
+	testRules := genesis.NewDefaultRules()
+	ruleFactory := genesis.ImmutableRuleFactory{
+		Rules: testRules,
+	}
+
+	tests := []struct {
+		name           string
+		state          map[string][]byte
+		tx             *chain.Transaction
+		validityWindow chain.ValidityWindow
+		verifyAuth     bool
+		err            error
+	}{
+		{
+			name: "valid test case",
+			state: map[string][]byte{
+				feeKey: {},
+			},
+			tx: &chain.Transaction{
+				TransactionData: chain.TransactionData{
+					Base: &chain.Base{
+						Timestamp: utils.UnixRMilli(
+							time.Now().UnixMilli(),
+							testRules.GetValidityWindow(),
+						),
+					},
+				},
+				Auth: &mockAuth{
+					start: -1,
+					end:   -1,
+				},
+			},
+			validityWindow: &mockValidityWindow{},
+		},
+		{
+			name: "raw fee doesn't exist",
+			err:  database.ErrNotFound,
+		},
+		{
+			name: "validity window error",
+			tx:   &chain.Transaction{},
+			state: map[string][]byte{
+				feeKey: {},
+			},
+			validityWindow: &mockValidityWindow{
+				isRepeatError: errMockValidityWindow,
+			},
+			err: errMockValidityWindow,
+		},
+		{
+			name: "duplicate transaction",
+			tx:   &chain.Transaction{},
+			state: map[string][]byte{
+				feeKey: {},
+			},
+			validityWindow: &mockValidityWindow{
+				setBits: []int{0},
+			},
+			err: chain.ErrDuplicateTx,
+		},
+		{
+			name: "tx state keys are invalid",
+			state: map[string][]byte{
+				feeKey: {},
+			},
+			tx: &chain.Transaction{
+				TransactionData: chain.TransactionData{
+					Actions: []chain.Action{
+						&mockAction{
+							stateKeys: state.Keys{
+								"": state.None,
+							},
+						},
+					},
+				},
+				Auth: &mockAuth{},
+			},
+			validityWindow: &mockValidityWindow{},
+			err:            chain.ErrInvalidKeyValue,
+		},
+		{
+			name: "verify auth error",
+			state: map[string][]byte{
+				feeKey: {},
+			},
+			tx: &chain.Transaction{
+				TransactionData: chain.TransactionData{
+					Base: &chain.Base{},
+				},
+				Auth: &mockAuth{
+					verifyError: errMockAuth,
+				},
+			},
+			validityWindow: &mockValidityWindow{},
+			verifyAuth:     true,
+			err:            errMockAuth,
+		},
+		{
+			name: "transaction pre-execute error",
+			state: map[string][]byte{
+				feeKey: {},
+			},
+			tx: &chain.Transaction{
+				TransactionData: chain.TransactionData{
+					Base: &chain.Base{},
+				},
+				Auth: &mockAuth{},
+			},
+			validityWindow: &mockValidityWindow{},
+			err:            chain.ErrTimestampTooLate,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := require.New(t)
+			ctx := context.Background()
+
+			db, err := merkledb.New(
+				ctx,
+				memdb.New(),
+				merkledb.Config{
+					BranchFactor: merkledb.BranchFactor16,
+					Tracer:       trace.Noop,
+				},
+			)
+			r.NoError(err)
+
+			for k, v := range tt.state {
+				r.NoError(db.Put([]byte(k), v))
+			}
+			r.NoError(db.CommitToDB(ctx))
+
+			preExecutor := chain.NewPreExecutor(
+				&ruleFactory,
+				tt.validityWindow,
+				metadata.NewDefaultManager(),
+				&mockBalanceHandler{},
+			)
+
+			r.ErrorIs(
+				preExecutor.PreExecute(
+					ctx,
+					nil,
+					db,
+					tt.tx,
+					tt.verifyAuth,
+				), tt.err,
+			)
+		})
+	}
+}

chain/transaction_test.go

@@ -42,6 +42,7 @@ type mockAction struct {
 	end          int64
 	computeUnits uint64
 	typeID       uint8
+	stateKeys    state.Keys
 }
 
 func (m *mockAction) ComputeUnits(chain.Rules) uint64 {
@@ -56,8 +57,8 @@ func (m *mockAction) GetTypeID() uint8 {
 	return m.typeID
 }
 
-func (*mockAction) StateKeys(codec.Address, ids.ID) state.Keys {
-	return state.Keys{}
+func (m *mockAction) StateKeys(codec.Address, ids.ID) state.Keys {
+	return m.stateKeys
 }
 
 func (m *mockAction) ValidRange(chain.Rules) (int64, int64) {
@@ -127,6 +128,7 @@ type mockAuth struct {
 	computeUnits uint64
 	actor        codec.Address
 	sponsor      codec.Address
+	verifyError  error
 }
 
 func (m *mockAuth) Actor() codec.Address {
@@ -157,8 +159,8 @@ func (m *mockAuth) ValidRange(chain.Rules) (int64, int64) {
 	return m.start, m.end
 }
 
-func (*mockAuth) Verify(context.Context, []byte) error {
-	panic("unimplemented")
+func (m *mockAuth) Verify(context.Context, []byte) error {
+	return m.verifyError
 }
 
 func TestJSONMarshalUnmarshal(t *testing.T) {