prysm-pulse/beacon-chain/sync/utils_test.go
Nishant Das c725a9c8f2
Sort Duplicate Blocks In Response (#6222)
* sort out new blocks
* add unit test
* Merge refs/heads/master into sortDuplicates
* victor's review
* Merge branch 'sortDuplicates' of https://github.com/prysmaticlabs/geth-sharding into sortDuplicates
* Merge refs/heads/master into sortDuplicates
2020-06-12 13:50:07 +00:00

113 lines
3.4 KiB
Go

package sync
import (
"math/rand"
"testing"
"time"
ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/params"
"github.com/prysmaticlabs/prysm/shared/roughtime"
)
func TestSortedObj_SortBlocksRoots(t *testing.T) {
source := rand.NewSource(33)
randGen := rand.New(source)
blks := []*ethpb.SignedBeaconBlock{}
roots := [][32]byte{}
randFunc := func() int64 {
return randGen.Int63n(50)
}
for i := 0; i < 10; i++ {
slot := uint64(randFunc())
newBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot}}
blks = append(blks, newBlk)
root := bytesutil.ToBytes32(bytesutil.Bytes32(slot))
roots = append(roots, root)
}
r := &Service{}
newBlks, newRoots := r.sortBlocksAndRoots(blks, roots)
previousSlot := uint64(0)
for i, b := range newBlks {
if b.Block.Slot < previousSlot {
t.Errorf("Block list is not sorted as %d is smaller than previousSlot %d", b.Block.Slot, previousSlot)
}
if bytesutil.FromBytes8(newRoots[i][:]) != b.Block.Slot {
t.Errorf("root doesn't match stored slot in block: wanted %d but got %d", b.Block.Slot, bytesutil.FromBytes8(newRoots[i][:]))
}
previousSlot = b.Block.Slot
}
}
func TestSortedObj_NoDuplicates(t *testing.T) {
source := rand.NewSource(33)
randGen := rand.New(source)
blks := []*ethpb.SignedBeaconBlock{}
roots := [][32]byte{}
randFunc := func() int64 {
return randGen.Int63n(50)
}
for i := 0; i < 10; i++ {
slot := uint64(randFunc())
newBlk := &ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Slot: slot}}
// append twice
blks = append(blks, newBlk)
blks = append(blks, newBlk)
// append twice
root := bytesutil.ToBytes32(bytesutil.Bytes32(slot))
roots = append(roots, root)
roots = append(roots, root)
}
r := &Service{}
newBlks, newRoots := r.dedupBlocksAndRoots(blks, roots)
rootMap := make(map[[32]byte]bool)
for i, b := range newBlks {
if rootMap[newRoots[i]] {
t.Errorf("Duplicated root exists %#x with block %v", newRoots[i], b)
}
rootMap[newRoots[i]] = true
}
}
func TestValidateAggregatedTime_ValidatesCorrectly(t *testing.T) {
const genesisOffset = 1200
genTime := roughtime.Now().Add(-(genesisOffset * time.Second))
currSlot := helpers.SlotsSince(genTime)
invalidAttSlot := currSlot - params.BeaconNetworkConfig().AttestationPropagationSlotRange - 1
err := validateAggregateAttTime(invalidAttSlot, genTime)
if err == nil {
t.Error("Expected attestation time to be invalid, but it was marked as valid")
}
timePerSlot := time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
// adjusts the genesis time to allow for the clock disparity to
// allow for the attestation to be valid.
clockAllowance := params.BeaconNetworkConfig().MaximumGossipClockDisparity * 8 / 10
newTime := genTime.Add(timePerSlot - clockAllowance)
err = validateAggregateAttTime(invalidAttSlot, newTime)
if err != nil {
t.Errorf("Expected attestation time to be valid, but it was not: %v", err)
}
// re-determine the current slot
currSlot = helpers.SlotsSince(genTime)
err = validateAggregateAttTime(currSlot+1, genTime)
if err == nil {
t.Error("Expected attestation time to be invalid, but it was marked as valid")
}
err = validateAggregateAttTime(currSlot-10, genTime)
if err != nil {
t.Errorf("Expected attestation time to be valid, but it was not: %v", err)
}
}