[e2etest] add tests for original actions after candidate ownership transfer

action/protocol/staking/candidate_center_test.go

@@ -578,7 +578,6 @@ func candCenterFromNewCandidateStateManager(r *require.Assertions, view protocol
 }
 
 func TestCandidateUpsert(t *testing.T) {
- // t.Skip()
  r := require.New(t)
 
  m, err := NewCandidateCenter(nil)

action/protocol/staking/handler_candidate_transfer_ownership_test.go

@@ -21,8 +21,6 @@ import (
 )
 
 func TestProtocol_HandleCandidateTransferOwnership(t *testing.T) {
- //TODO: fix this test
- t.Skip()
  require := require.New(t)
  ctrl := gomock.NewController(t)
  sm := testdb.NewMockStateManager(ctrl)
@@ -212,6 +210,7 @@ func TestProtocol_HandleCandidateTransferOwnership(t *testing.T) {
  })
  cfg := deepcopy.Copy(genesis.Default).(genesis.Genesis)
  cfg.TsunamiBlockHeight = 1
+ cfg.ToBeEnabledBlockHeight = 1 // enable candidate owner transfer feature
  ctx = genesis.WithGenesisContext(ctx, cfg)
  ctx = protocol.WithFeatureCtx(protocol.WithFeatureWithHeightCtx(ctx))
  require.NoError(p.Validate(ctx, act, sm))

action/protocol/staking/protocol.go

@@ -562,8 +562,10 @@ func (p *Protocol) ReadState(ctx context.Context, sr protocol.StateReader, metho
  if err != nil {
  return nil, 0, err
  }
- rp := rolldpos.MustGetProtocol(protocol.MustGetRegistry(ctx))
- epochStartHeight := rp.GetEpochHeight(rp.GetEpochNum(inputHeight))
+ epochStartHeight := inputHeight
+ if rp := rolldpos.FindProtocol(protocol.MustGetRegistry(ctx)); rp != nil {
+ epochStartHeight = rp.GetEpochHeight(rp.GetEpochNum(inputHeight))
+ }
  nativeSR, err := ConstructBaseView(sr)
  if err != nil {
  return nil, 0, err

e2etest/e2etest.go

@@ -0,0 +1,152 @@
+package e2etest
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/require"
+
+ "github.com/iotexproject/iotex-core/action"
+ "github.com/iotexproject/iotex-core/actpool"
+ "github.com/iotexproject/iotex-core/blockchain"
+ "github.com/iotexproject/iotex-core/blockchain/block"
+ "github.com/iotexproject/iotex-core/chainservice"
+ "github.com/iotexproject/iotex-core/config"
+ "github.com/iotexproject/iotex-core/server/itx"
+ "github.com/iotexproject/iotex-core/testutil"
+)
+
+type (
+ actionWithTime struct {
+ act *action.SealedEnvelope
+ t time.Time
+ }
+ testcase struct {
+ name string
+ preActs []*actionWithTime
+ act *actionWithTime
+ expect []actionExpect
+ }
+ accountNonceManager map[string]uint64
+ e2etest struct {
+ cfg config.Config
+ svr *itx.Server
+ cs *chainservice.ChainService
+ t *testing.T
+ nonceMgr accountNonceManager
+ }
+)
+
+func (m accountNonceManager) pop(addr string) uint64 {
+ nonce := m[addr]
+ m[addr] = nonce + 1
+ return nonce
+}
+
+func newE2ETest(t *testing.T, cfg config.Config) *e2etest {
+ require := require.New(t)
+ // Create a new blockchain
+ svr, err := itx.NewServer(cfg)
+ require.NoError(err)
+ ctx := context.Background()
+ require.NoError(svr.Start(ctx))
+ return &e2etest{
+ cfg: cfg,
+ svr: svr,
+ cs: svr.ChainService(cfg.Chain.ID),
+ t: t,
+ nonceMgr: make(accountNonceManager),
+ }
+}
+
+func (e *e2etest) run(cases []*testcase) {
+ ctx := context.Background()
+ // run subcases
+ for _, sub := range cases {
+ e.t.Run(sub.name, func(t *testing.T) {
+ e.withTest(t).runCase(ctx, sub)
+ })
+ }
+}
+
+func (e *e2etest) runCase(ctx context.Context, c *testcase) {
+ require := require.New(e.t)
+ bc := e.cs.Blockchain()
+ ap := e.cs.ActionPool()
+ // run pre-actions
+ for _, act := range c.preActs {
+ _, _, err := addOneTx(ctx, ap, bc, act)
+ require.NoError(err)
+ }
+ // run action
+ act, receipt, err := addOneTx(ctx, ap, bc, c.act)
+ for _, exp := range c.expect {
+ exp.expect(e, act, receipt, err)
+ }
+}
+
+func (e *e2etest) teardown() {
+ require := require.New(e.t)
+ // clean up
+ testutil.CleanupPath(e.cfg.Chain.ChainDBPath)
+ testutil.CleanupPath(e.cfg.Chain.TrieDBPath)
+ testutil.CleanupPath(e.cfg.Chain.BloomfilterIndexDBPath)
+ testutil.CleanupPath(e.cfg.Chain.CandidateIndexDBPath)
+ testutil.CleanupPath(e.cfg.Chain.StakingIndexDBPath)
+ testutil.CleanupPath(e.cfg.Chain.ContractStakingIndexDBPath)
+ testutil.CleanupPath(e.cfg.DB.DbPath)
+ testutil.CleanupPath(e.cfg.Chain.IndexDBPath)
+ testutil.CleanupPath(e.cfg.System.SystemLogDBPath)
+ testutil.CleanupPath(e.cfg.Chain.SGDIndexDBPath)
+ require.NoError(e.svr.Stop(context.Background()))
+}
+
+func (e *e2etest) withTest(t *testing.T) *e2etest {
+ return &e2etest{
+ cfg: e.cfg,
+ svr: e.svr,
+ cs: e.cs,
+ t: t,
+ }
+}
+
+func addOneTx(ctx context.Context, ap actpool.ActPool, bc blockchain.Blockchain, tx *actionWithTime) (*action.SealedEnvelope, *action.Receipt, error) {
+ if err := ap.Add(ctx, tx.act); err != nil {
+ return tx.act, nil, err
+ }
+ blk, err := createAndCommitBlock(bc, ap, tx.t)
+ if err != nil {
+ return tx.act, nil, err
+ }
+ h, err := tx.act.Hash()
+ if err != nil {
+ return tx.act, nil, err
+ }
+ for _, r := range blk.Receipts {
+ if r.ActionHash == h {
+ return tx.act, r, nil
+ }
+ }
+ return tx.act, nil, errors.Errorf("failed to find receipt for %x", h)
+}
+
+func createAndCommitBlock(bc blockchain.Blockchain, ap actpool.ActPool, blkTime time.Time) (*block.Block, error) {
+ blk, err := bc.MintNewBlock(blkTime)
+ if err != nil {
+ return nil, err
+ }
+ if err := bc.CommitBlock(blk); err != nil {
+ return nil, err
+ }
+ ap.Reset()
+ return blk, nil
+}
+
+func mustNoErr[T any](t T, err error) T {
+ if err != nil {
+ panic(err)
+ }
+ return t
+}

e2etest/expect.go

@@ -0,0 +1,115 @@
+package e2etest
+
+import (
+ "context"
+ "slices"
+
+ "github.com/iotexproject/iotex-proto/golang/iotexapi"
+ "github.com/iotexproject/iotex-proto/golang/iotextypes"
+ "github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/proto"
+
+ "github.com/iotexproject/iotex-core/action"
+ "github.com/iotexproject/iotex-core/action/protocol"
+ "github.com/iotexproject/iotex-core/action/protocol/staking"
+ "github.com/iotexproject/iotex-core/blockchain/genesis"
+)
+
+type (
+ actionExpect interface {
+ expect(test *e2etest, act *action.SealedEnvelope, receipt *action.Receipt, err error)
+ }
+ basicActionExpect struct {
+ err error
+ status uint64
+ executionRevertMsg string
+ }
+ candidateExpect struct {
+ candName string
+ cand *iotextypes.CandidateV2
+ }
+ bucketExpect struct {
+ bucket *iotextypes.VoteBucket
+ }
+)
+
+func (be *basicActionExpect) expect(test *e2etest, act *action.SealedEnvelope, receipt *action.Receipt, err error) {
+ require := require.New(test.t)
+ require.ErrorIs(err, be.err)
+ require.Equal(be.status, receipt.Status)
+ require.Equal(be.executionRevertMsg, receipt.ExecutionRevertMsg())
+}
+
+func (ce *candidateExpect) expect(test *e2etest, act *action.SealedEnvelope, receipt *action.Receipt, err error) {
+ require := require.New(test.t)
+ method := &iotexapi.ReadStakingDataMethod{
+ Method: iotexapi.ReadStakingDataMethod_CANDIDATE_BY_NAME,
+ }
+ methodBytes, err := proto.Marshal(method)
+ require.NoError(err)
+ r := &iotexapi.ReadStakingDataRequest{
+ Request: &iotexapi.ReadStakingDataRequest_CandidateByName_{
+ CandidateByName: &iotexapi.ReadStakingDataRequest_CandidateByName{
+ CandName: ce.candName,
+ },
+ },
+ }
+ cs := test.svr.ChainService(test.cfg.Chain.ID)
+ sr := cs.StateFactory()
+ bc := cs.Blockchain()
+ prtcl, ok := cs.Registry().Find("staking")
+ require.True(ok)
+ stkPrtcl := prtcl.(*staking.Protocol)
+ reqBytes, err := proto.Marshal(r)
+ require.NoError(err)
+ ctx := protocol.WithRegistry(context.Background(), cs.Registry())
+ ctx = genesis.WithGenesisContext(ctx, test.cfg.Genesis)
+ ctx = protocol.WithBlockCtx(ctx, protocol.BlockCtx{
+ BlockHeight: bc.TipHeight(),
+ })
+ ctx = protocol.WithFeatureCtx(ctx)
+ respData, _, err := stkPrtcl.ReadState(ctx, sr, methodBytes, reqBytes)
+ require.NoError(err)
+ candidate := &iotextypes.CandidateV2{}
+ require.NoError(proto.Unmarshal(respData, candidate))
+ require.EqualValues(ce.cand.String(), candidate.String())
+}
+
+func (be *bucketExpect) expect(test *e2etest, act *action.SealedEnvelope, receipt *action.Receipt, err error) {
+ require := require.New(test.t)
+ method := &iotexapi.ReadStakingDataMethod{
+ Method: iotexapi.ReadStakingDataMethod_BUCKETS_BY_INDEXES,
+ }
+ methodBytes, err := proto.Marshal(method)
+ require.NoError(err)
+ r := &iotexapi.ReadStakingDataRequest{
+ Request: &iotexapi.ReadStakingDataRequest_BucketsByIndexes{
+ BucketsByIndexes: &iotexapi.ReadStakingDataRequest_VoteBucketsByIndexes{
+ Index: []uint64{be.bucket.Index},
+ },
+ },
+ }
+ cs := test.svr.ChainService(test.cfg.Chain.ID)
+ sr := cs.StateFactory()
+ bc := cs.Blockchain()
+ prtcl, ok := cs.Registry().Find("staking")
+ require.True(ok)
+ stkPrtcl := prtcl.(*staking.Protocol)
+ reqBytes, err := proto.Marshal(r)
+ require.NoError(err)
+ ctx := protocol.WithRegistry(context.Background(), cs.Registry())
+ ctx = genesis.WithGenesisContext(ctx, test.cfg.Genesis)
+ ctx = protocol.WithBlockCtx(ctx, protocol.BlockCtx{
+ BlockHeight: bc.TipHeight(),
+ })
+ ctx = protocol.WithFeatureCtx(ctx)
+ respData, _, err := stkPrtcl.ReadState(ctx, sr, methodBytes, reqBytes)
+ require.NoError(err)
+ vbs := &iotextypes.VoteBucketList{}
+ require.NoError(proto.Unmarshal(respData, vbs))
+ idx := slices.IndexFunc(vbs.Buckets, func(vb *iotextypes.VoteBucket) bool {
+ return vb.ContractAddress == be.bucket.ContractAddress
+ })
+ require.True(idx != -1)
+ require.EqualValues(be.bucket.String(), vbs.Buckets[idx].String())
+}