vms/platformvm: Cleanup some block tests (#2422)

Co-authored-by: Dan Laine <daniel.laine@avalabs.org>

Author: dhrubabasu

vms/platformvm/block/parse_test.go

@@ -25,12 +25,12 @@ func TestStandardBlocks(t *testing.T) {
 	blkTimestamp := time.Now()
 	parentID := ids.ID{'p', 'a', 'r', 'e', 'n', 't', 'I', 'D'}
 	height := uint64(2022)
-	txs, err := testDecisionTxs()
+	decisionTxs, err := testDecisionTxs()
 	require.NoError(err)
 
 	for _, cdc := range []codec.Manager{Codec, GenesisCodec} {
 		// build block
-		apricotStandardBlk, err := NewApricotStandardBlock(parentID, height, txs)
+		apricotStandardBlk, err := NewApricotStandardBlock(parentID, height, decisionTxs)
 		require.NoError(err)
 
 		// parse block
@@ -44,10 +44,10 @@ func TestStandardBlocks(t *testing.T) {
 		require.Equal(apricotStandardBlk.Height(), parsed.Height())
 
 		require.IsType(&ApricotStandardBlock{}, parsed)
-		require.Equal(txs, parsed.Txs())
+		require.Equal(decisionTxs, parsed.Txs())
 
 		// check that banff standard block can be built and parsed
-		banffStandardBlk, err := NewBanffStandardBlock(blkTimestamp, parentID, height, txs)
+		banffStandardBlk, err := NewBanffStandardBlock(blkTimestamp, parentID, height, decisionTxs)
 		require.NoError(err)
 
 		// parse block
@@ -61,7 +61,7 @@ func TestStandardBlocks(t *testing.T) {
 		require.Equal(banffStandardBlk.Height(), parsed.Height())
 		require.IsType(&BanffStandardBlock{}, parsed)
 		parsedBanffStandardBlk := parsed.(*BanffStandardBlock)
-		require.Equal(txs, parsedBanffStandardBlk.Txs())
+		require.Equal(decisionTxs, parsedBanffStandardBlk.Txs())
 
 		// timestamp check for banff blocks only
 		require.Equal(banffStandardBlk.Timestamp(), parsedBanffStandardBlk.Timestamp())
@@ -77,15 +77,15 @@ func TestProposalBlocks(t *testing.T) {
 	blkTimestamp := time.Now()
 	parentID := ids.ID{'p', 'a', 'r', 'e', 'n', 't', 'I', 'D'}
 	height := uint64(2022)
-	tx, err := testProposalTx()
+	proposalTx, err := testProposalTx()
 	require.NoError(err)
 
 	for _, cdc := range []codec.Manager{Codec, GenesisCodec} {
 		// build block
 		apricotProposalBlk, err := NewApricotProposalBlock(
 			parentID,
 			height,
-			tx,
+			proposalTx,
 		)
 		require.NoError(err)
 
@@ -101,14 +101,14 @@ func TestProposalBlocks(t *testing.T) {
 
 		require.IsType(&ApricotProposalBlock{}, parsed)
 		parsedApricotProposalBlk := parsed.(*ApricotProposalBlock)
-		require.Equal([]*txs.Tx{tx}, parsedApricotProposalBlk.Txs())
+		require.Equal([]*txs.Tx{proposalTx}, parsedApricotProposalBlk.Txs())
 
 		// check that banff proposal block can be built and parsed
 		banffProposalBlk, err := NewBanffProposalBlock(
 			blkTimestamp,
 			parentID,
 			height,
-			tx,
+			proposalTx,
 		)
 		require.NoError(err)
 
@@ -119,11 +119,11 @@ func TestProposalBlocks(t *testing.T) {
 		// compare content
 		require.Equal(banffProposalBlk.ID(), parsed.ID())
 		require.Equal(banffProposalBlk.Bytes(), parsed.Bytes())
-		require.Equal(banffProposalBlk.Parent(), banffProposalBlk.Parent())
+		require.Equal(banffProposalBlk.Parent(), parsed.Parent())
 		require.Equal(banffProposalBlk.Height(), parsed.Height())
 		require.IsType(&BanffProposalBlock{}, parsed)
 		parsedBanffProposalBlk := parsed.(*BanffProposalBlock)
-		require.Equal([]*txs.Tx{tx}, parsedBanffProposalBlk.Txs())
+		require.Equal([]*txs.Tx{proposalTx}, parsedBanffProposalBlk.Txs())
 
 		// timestamp check for banff blocks only
 		require.Equal(banffProposalBlk.Timestamp(), parsedBanffProposalBlk.Timestamp())
@@ -224,15 +224,15 @@ func TestAtomicBlock(t *testing.T) {
 	require := require.New(t)
 	parentID := ids.ID{'p', 'a', 'r', 'e', 'n', 't', 'I', 'D'}
 	height := uint64(2022)
-	tx, err := testAtomicTx()
+	atomicTx, err := testAtomicTx()
 	require.NoError(err)
 
 	for _, cdc := range []codec.Manager{Codec, GenesisCodec} {
 		// build block
 		atomicBlk, err := NewApricotAtomicBlock(
 			parentID,
 			height,
-			tx,
+			atomicTx,
 		)
 		require.NoError(err)
 
@@ -248,7 +248,7 @@ func TestAtomicBlock(t *testing.T) {
 
 		require.IsType(&ApricotAtomicBlock{}, parsed)
 		parsedAtomicBlk := parsed.(*ApricotAtomicBlock)
-		require.Equal([]*txs.Tx{tx}, parsedAtomicBlk.Txs())
+		require.Equal([]*txs.Tx{atomicTx}, parsedAtomicBlk.Txs())
 	}
 }
 

vms/platformvm/block/proposal_block_test.go

@@ -10,10 +10,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/ava-labs/avalanchego/ids"
-	"github.com/ava-labs/avalanchego/vms/components/avax"
-	"github.com/ava-labs/avalanchego/vms/components/verify"
-	"github.com/ava-labs/avalanchego/vms/platformvm/txs"
-	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 )
 
 func TestNewBanffProposalBlock(t *testing.T) {
@@ -22,38 +18,22 @@ func TestNewBanffProposalBlock(t *testing.T) {
 	timestamp := time.Now().Truncate(time.Second)
 	parentID := ids.GenerateTestID()
 	height := uint64(1337)
-
-	tx := &txs.Tx{
-		Unsigned: &txs.AddValidatorTx{
-			BaseTx: txs.BaseTx{
-				BaseTx: avax.BaseTx{
-					Ins:  []*avax.TransferableInput{},
-					Outs: []*avax.TransferableOutput{},
-				},
-			},
-			StakeOuts: []*avax.TransferableOutput{},
-			Validator: txs.Validator{},
-			RewardsOwner: &secp256k1fx.OutputOwners{
-				Addrs: []ids.ShortID{},
-			},
-		},
-		Creds: []verify.Verifiable{},
-	}
-	require.NoError(tx.Initialize(txs.Codec))
+	proposalTx, err := testProposalTx()
+	require.NoError(err)
 
 	blk, err := NewBanffProposalBlock(
 		timestamp,
 		parentID,
 		height,
-		tx,
+		proposalTx,
 	)
 	require.NoError(err)
 
 	// Make sure the block and tx are initialized
 	require.NotEmpty(blk.Bytes())
 	require.NotEmpty(blk.Tx.Bytes())
 	require.NotEqual(ids.Empty, blk.Tx.ID())
-	require.Equal(tx.Bytes(), blk.Tx.Bytes())
+	require.Equal(proposalTx.Bytes(), blk.Tx.Bytes())
 	require.Equal(timestamp, blk.Timestamp())
 	require.Equal(parentID, blk.Parent())
 	require.Equal(height, blk.Height())
@@ -64,37 +44,21 @@ func TestNewApricotProposalBlock(t *testing.T) {
 
 	parentID := ids.GenerateTestID()
 	height := uint64(1337)
-
-	tx := &txs.Tx{
-		Unsigned: &txs.AddValidatorTx{
-			BaseTx: txs.BaseTx{
-				BaseTx: avax.BaseTx{
-					Ins:  []*avax.TransferableInput{},
-					Outs: []*avax.TransferableOutput{},
-				},
-			},
-			StakeOuts: []*avax.TransferableOutput{},
-			Validator: txs.Validator{},
-			RewardsOwner: &secp256k1fx.OutputOwners{
-				Addrs: []ids.ShortID{},
-			},
-		},
-		Creds: []verify.Verifiable{},
-	}
-	require.NoError(tx.Initialize(txs.Codec))
+	proposalTx, err := testProposalTx()
+	require.NoError(err)
 
 	blk, err := NewApricotProposalBlock(
 		parentID,
 		height,
-		tx,
+		proposalTx,
 	)
 	require.NoError(err)
 
 	// Make sure the block and tx are initialized
 	require.NotEmpty(blk.Bytes())
 	require.NotEmpty(blk.Tx.Bytes())
 	require.NotEqual(ids.Empty, blk.Tx.ID())
-	require.Equal(tx.Bytes(), blk.Tx.Bytes())
+	require.Equal(proposalTx.Bytes(), blk.Tx.Bytes())
 	require.Equal(parentID, blk.Parent())
 	require.Equal(height, blk.Height())
 }