// Copyright 2018 The dexon-consensus Authors
// This file is part of the dexon-consensus library.
//
// The dexon-consensus 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 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 library. If not, see
// <http://www.gnu.org/licenses/>.
package test
import (
"testing"
"time"
"github.com/dexon-foundation/dexon-consensus/common"
"github.com/dexon-foundation/dexon-consensus/core/blockdb"
"github.com/dexon-foundation/dexon-consensus/core/types"
"github.com/stretchr/testify/suite"
)
type RevealerTestSuite struct {
suite.Suite
db blockdb.BlockDatabase
totalBlockCount int
}
func (s *RevealerTestSuite) SetupSuite() {
var (
err error
genesisTime = time.Now().UTC()
)
// Setup block database.
s.db, err = blockdb.NewMemBackedBlockDB()
s.Require().NoError(err)
// Randomly generate blocks.
config := &BlocksGeneratorConfig{
NumChains: 19,
MinBlockTimeInterval: 250 * time.Millisecond,
}
gen := NewBlocksGenerator(config, nil, stableRandomHash)
s.Require().NoError(gen.Generate(
0,
genesisTime,
genesisTime.Add(30*time.Second),
s.db))
// Cache the count of total generated block.
iter, err := s.db.GetAll()
s.Require().NoError(err)
blocks, err := loadAllBlocks(iter)
s.Require().NoError(err)
s.totalBlockCount = len(blocks)
}
func (s *RevealerTestSuite) baseTest(
revealer Revealer,
repeat int,
checkFunc func(*types.Block, map[common.Hash]struct{})) {
revealingSequence := map[string]struct{}{}
for i := 0; i < repeat; i++ {
revealed := map[common.Hash]struct{}{}
sequence := ""
for {
b, err := revealer.Next()
if err != nil {
if err == blockdb.ErrIterationFinished {
err = nil
break
}
s.Require().NotNil(err)
}
checkFunc(&b, revealed)
revealed[b.Hash] = struct{}{}
sequence += b.Hash.String() + ","
}
s.Len(revealed, s.totalBlockCount)
revealingSequence[sequence] = struct{}{}
revealer.Reset()
}
// It should be reasonable to reveal at least two
// different sequence.
s.True(len(revealingSequence) > 1)
}
func (s *RevealerTestSuite) TestRandomReveal() {
// This test case would make sure we could at least generate
// two different revealing sequence when revealing more than
// 10 times.
iter, err := s.db.GetAll()
s.Require().Nil(err)
revealer, err := NewRandomRevealer(iter)
s.Require().Nil(err)
checkFunc := func(b *types.Block, revealed map[common.Hash]struct{}) {
// Make sure the revealer won't reveal the same block twice.
_, alreadyRevealed := revealed[b.Hash]
s.False(alreadyRevealed)
}
s.baseTest(revealer, 10, checkFunc)
}
func (s *RevealerTestSuite) TestRandomDAGReveal() {
// This test case would make sure we could at least generate
// two different revealing sequence when revealing more than
// 10 times, and each of them would form valid DAGs during
// revealing.
iter, err := s.db.GetAll()
s.Require().Nil(err)
revealer, err := NewRandomDAGRevealer(iter)
s.Require().Nil(err)
checkFunc := func(b *types.Block, revealed map[common.Hash]struct{}) {
// Make sure this revealer won't reveal
// the same block twice.
_, alreadyRevealed := revealed[b.Hash]
s.False(alreadyRevealed)
// Make sure the newly revealed block would still
// form a valid DAG after added to revealed blocks.
s.True(isAllAckingBlockRevealed(b, revealed))
}
s.baseTest(revealer, 10, checkFunc)
}
func (s *RevealerTestSuite) TestRandomTipReveal() {
// This test case would make sure we could at least generate
// two different revealing sequence when revealing more than
// 10 times.
iter, err := s.db.GetAll()
s.Require().Nil(err)
revealer, err := NewRandomTipRevealer(iter)
s.Require().Nil(err)
checkFunc := func(b *types.Block, revealed map[common.Hash]struct{}) {
// Make sure the revealer won't reveal the same block twice.
_, alreadyRevealed := revealed[b.Hash]
s.False(alreadyRevealed)
// Make sure the parent is already revealed.
if b.Position.Height == 0 {
return
}
_, alreadyRevealed = revealed[b.ParentHash]
s.True(alreadyRevealed)
}
s.baseTest(revealer, 10, checkFunc)
}
func (s *RevealerTestSuite) TestCompactionChainReveal() {
db, err := blockdb.NewMemBackedBlockDB()
s.Require().NoError(err)
// Put several blocks with finalization field ready.
b1 := &types.Block{
Hash: common.NewRandomHash(),
Finalization: types.FinalizationResult{
Height: 1,
}}
b2 := &types.Block{
Hash: common.NewRandomHash(),
Finalization: types.FinalizationResult{
ParentHash: b1.Hash,
Height: 2,
}}
b3 := &types.Block{
Hash: common.NewRandomHash(),
Finalization: types.FinalizationResult{
ParentHash: b2.Hash,
Height: 3,
}}
s.Require().NoError(db.Put(*b1))
s.Require().NoError(db.Put(*b3))
iter, err := db.GetAll()
s.Require().NoError(err)
// The compaction chain is not complete, we can't construct a revealer
// instance successfully.
r, err := NewCompactionChainRevealer(iter, 0)
s.Require().Nil(r)
s.Require().IsType(ErrNotValidCompactionChain, err)
// Put a block to make the compaction chain complete.
s.Require().NoError(db.Put(*b2))
// We can construct that revealer now.
iter, err = db.GetAll()
s.Require().NoError(err)
r, err = NewCompactionChainRevealer(iter, 0)
s.Require().NotNil(r)
s.Require().NoError(err)
// The revealing order should be ok.
chk := func(h uint64) {
b, err := r.Next()
s.Require().NoError(err)
s.Require().Equal(b.Finalization.Height, h)
}
chk(1)
chk(2)
chk(3)
// Iteration should be finished
_, err = r.Next()
s.Require().IsType(blockdb.ErrIterationFinished, err)
// Test 'startHeight' parameter.
iter, err = db.GetAll()
s.Require().NoError(err)
r, err = NewCompactionChainRevealer(iter, 2)
s.Require().NotNil(r)
s.Require().NoError(err)
chk(2)
chk(3)
}
func TestRevealer(t *testing.T) {
suite.Run(t, new(RevealerTestSuite))
}
