Skip to content

Commit

Permalink
Test fixes
Browse files Browse the repository at this point in the history
  • Loading branch information
wanwiset25 committed May 10, 2024
1 parent c11ae59 commit a48de06
Show file tree
Hide file tree
Showing 9 changed files with 260 additions and 61 deletions.
2 changes: 1 addition & 1 deletion consensus/tests/engine_v2_tests/adaptor_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -136,7 +136,7 @@ func TestAdaptorGetMasternodesV2(t *testing.T) {
err := blockchain.InsertBlock(currentBlock)
assert.Nil(t, err)
masternodes1 := adaptor.GetMasternodes(blockchain, currentBlock.Header())
assert.Equal(t, 20, len(masternodes1))
assert.Equal(t, 5, len(masternodes1))
masternodes1ByNumber := adaptor.GetMasternodesByNumber(blockchain, currentBlock.NumberU64())
assert.True(t, reflect.DeepEqual(masternodes1, masternodes1ByNumber), "at block number", blockNum)
for blockNum = 902; blockNum < 915; blockNum++ {
Expand Down
99 changes: 99 additions & 0 deletions consensus/tests/engine_v2_tests/api_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,99 @@
package engine_v2_tests

import (
"math/big"
"testing"

"github.com/XinFinOrg/XDC-Subnet/consensus/XDPoS"
"github.com/XinFinOrg/XDC-Subnet/core/types"
"github.com/XinFinOrg/XDC-Subnet/params"
"github.com/XinFinOrg/XDC-Subnet/rpc"
"github.com/stretchr/testify/assert"
)

func TestGetMissedRoundsInEpochByBlockNumReturnEmptyForV2(t *testing.T) {
_, bc, cb, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig)

engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS)
blockNum := rpc.BlockNumber(cb.NumberU64())

data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum)

assert.Nil(t, err)
assert.Equal(t, types.Round(1800), data.EpochRound)
assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber)
assert.Equal(t, 0, len(data.MissedRounds))

blockNum = rpc.BlockNumber(1800)

data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum)

assert.Nil(t, err)
assert.Equal(t, types.Round(1800), data.EpochRound)
assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber)
assert.Equal(t, 0, len(data.MissedRounds))

blockNum = rpc.BlockNumber(1801)

data, err = engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum)

assert.Nil(t, err)
assert.Equal(t, types.Round(1800), data.EpochRound)
assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber)
assert.Equal(t, 0, len(data.MissedRounds))
}

func TestGetMissedRoundsInEpochByBlockNumReturnEmptyForV2FistEpoch(t *testing.T) {
_, bc, _, _, _ := PrepareXDCTestBlockChainWith128Candidates(t, 10, params.TestXDPoSMockChainConfig)

engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS)
blockNum := rpc.BlockNumber(2)

data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum)

assert.Nil(t, err)
assert.Equal(t, types.Round(0), data.EpochRound)
assert.Equal(t, big.NewInt(0), data.EpochBlockNumber)
assert.Equal(t, 0, len(data.MissedRounds))
}

func TestGetMissedRoundsInEpochByBlockNum(t *testing.T) {
blockchain, bc, currentBlock, signer, signFn := PrepareXDCTestBlockChainWith128Candidates(t, 1802, params.TestXDPoSMockChainConfig)
chainConfig := params.TestXDPoSMockChainConfig
engine := bc.GetBlockChain().Engine().(*XDPoS.XDPoS)
blockCoinBase := signer.Hex()

startingBlockNum := currentBlock.Number().Int64() + 1
// Skipped the round
roundNumber := startingBlockNum + 2
block := CreateBlock(blockchain, chainConfig, currentBlock, int(startingBlockNum), roundNumber, blockCoinBase, signer, signFn, nil, nil, "c2bf7b59be5184fc1148be5db14692b2dc89a1b345895d3e8d0ee7b8a7607450")
err := blockchain.InsertBlock(block)
if err != nil {
t.Fatal(err)
}

// Update Signer as there is no previous signer assigned
err = UpdateSigner(blockchain)
if err != nil {
t.Fatal(err)
}

blockNum := rpc.BlockNumber(1803)

data, err := engine.APIs(bc.GetBlockChain())[0].Service.(*XDPoS.API).GetMissedRoundsInEpochByBlockNum(&blockNum)

assert.Nil(t, err)
assert.Equal(t, types.Round(1800), data.EpochRound)
assert.Equal(t, big.NewInt(1800), data.EpochBlockNumber)
assert.Equal(t, 2, len(data.MissedRounds))
assert.NotEmpty(t, data.MissedRounds[0].Miner)
assert.Equal(t, data.MissedRounds[0].Round, types.Round(1803))
assert.Equal(t, data.MissedRounds[0].CurrentBlockNum, big.NewInt(1803))
assert.Equal(t, data.MissedRounds[0].ParentBlockNum, big.NewInt(1802))
assert.NotEmpty(t, data.MissedRounds[1].Miner)
assert.Equal(t, data.MissedRounds[1].Round, types.Round(1804))
assert.Equal(t, data.MissedRounds[0].CurrentBlockNum, big.NewInt(1803))
assert.Equal(t, data.MissedRounds[0].ParentBlockNum, big.NewInt(1802))

assert.NotEqual(t, data.MissedRounds[0].Miner, data.MissedRounds[1].Miner)
}
19 changes: 9 additions & 10 deletions consensus/tests/engine_v2_tests/authorised_masternode_test.go
Original file line number Diff line number Diff line change
@@ -1,7 +1,6 @@
package engine_v2_tests

import (
"fmt"
"math/big"
"testing"
"time"
Expand Down Expand Up @@ -47,21 +46,21 @@ func TestIsYourTurnConsensusV2(t *testing.T) {
err := blockchain.InsertBlock(currentBlock)
assert.Nil(t, err)
// Less then Mine Period
isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, common.StringToAddress(fmt.Sprintf("%02d", 2)))
isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, acc2Addr)
assert.Nil(t, err)
assert.False(t, isYourTurn)

time.Sleep(time.Duration(minePeriod) * time.Second)
// The second address is valid as the round starting from 1
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, common.StringToAddress(fmt.Sprintf("%02d", 2)))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc2Addr)
assert.Nil(t, err)
assert.True(t, isYourTurn)

// The first and third address are not valid
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 1)))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
assert.Nil(t, err)
assert.False(t, isYourTurn)
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 3)))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc3Addr)
assert.Nil(t, err)
assert.False(t, isYourTurn)

Expand All @@ -73,13 +72,13 @@ func TestIsYourTurnConsensusV2(t *testing.T) {
time.Sleep(time.Duration(minePeriod) * time.Second)

adaptor.EngineV2.SetNewRoundFaker(blockchain, 2, false)
isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 2)))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc2Addr)
assert.False(t, isYourTurn)

isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 3)))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc3Addr)
assert.True(t, isYourTurn)

isYourTurn, _ = adaptor.YourTurn(blockchain, currentBlock.Header(), common.StringToAddress(fmt.Sprintf("%02d", 1)))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
assert.False(t, isYourTurn)

}
Expand All @@ -100,7 +99,7 @@ func TestIsYourTurnConsensusV2CrossConfig(t *testing.T) {
assert.Nil(t, err)
// after first mine period
time.Sleep(time.Duration(firstMinePeriod) * time.Second)
isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, common.HexToAddress("xdc0000000000000000000000000000000000003131"))
isYourTurn, err := adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
assert.Nil(t, err)
assert.False(t, isYourTurn)

Expand All @@ -110,7 +109,7 @@ func TestIsYourTurnConsensusV2CrossConfig(t *testing.T) {
secondMinePeriod := blockchain.Config().XDPoS.V2.CurrentConfig.MinePeriod

time.Sleep(time.Duration(secondMinePeriod-firstMinePeriod) * time.Second)
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, common.HexToAddress("xdc0000000000000000000000000000000000003131"))
isYourTurn, err = adaptor.YourTurn(blockchain, currentBlockHeader, acc1Addr)
assert.Nil(t, err)
assert.True(t, isYourTurn)
}
35 changes: 21 additions & 14 deletions consensus/tests/engine_v2_tests/helper.go
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,6 @@ import (
"crypto/ecdsa"
"encoding/hex"
"fmt"
"io/ioutil"
"math/big"
"math/rand"
"os"
Expand Down Expand Up @@ -78,7 +77,7 @@ func RandStringBytes(n int) string {
func getSignerAndSignFn(pk *ecdsa.PrivateKey) (common.Address, func(account accounts.Account, hash []byte) ([]byte, error), error) {
veryLightScryptN := 2
veryLightScryptP := 1
dir, _ := ioutil.TempDir("", fmt.Sprintf("eth-getSignerAndSignFn-test-%v", RandStringBytes(5)))
dir, _ := os.MkdirTemp("", fmt.Sprintf("eth-getSignerAndSignFn-test-%v", RandStringBytes(5)))

new := func(kd string) *keystore.KeyStore {
return keystore.NewKeyStore(kd, veryLightScryptN, veryLightScryptP)
Expand Down Expand Up @@ -124,14 +123,6 @@ func getCommonBackend(t *testing.T, chainConfig *params.ChainConfig, signer comm

var candidates []common.Address
var caps []*big.Int
defalutCap := new(big.Int)
defalutCap.SetString("1000000000", 10)

for i := 1; i <= 15; i++ {
addr := fmt.Sprintf("%02d", i)
candidates = append(candidates, common.StringToAddress(addr)) // StringToAddress does not exist
caps = append(caps, defalutCap)
}

acc1Cap, acc2Cap, acc3Cap, voterCap, signerCap := new(big.Int), new(big.Int), new(big.Int), new(big.Int), new(big.Int)

Expand All @@ -141,8 +132,9 @@ func getCommonBackend(t *testing.T, chainConfig *params.ChainConfig, signer comm
voterCap.SetString("10000002", 10)
signerCap.SetString("10000001", 10)

caps = append(caps, voterCap, acc1Cap, acc2Cap, acc3Cap, signerCap)
candidates = append(candidates, voterAddr, acc1Addr, acc2Addr, acc3Addr, signer)
caps = append(caps, acc1Cap, acc2Cap, acc3Cap, signerCap, voterCap)
candidates = append(candidates, acc1Addr, acc2Addr, acc3Addr, signer, voterAddr)

// initial helper backend
contractBackendForSC := backends.NewXDCSimulatedBackend(core.GenesisAlloc{
voterAddr: {Balance: new(big.Int).SetUint64(10000000000)},
Expand Down Expand Up @@ -572,6 +564,19 @@ func PrepareXDCTestBlockChainWith128Candidates(t *testing.T, numOfBlocks int, ch
if err != nil {
t.Fatal(err)
}

//FROM XDPOS: find v2 switch block, don't need in subnet
// First v2 block
// if (int64(i) - chainConfig.XDPoS.V2.SwitchBlock.Int64()) == 1 {
// lastv1BlockNumber := block.Header().Number.Uint64() - 1
// checkpointBlockNumber := lastv1BlockNumber - lastv1BlockNumber%chainConfig.XDPoS.Epoch
// checkpointHeader := blockchain.GetHeaderByNumber(checkpointBlockNumber)
// err := engine.EngineV2.Initial(blockchain, checkpointHeader)
// if err != nil {
// panic(err)
// }
// }

currentBlock = block
}

Expand Down Expand Up @@ -609,7 +614,7 @@ func PrepareQCandProcess(t *testing.T, blockchain *BlockChain, currentBlock *typ
func CreateBlock(blockchain *BlockChain, chainConfig *params.ChainConfig, startingBlock *types.Block, blockNumber int, roundNumber int64, blockCoinBase string, signer common.Address, signFn func(account accounts.Account, hash []byte) ([]byte, error), penalties []common.Address, signersKey []*ecdsa.PrivateKey, merkleRoot string) *types.Block {
currentBlock := startingBlock
if len(merkleRoot) == 0 {
merkleRoot = "b3e34cf1d3d80bcd2c5add880842892733e45979ddaf16e531f660fdf7ca5787"
merkleRoot = "711be05c0b9d89bd511dd4c20ade1820b2c1fb13343ee0cedd3869150eb2d377"
}
var header *types.Header
statedb, err := blockchain.State()
Expand Down Expand Up @@ -757,6 +762,8 @@ func findSignerAndSignFn(bc *BlockChain, header *types.Header, signer common.Add
} else if index == 3 {
// Skip signing anything for voterAddress to simulate penalty
return signer, signFn
} else if index == 4 {
_, signFn, err = getSignerAndSignFn(voterKey)
}
addressedSignFn = signFn
if err != nil {
Expand All @@ -781,7 +788,7 @@ func sealHeader(bc *BlockChain, header *types.Header, signer common.Address, sig
func getMasternodesList(signer common.Address) []common.Address {
var masternodes []common.Address
// Place the test's signer address to the last
masternodes = append(masternodes, acc1Addr, acc2Addr, acc3Addr, signer)
masternodes = append(masternodes, acc1Addr, acc2Addr, acc3Addr, signer, voterAddr)
return masternodes
}

Expand Down
12 changes: 6 additions & 6 deletions consensus/tests/engine_v2_tests/mine_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ func TestYourTurnInitialV2(t *testing.T) {
t.Logf("Inserting block with propose at 11...")
blockCoinbaseA := "0xaaa0000000000000000000000000000000000011"
//Get from block validator error message
merkleRoot := "b3e34cf1d3d80bcd2c5add880842892733e45979ddaf16e531f660fdf7ca5787"
merkleRoot := "711be05c0b9d89bd511dd4c20ade1820b2c1fb13343ee0cedd3869150eb2d377"
extraInBytes := generateV2Extra(11, parentBlock, signer, signFn, nil)

header := &types.Header{
Expand All @@ -55,10 +55,10 @@ func TestYourTurnInitialV2(t *testing.T) {
time.Sleep(time.Duration(minePeriod) * time.Second)

// YourTurn is called before mine first v2 block
b, err := adaptor.YourTurn(blockchain, block11.Header(), common.HexToAddress("xdc0000000000000000000000000000000000003031"))
b, err := adaptor.YourTurn(blockchain, block11.Header(), acc1Addr)
assert.Nil(t, err)
assert.False(t, b)
b, err = adaptor.YourTurn(blockchain, block11.Header(), common.HexToAddress("xdc0000000000000000000000000000000000003132"))
b, err = adaptor.YourTurn(blockchain, block11.Header(), acc2Addr)
assert.Nil(t, err)
// round=1, so masternode[1] has YourTurn = True
assert.True(t, b)
Expand All @@ -79,7 +79,7 @@ func TestShouldMineOncePerRound(t *testing.T) {
_, err := adaptor.Seal(blockchain, block910, nil)
assert.Nil(t, err)
time.Sleep(time.Duration(minePeriod) * time.Second)
merkleRoot := "b3e34cf1d3d80bcd2c5add880842892733e45979ddaf16e531f660fdf7ca5787"
merkleRoot := "711be05c0b9d89bd511dd4c20ade1820b2c1fb13343ee0cedd3869150eb2d377"

header := &types.Header{
Root: common.HexToHash(merkleRoot),
Expand Down Expand Up @@ -128,7 +128,7 @@ func TestUpdateMasterNodes(t *testing.T) {
t.Fatal(err)
}
//Get from block validator error message
merkleRoot := "42970e0f2265db7d85d0d9cd7328d58bd53bdb54d85d7997e95a1c3f60845602"
merkleRoot := "2f34d88e4afb95a51b5dd3b157bdec944790c033bbf6e990cc7f946ad07d47c4"
header := &types.Header{
Root: common.HexToHash(merkleRoot),
Number: big.NewInt(int64(1350)),
Expand Down Expand Up @@ -209,7 +209,7 @@ func TestPrepareFail(t *testing.T) {
err = adaptor.Prepare(blockchain, notReadyToMine)
assert.Equal(t, consensus.ErrNotReadyToMine, err)

adaptor.EngineV2.SetNewRoundFaker(blockchain, types.Round(19), false)
adaptor.EngineV2.SetNewRoundFaker(blockchain, types.Round(18), false)
header901WithoutCoinbase := &types.Header{
ParentHash: currentBlock.ParentHash(),
Number: big.NewInt(int64(901)),
Expand Down
2 changes: 1 addition & 1 deletion consensus/tests/engine_v2_tests/penalty_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -33,7 +33,7 @@ func TestHookPenaltyV2TwoEpoch(t *testing.T) {
header450 := blockchain.GetHeaderByNumber(450)
penalty, err := adaptor.EngineV2.HookPenalty(blockchain, header450.Number, header450.ParentHash, masternodes, config.XDPoS)
assert.Nil(t, err)
assert.Equal(t, 125, len(penalty)) // we have 4 miners created for all blocks, 3 is among 128 masternode candidates (test issue, no need to fix). So 125 candidates left are penalties
assert.Equal(t, 124, len(penalty)) // we have 4 miners created for all blocks, 3 is among 128 masternode candidates (test issue, no need to fix). So 125 candidates left are penalties

header1335 := blockchain.GetHeaderByNumber(config.XDPoS.Epoch + config.XDPoS.Gap - uint64(common.MergeSignRange))
tx, err := signingTxWithKey(header1335, 0, voterKey)
Expand Down
Loading

0 comments on commit a48de06

Please sign in to comment.