test: add test.Scheduler (#58)

When simulating execution of core.Consensus by passing packets through golang-channel or real-socket, we need to utilize time.Sleep and time.Now to simulate the required network/proposing latency. It's problematic when we try to test a simulation with long network latency.

Instead, Scheduler would try to execute the event with minimum timestamp, thus time.Sleep is replaced with Scheduler.nextTick, and time.Now is replaced with Event.Time.

Changes:
- Add test.Scheduler.
- Add test.Stopper interface to provide encapsulate different stop conditions for scheduler.
- Add a reference implementation for test.Stopper, it will stop scheduler when all validators confirmed X blocks proposed from themselves.
- Add a test scenario on core.Consensus that all validators are not byzantine.

3 files changed, 265 insertions, 0 deletions

diff --git a/integration_test/latency.go b/integration_test/latency.go
new file mode 100644
index 0000000..383d069
--- /dev/null
+++ b/integration_test/latency.go
@@ -0,0 +1,44 @@
+// Copyright 2018 The dexon-consensus-core Authors
+// This file is part of the dexon-consensus-core library.
+//
+// The dexon-consensus-core library is free software: you can redistribute it
+// and/or modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The dexon-consensus-core library is distributed in the hope that it will be
+// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the dexon-consensus-core library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package integration
+
+import (
+	"math/rand"
+	"time"
+)
+
+// LatencyModel defines an interface to randomly decide latency
+// for one operation.
+type LatencyModel interface {
+	Delay() time.Duration
+}
+
+// normalLatencyModel would return latencies in normal distribution.
+type normalLatencyModel struct {
+	Sigma float64
+	Mean  float64
+}
+
+// Delay implements LatencyModel interface.
+func (m *normalLatencyModel) Delay() time.Duration {
+	delay := rand.NormFloat64()*m.Sigma + m.Mean
+	if delay < 0 {
+		delay = m.Sigma / 2
+	}
+	return time.Duration(delay) * time.Millisecond
+}
diff --git a/integration_test/non-byzantine_test.go b/integration_test/non-byzantine_test.go
new file mode 100644
index 0000000..111dcd0
--- /dev/null
+++ b/integration_test/non-byzantine_test.go
@@ -0,0 +1,90 @@
+// Copyright 2018 The dexon-consensus-core Authors
+// This file is part of the dexon-consensus-core library.
+//
+// The dexon-consensus-core library is free software: you can redistribute it
+// and/or modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The dexon-consensus-core library is distributed in the hope that it will be
+// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the dexon-consensus-core library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package integration
+
+import (
+	"testing"
+	"time"
+
+	"github.com/dexon-foundation/dexon-consensus-core/blockdb"
+	"github.com/dexon-foundation/dexon-consensus-core/core/test"
+	"github.com/dexon-foundation/dexon-consensus-core/core/types"
+	"github.com/stretchr/testify/suite"
+)
+
+type NonByzantineTestSuite struct {
+	suite.Suite
+}
+
+func (s *NonByzantineTestSuite) TestNonByzantine() {
+	var (
+		networkLatency = &normalLatencyModel{
+			Sigma: 20,
+			Mean:  250,
+		}
+		proposingLatency = &normalLatencyModel{
+			Sigma: 30,
+			Mean:  500,
+		}
+		apps = make(map[types.ValidatorID]*test.App)
+		dbs  = make(map[types.ValidatorID]blockdb.BlockDatabase)
+		req  = s.Require()
+	)
+
+	gov, err := test.NewGovernance(25, 700)
+	req.Nil(err)
+	now := time.Now().UTC()
+	for vID := range gov.GetValidatorSet() {
+		apps[vID] = test.NewApp()
+
+		db, err := blockdb.NewMemBackedBlockDB()
+		req.Nil(err)
+		dbs[vID] = db
+	}
+	stopper := test.NewStopByConfirmedBlocks(50, apps, dbs)
+	sch := test.NewScheduler(stopper)
+	for vID := range gov.GetValidatorSet() {
+		key, err := gov.GetPrivateKey(vID)
+		req.Nil(err)
+		v := newValidator(
+			apps[vID],
+			gov,
+			dbs[vID],
+			key,
+			vID,
+			networkLatency,
+			proposingLatency)
+		sch.RegisterEventHandler(vID, v)
+		req.Nil(sch.Seed(newProposeBlockEvent(vID, now)))
+	}
+	sch.Run(10)
+	// Check results by comparing test.App instances.
+	for vFrom := range gov.GetValidatorSet() {
+		req.Nil(apps[vFrom].Verify())
+		for vTo := range gov.GetValidatorSet() {
+			if vFrom == vTo {
+				continue
+			}
+			req.Nil(apps[vFrom].Compare(apps[vTo]))
+		}
+	}
+}
+
+func TestNonByzantine(t *testing.T) {
+	suite.Run(t, new(NonByzantineTestSuite))
+}
diff --git a/integration_test/validator.go b/integration_test/validator.go
new file mode 100644
index 0000000..00ffff2
--- /dev/null
+++ b/integration_test/validator.go
@@ -0,0 +1,131 @@
+// Copyright 2018 The dexon-consensus-core Authors
+// This file is part of the dexon-consensus-core library.
+//
+// The dexon-consensus-core library is free software: you can redistribute it
+// and/or modify it under the terms of the GNU Lesser General Public License as
+// published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The dexon-consensus-core library is distributed in the hope that it will be
+// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the dexon-consensus-core library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package integration
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/dexon-foundation/dexon-consensus-core/blockdb"
+	"github.com/dexon-foundation/dexon-consensus-core/core"
+	"github.com/dexon-foundation/dexon-consensus-core/core/test"
+	"github.com/dexon-foundation/dexon-consensus-core/core/types"
+	"github.com/dexon-foundation/dexon-consensus-core/crypto"
+	"github.com/dexon-foundation/dexon-consensus-core/crypto/eth"
+)
+
+type consensusEventType int
+
+const (
+	evtProposeBlock consensusEventType = iota
+	evtReceiveBlock
+)
+
+type consensusEventPayload struct {
+	Type      consensusEventType
+	PiggyBack interface{}
+}
+
+func newProposeBlockEvent(vID types.ValidatorID, when time.Time) *test.Event {
+	return test.NewEvent(vID, when, &consensusEventPayload{
+		Type: evtProposeBlock,
+	})
+}
+
+func newReceiveBlockEvent(
+	vID types.ValidatorID, when time.Time, block *types.Block) *test.Event {
+
+	return test.NewEvent(vID, when, &consensusEventPayload{
+		Type:      evtReceiveBlock,
+		PiggyBack: block,
+	})
+}
+
+type validator struct {
+	ID               types.ValidatorID
+	cons             *core.Consensus
+	gov              core.Governance
+	networkLatency   LatencyModel
+	proposingLatency LatencyModel
+}
+
+func newValidator(
+	app core.Application,
+	gov core.Governance,
+	db blockdb.BlockDatabase,
+	privateKey crypto.PrivateKey,
+	vID types.ValidatorID,
+	networkLatency LatencyModel,
+	proposingLatency LatencyModel) *validator {
+
+	return &validator{
+		ID:               vID,
+		gov:              gov,
+		networkLatency:   networkLatency,
+		proposingLatency: proposingLatency,
+		cons: core.NewConsensus(
+			app, gov, db, privateKey, eth.SigToPub),
+	}
+}
+
+func (v *validator) Handle(e *test.Event) (events []*test.Event) {
+	payload := e.Payload.(*consensusEventPayload)
+	switch payload.Type {
+	case evtProposeBlock:
+		events, e.ExecError = v.handleProposeBlock(e.Time, payload.PiggyBack)
+	case evtReceiveBlock:
+		events, e.ExecError = v.handleReceiveBlock(payload.PiggyBack)
+	default:
+		panic(fmt.Errorf("unknown consensus event type: %v", payload.Type))
+	}
+	return
+}
+
+func (v *validator) handleProposeBlock(when time.Time, piggyback interface{}) (
+	events []*test.Event, err error) {
+
+	b := &types.Block{ProposerID: v.ID}
+	if err = v.cons.PrepareBlock(b, when); err != nil {
+		return
+	}
+	if err = v.cons.ProcessBlock(b); err != nil {
+		return
+	}
+	// Create 'block received' event for each other validators.
+	for vID := range v.gov.GetValidatorSet() {
+		if vID == v.ID {
+			continue
+		}
+		events = append(events, newReceiveBlockEvent(
+			vID, when.Add(v.networkLatency.Delay()), b.Clone()))
+	}
+	// Create next 'block proposing' event for this validators.
+	events = append(events, newProposeBlockEvent(
+		v.ID, when.Add(v.proposingLatency.Delay())))
+	return
+}
+
+func (v *validator) handleReceiveBlock(piggyback interface{}) (
+	events []*test.Event, err error) {
+
+	err = v.cons.ProcessBlock(piggyback.(*types.Block))
+	if err != nil {
+		panic(err)
+	}
+	return
+}