prysm-pulse/beacon-chain/sync/validate_beacon_blocks_test.go
terence tsao 81c53c26fb Update run time to v0.9 (#3935)
* Update seed domains (#3872)

* Remove Transfers (#3870)

* Remove active index roots and compact committee roots (#3869)

* Update inclusion reward (#3886)

* Alter proposer selection logic (#3884)

* Fix early committee bias (#3888)

* Remove shards and committees (#3896)

* Epoch spec tests v0.9 (#3907)

* Block spec test v0.9 (#3905)

* rm'ed in protobuf

* build proto

* build proto

* build proto

* fix core package

* Gazelle

* Fixed all the tests

* Fixed static test

* Comment out spec test for now

* One more skip

* fix-roundRobinSync (#3862)

* Starting but need new seed function

* Revert initial sync

* Updated Proposer Slashing

* Fixed all tests

* Lint

* Update inclusion reward

* Fill randao mixes with eth1 data hash

* Test

* Fixing test part1

* All tests passing

* One last test

* Updated config

* Build proto

* Proper skip message

* Conflict and fmt

* Removed crosslinks and shards. Built

* Format and gazelle

* Fixed all the block package tests

* Fixed all the helper tests

* All epoch package tests pass

* All core package tests pass

* Fixed operation tests

* Started fixing rpc test

* RPC tests passed!

* Fixed all init sync tests

* All tests pass

* Fixed blockchain tests

* Lint

* Lint

* Preston's feedback

* Starting

* Remove container

* Fixed block spec tests

* All passing except for block_processing test

* Failing block processing test

* Starting

* Add AggregateAndProof

* All mainnet test passes

* Update deposit contract (#3906)

* Proto spec tests v0.9 (#3908)

* Starting

* Add AggregateAndProof

* Unskip block util tests (#3910)

* rm'ed in protobuf

* build proto

* build proto

* build proto

* fix core package

* Gazelle

* Fixed all the tests

* Fixed static test

* Comment out spec test for now

* One more skip

* fix-roundRobinSync (#3862)

* Starting but need new seed function

* Revert initial sync

* Updated Proposer Slashing

* Fixed all tests

* Lint

* Update inclusion reward

* Fill randao mixes with eth1 data hash

* Test

* Fixing test part1

* All tests passing

* One last test

* Updated config

* Build proto

* Proper skip message

* Conflict and fmt

* Removed crosslinks and shards. Built

* Format and gazelle

* Fixed all the block package tests

* Fixed all the helper tests

* All epoch package tests pass

* All core package tests pass

* Fixed operation tests

* Started fixing rpc test

* RPC tests passed!

* Fixed all init sync tests

* All tests pass

* Fixed blockchain tests

* Lint

* Lint

* Preston's feedback

* Starting

* Remove container

* Fixed block spec tests

* All passing except for block_processing test

* Failing block processing test

* Starting

* Add AggregateAndProof

* All mainnet test passes

* Unskip block util tests

* Slot processing spec test V0.9 (#3912)

* Starting

* Add AggregateAndProof

* Unskip slot processing mainnet test

* Unskip minimal spec test for finalization (#3920)

* Remove outdated interop tests (#3922)

* Rm outdated interop tests

* Rm test runner

* Gazelle

* Update validator to use proposer slot (#3919)

* Fix committee assignment (#3931)

* Replace shard with committee index (#3930)

* Conflict

* Clean up (#3933)

* Remove shard filter in db (#3936)

* Remove lightouse compatibility test (#3939)

* Update Committee Cache for v0.9 (#3948)

* Updated committee cache

* Removed shuffled indices cache

* Started testing run time

* Lint

* Fixed test

* Safeguard against nil head state

* address edge case

* add test

* Fixed TestRoundRobinSync by doubling the epochs

* Unskip TestProtoCompatability (#3958)

* Unskip TestProtoCompatability

* Update WORKSPACE

* Fix minimal config (#3959)

* fix minimal configs

* fix hardcoded value in test

* Simplify verify att time (#3961)

* update readme for deposit contract, regen bindings for vyper 0.1.0b12 (#3963)

* update readme for deposit contract, regen bindings

* medium

* Check nil base state (#3964)

* Copy Block When Receiving it From Sync (#3966)

* copy block

* clone for other service methods too

* Change logging of Bitfield  (#3956)

* change logging of bits

* preston's review

* Unskip Beacon Server Test (#3962)

* run test till the end

* fix up proto message types

* fmt

* resolve broken tests

* better error handling

* fixing new logic to use archived proposer info

* fix up logic

* clip using the max effective balance

* broken build fix with num arg mismatch

* amend archive

* archival logic changed

* rename test

* archive both proposer and attester seeds

* page size 100

* further experiments

* further experimentation, archivedProposerIndex seems wrong

* test passes

* rem log

* fix broken test

* fix test

* gaz

* fix imports

* ethapis
2019-11-11 17:03:43 -05:00

348 lines
8.4 KiB
Go

package sync
import (
"context"
"strings"
"testing"
"time"
mock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
dbtest "github.com/prysmaticlabs/prysm/beacon-chain/db/testing"
p2ptest "github.com/prysmaticlabs/prysm/beacon-chain/p2p/testing"
mockSync "github.com/prysmaticlabs/prysm/beacon-chain/sync/initial-sync/testing"
ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
"github.com/prysmaticlabs/prysm/shared/bls"
"github.com/prysmaticlabs/prysm/shared/bytesutil"
"github.com/prysmaticlabs/prysm/shared/testutil"
)
// General note for writing validation tests: Use a random value for any field
// on the beacon block to avoid hitting shared global cache conditions across
// tests in this package.
func TestValidateBeaconBlockPubSub_InvalidSignature(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
msg := &ethpb.BeaconBlock{
Slot: 1,
ParentRoot: testutil.Random32Bytes(t),
Signature: []byte("fake"),
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{Genesis: time.Now(),
FinalizedCheckPoint: &ethpb.Checkpoint{
Epoch: 0,
}},
}
result, err := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if err == nil {
t.Error("expected an error")
}
if result {
t.Error("Expected false result, got true")
}
if mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was called when it should not have been called")
}
}
func TestValidateBeaconBlockPubSub_BlockAlreadyPresentInDB(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
msg := &ethpb.BeaconBlock{
Slot: 100,
ParentRoot: testutil.Random32Bytes(t),
}
if err := db.SaveBlock(context.Background(), msg); err != nil {
t.Fatal(err)
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{Genesis: time.Now()},
}
result, _ := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if result {
t.Error("Expected false result, got true")
}
if mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was called when it should not have been called")
}
}
func TestValidateBeaconBlockPubSub_BlockAlreadyPresentInCache(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
b := []byte("sk")
b32 := bytesutil.ToBytes32(b)
sk, err := bls.SecretKeyFromBytes(b32[:])
if err != nil {
t.Fatal(err)
}
msg := &ethpb.BeaconBlock{
ParentRoot: testutil.Random32Bytes(t),
Signature: sk.Sign([]byte("data"), 0).Marshal(),
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{Genesis: time.Now(),
FinalizedCheckPoint: &ethpb.Checkpoint{
Epoch: 0,
}},
}
result, err := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if err != nil {
t.Errorf("Expected no error, got: %v", err)
}
if !result {
t.Error("Expected true result, got false")
}
if !mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was not called when it should have been called")
}
// The value should be cached now so the second request will fail.
mockBroadcaster.BroadcastCalled = false
result, _ = r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if result {
t.Error("Expected false result, got true")
}
if mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was called when it should not have been called")
}
}
func TestValidateBeaconBlockPubSub_ValidSignature(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
b := []byte("sk")
b32 := bytesutil.ToBytes32(b)
sk, err := bls.SecretKeyFromBytes(b32[:])
if err != nil {
t.Fatal(err)
}
msg := &ethpb.BeaconBlock{
ParentRoot: testutil.Random32Bytes(t),
Signature: sk.Sign([]byte("data"), 0).Marshal(),
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{Genesis: time.Now(),
FinalizedCheckPoint: &ethpb.Checkpoint{
Epoch: 0,
}},
}
result, _ := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if !result {
t.Error("Expected true result, got false")
}
if !mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was not called when it should have been called")
}
}
func TestValidateBeaconBlockPubSub_ValidSignature_FromSelf(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
b := []byte("sk")
b32 := bytesutil.ToBytes32(b)
sk, err := bls.SecretKeyFromBytes(b32[:])
if err != nil {
t.Fatal(err)
}
msg := &ethpb.BeaconBlock{
Slot: 1,
ParentRoot: testutil.Random32Bytes(t),
Signature: sk.Sign([]byte("data"), 0).Marshal(),
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{Genesis: time.Now()},
}
result, _ := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
true, // fromSelf
)
if result {
t.Error("Expected false result, got true")
}
if mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was called when it should not have been called")
}
}
func TestValidateBeaconBlockPubSub_Syncing(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
b := []byte("sk")
b32 := bytesutil.ToBytes32(b)
sk, err := bls.SecretKeyFromBytes(b32[:])
if err != nil {
t.Fatal(err)
}
msg := &ethpb.BeaconBlock{
ParentRoot: testutil.Random32Bytes(t),
Signature: sk.Sign([]byte("data"), 0).Marshal(),
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: true},
chain: &mock.ChainService{
Genesis: time.Now(),
FinalizedCheckPoint: &ethpb.Checkpoint{
Epoch: 0,
}},
}
result, _ := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if result {
t.Error("Expected false result, got true")
}
if !mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was not called when it should have been called")
}
}
func TestValidateBeaconBlockPubSub_RejectBlocksFromFuture(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
b := []byte("sk")
b32 := bytesutil.ToBytes32(b)
sk, err := bls.SecretKeyFromBytes(b32[:])
if err != nil {
t.Fatal(err)
}
msg := &ethpb.BeaconBlock{
ParentRoot: testutil.Random32Bytes(t),
Signature: sk.Sign([]byte("data"), 0).Marshal(),
Slot: 1000,
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{Genesis: time.Now()},
}
result, err := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if err == nil || !strings.Contains(err.Error(), "could not process slot from the future") {
t.Errorf("Err = %v, wanted substring %s", err, "could not process slot from the future")
}
if result {
t.Error("Expected false result, got true")
}
if mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was called when it should not have been called")
}
}
func TestValidateBeaconBlockPubSub_RejectBlocksFromThePast(t *testing.T) {
db := dbtest.SetupDB(t)
defer dbtest.TeardownDB(t, db)
b := []byte("sk")
b32 := bytesutil.ToBytes32(b)
sk, err := bls.SecretKeyFromBytes(b32[:])
if err != nil {
t.Fatal(err)
}
msg := &ethpb.BeaconBlock{
ParentRoot: testutil.Random32Bytes(t),
Signature: sk.Sign([]byte("data"), 0).Marshal(),
Slot: 10,
}
mockBroadcaster := &p2ptest.MockBroadcaster{}
genesisTime := time.Now()
r := &RegularSync{
db: db,
initialSync: &mockSync.Sync{IsSyncing: false},
chain: &mock.ChainService{
Genesis: time.Unix(genesisTime.Unix()-1000, 0),
FinalizedCheckPoint: &ethpb.Checkpoint{
Epoch: 1,
}},
}
result, err := r.validateBeaconBlockPubSub(
context.Background(),
msg,
mockBroadcaster,
false, // fromSelf
)
if result {
t.Error("Expected false result, got true")
}
if mockBroadcaster.BroadcastCalled {
t.Error("Broadcast was called when it should not have been called")
}
}