tests

Documentation

Index

• Constants
• Variables
• type ControllerSpecTest
  • func (test *ControllerSpecTest) Run(t *testing.T)
  • func (test *ControllerSpecTest) TestName() string
• type CreateMsgSpecTest
  • func (test *CreateMsgSpecTest) Run(t *testing.T)
  • func (test *CreateMsgSpecTest) TestName() string
• type DecidedState
• type MsgProcessingSpecTest
  • func HappyFlow() *MsgProcessingSpecTest
  • func SevenOperators() *MsgProcessingSpecTest
  • func TenOperators() *MsgProcessingSpecTest
  • func ThirteenOperators() *MsgProcessingSpecTest
  • func (test *MsgProcessingSpecTest) Run(t *testing.T)
  • func (test *MsgProcessingSpecTest) TestName() string
• type MsgSpecTest
  • func (test *MsgSpecTest) Run(t *testing.T)
  • func (test *MsgSpecTest) TestName() string
• type RoundRobinSpecTest
  • func (test *RoundRobinSpecTest) Run(t *testing.T)
  • func (test *RoundRobinSpecTest) TestName() string
• type RunInstanceData

Constants

const (
	CreateProposal      = "CreateProposal"
	CreateVCBC          = "CreateVCBC"
	CreateFillGap       = "CreateFillGap"
	CreateFiller        = "CreateFiller"
	CreateABAInit       = "CreateABAInit"
	CreateABAAux        = "CreateABAAux"
	CreateABAConf       = "CreateABAConf"
	CreateABAFinish     = "CreateABAFinish"
	CreateVCBCBroadcast = "CreateVCBCBroadcast"
	CreateVCBCSend      = "CreateVCBCSend"
	CreateVCBCReady     = "CreateVCBCReady"
	CreateVCBCFinal     = "CreateVCBCFinal"
	CreateVCBCRequest   = "CreateVCBCRequest"
	CreateVCBCAnswer    = "CreateVCBCAnswer"
)

const ChangeProposerFuncInstanceHeight = 1

ChangeProposerFuncInstanceHeight tests with this height will return proposer operator ID 2

Variables

var AggregatedMsgBytes = func(author types.OperatorID, priority alea.Priority) []byte {

	readyMsgs := make([]*alea.SignedMessage, 0)
	for opID := 1; opID <= 3; opID++ {
		signedMessage := testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[types.OperatorID(opID)], types.OperatorID(opID), &alea.Message{
			MsgType:    alea.VCBCReadyMsgType,
			Height:     alea.FirstHeight,
			Round:      alea.FirstRound,
			Identifier: []byte{1, 2, 3, 4},
			Data:       testingutils.VCBCReadyDataBytes(Hash, priority, author),
		})
		readyMsgs = append(readyMsgs, signedMessage)
	}

	aggregatedReadyMessages, err := alea.AggregateMsgs(readyMsgs)
	if err != nil {
		errors.Wrap(err, "could not aggregate vcbcready messages in happy flow")
	}
	aggregatedMsgBytes, err := aggregatedReadyMessages.Encode()
	if err != nil {
		errors.Wrap(err, "could not encode aggregated msg")
	}
	return aggregatedMsgBytes
}

var AggregatedMsgBytes2 = func(author types.OperatorID, priority alea.Priority) []byte {

	readyMsgs := make([]*alea.SignedMessage, 0)
	for opID := 1; opID <= 3; opID++ {
		signedMessage := testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[types.OperatorID(opID)], types.OperatorID(opID), &alea.Message{
			MsgType:    alea.VCBCReadyMsgType,
			Height:     alea.FirstHeight,
			Round:      alea.FirstRound,
			Identifier: []byte{1, 2, 3, 4},
			Data:       testingutils.VCBCReadyDataBytes(Hash2, priority, author),
		})
		readyMsgs = append(readyMsgs, signedMessage)
	}

	aggregatedReadyMessages, err := alea.AggregateMsgs(readyMsgs)
	if err != nil {
		errors.Wrap(err, "could not aggregate vcbcready messages in happy flow")
	}
	aggregatedMsgBytes, err := aggregatedReadyMessages.Encode()
	if err != nil {
		errors.Wrap(err, "could not encode aggregated msg")
	}
	return aggregatedMsgBytes
}

var AggregatedMsgBytes3 = func(author types.OperatorID, priority alea.Priority) []byte {

	readyMsgs := make([]*alea.SignedMessage, 0)
	for opID := 1; opID <= 3; opID++ {
		signedMessage := testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[types.OperatorID(opID)], types.OperatorID(opID), &alea.Message{
			MsgType:    alea.VCBCReadyMsgType,
			Height:     alea.FirstHeight,
			Round:      alea.FirstRound,
			Identifier: []byte{1, 2, 3, 4},
			Data:       testingutils.VCBCReadyDataBytes(Hash3, priority, author),
		})
		readyMsgs = append(readyMsgs, signedMessage)
	}

	aggregatedReadyMessages, err := alea.AggregateMsgs(readyMsgs)
	if err != nil {
		errors.Wrap(err, "could not aggregate vcbcready messages in happy flow")
	}
	aggregatedMsgBytes, err := aggregatedReadyMessages.Encode()
	if err != nil {
		errors.Wrap(err, "could not encode aggregated msg")
	}
	return aggregatedMsgBytes
}

var AggregatedMsgBytesList = func(author types.OperatorID, priority alea.Priority) [][]byte {
	return [][]byte{AggregatedMsgBytes(author, priority), AggregatedMsgBytes2(author, priority+1)}
}

var Entries = [][]*alea.ProposalData{{ProposalData1, ProposalData2}, {ProposalData3, ProposalData4}}

var Hash, _ = alea.GetProposalsHash([]*alea.ProposalData{ProposalData1, ProposalData2})

var Hash2, _ = alea.GetProposalsHash([]*alea.ProposalData{ProposalData3, ProposalData4})

var Hash3, _ = alea.GetProposalsHash([]*alea.ProposalData{ProposalData5, ProposalData6})

var Priorities = []alea.Priority{alea.FirstPriority, alea.FirstPriority + 1}

var ProposalData1, _ = SignedProposal1.Message.GetProposalData()

var ProposalData2, _ = SignedProposal2.Message.GetProposalData()

var ProposalData3, _ = SignedProposal3.Message.GetProposalData()

var ProposalData4, _ = SignedProposal4.Message.GetProposalData()

var ProposalData5, _ = SignedProposal5.Message.GetProposalData()

var ProposalData6, _ = SignedProposal6.Message.GetProposalData()

var ProposalDataList = []*alea.ProposalData{ProposalData1, ProposalData2}

var ProposalDataList2 = []*alea.ProposalData{ProposalData3, ProposalData4}

var ProposalDataList3 = []*alea.ProposalData{ProposalData5, ProposalData6}

var SignedProposal1 = testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[1], types.OperatorID(1), &alea.Message{
	MsgType:    alea.ProposalMsgType,
	Height:     alea.FirstHeight,
	Round:      alea.FirstRound,
	Identifier: []byte{1, 2, 3, 4},
	Data:       testingutils.ProposalDataBytesAlea([]byte{1, 2, 3, 4}),
})

var SignedProposal2 = testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[1], types.OperatorID(1), &alea.Message{
	MsgType:    alea.ProposalMsgType,
	Height:     alea.FirstHeight,
	Round:      alea.FirstRound,
	Identifier: []byte{1, 2, 3, 4},
	Data:       testingutils.ProposalDataBytesAlea([]byte{5, 6, 7, 8}),
})

var SignedProposal3 = testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[1], types.OperatorID(1), &alea.Message{
	MsgType:    alea.ProposalMsgType,
	Height:     alea.FirstHeight,
	Round:      alea.FirstRound,
	Identifier: []byte{1, 2, 3, 4},
	Data:       testingutils.ProposalDataBytesAlea([]byte{1, 3, 5, 7}),
})

var SignedProposal4 = testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[1], types.OperatorID(1), &alea.Message{
	MsgType:    alea.ProposalMsgType,
	Height:     alea.FirstHeight,
	Round:      alea.FirstRound,
	Identifier: []byte{1, 2, 3, 4},
	Data:       testingutils.ProposalDataBytesAlea([]byte{2, 4, 6, 8}),
})

var SignedProposal5 = testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[1], types.OperatorID(1), &alea.Message{
	MsgType:    alea.ProposalMsgType,
	Height:     alea.FirstHeight,
	Round:      alea.FirstRound,
	Identifier: []byte{1, 2, 3, 4},
	Data:       testingutils.ProposalDataBytesAlea([]byte{1, 5, 2, 3}),
})

var SignedProposal6 = testingutils.SignAleaMsg(testingutils.Testing4SharesSet().Shares[1], types.OperatorID(1), &alea.Message{
	MsgType:    alea.ProposalMsgType,
	Height:     alea.FirstHeight,
	Round:      alea.FirstRound,
	Identifier: []byte{1, 2, 3, 4},
	Data:       testingutils.ProposalDataBytesAlea([]byte{1, 6, 2, 3}),
})

Types

type ControllerSpecTest

type ControllerSpecTest struct {
	Name            string
	RunInstanceData []*RunInstanceData
	OutputMessages  []*alea.SignedMessage
	ExpectedError   string
}

func (*ControllerSpecTest) Run

func (test *ControllerSpecTest) Run(t *testing.T)

func (*ControllerSpecTest) TestName

func (test *ControllerSpecTest) TestName() string

type CreateMsgSpecTest

type CreateMsgSpecTest struct {
	Name           string
	Value          []byte
	Proposals      []*alea.ProposalData
	Priority       alea.Priority
	Vote           byte
	Votes          []byte
	Author         types.OperatorID
	Entries        [][]*alea.ProposalData
	Priorities     []alea.Priority
	Round          alea.Round
	ACRound        alea.ACRound
	Hash           []byte
	AggregatedMsg  []byte
	AggregatedMsgs [][]byte
	CreateType     string
	ExpectedRoot   string
	ExpectedError  string
}

func (*CreateMsgSpecTest) Run

func (test *CreateMsgSpecTest) Run(t *testing.T)

func (*CreateMsgSpecTest) TestName

func (test *CreateMsgSpecTest) TestName() string

type DecidedState

type DecidedState struct {
	DecidedVal               []byte
	DecidedCnt               uint
	BroadcastedDecided       *alea.SignedMessage
	CalledSyncDecidedByRange bool
	DecidedByRangeValues     [2]alea.Height
}

type MsgProcessingSpecTest

type MsgProcessingSpecTest struct {
	Name               string
	Pre                *alea.Instance
	PostRoot           string
	InputMessages      []*alea.SignedMessage
	OutputMessages     []*alea.SignedMessage
	ExpectedError      string
	ExpectedTimerState *testingutils.TimerStateAlea
	DontRunAC          bool
}

func HappyFlow

func HappyFlow() *MsgProcessingSpecTest

HappyFlow tests a simple full happy flow until decided

func SevenOperators

func SevenOperators() *MsgProcessingSpecTest

SevenOperators tests a simple full happy flow until decided

func TenOperators

func TenOperators() *MsgProcessingSpecTest

TenOperators tests a simple full happy flow until decided

func ThirteenOperators

func ThirteenOperators() *MsgProcessingSpecTest

ThirteenOperators tests a simple full happy flow until decided

func (*MsgProcessingSpecTest) Run

func (test *MsgProcessingSpecTest) Run(t *testing.T)

func (*MsgProcessingSpecTest) TestName

func (test *MsgProcessingSpecTest) TestName() string

type MsgSpecTest

type MsgSpecTest struct {
	Name            string
	Messages        []*alea.SignedMessage
	EncodedMessages [][]byte
	ExpectedRoots   [][]byte
	ExpectedError   string
}

MsgSpecTest tests encoding and decoding of a msg

func (*MsgSpecTest) Run

func (test *MsgSpecTest) Run(t *testing.T)

func (*MsgSpecTest) TestName

func (test *MsgSpecTest) TestName() string

type RoundRobinSpecTest

type RoundRobinSpecTest struct {
	Name      string
	Share     *types.Share
	Heights   []alea.Height
	Rounds    []alea.Round
	Proposers []types.OperatorID
}

func (*RoundRobinSpecTest) Run

func (test *RoundRobinSpecTest) Run(t *testing.T)

func (*RoundRobinSpecTest) TestName

func (test *RoundRobinSpecTest) TestName() string

type RunInstanceData

type RunInstanceData struct {
	InputValue           []byte
	InputMessages        []*alea.SignedMessage
	ControllerPostRoot   string
	ExpectedTimerState   *testingutils.TimerStateAlea
	ExpectedDecidedState DecidedState
}