Byzcoin: governance unit test

ledger/byzcoin/mod.go

@@ -351,14 +351,14 @@ func (a actorLedger) Setup(players mino.Players) error {
 
 	rosterpb, err := a.encoder.Pack(a.governance.rosterFactory.New(authority))
 	if err != nil {
-		return err
+		return xerrors.Errorf("couldn't pack roster: %v", err)
 	}
 
 	payload := &GenesisPayload{Roster: rosterpb.(*Roster)}
 
 	page, err := a.proc.setup(payload)
 	if err != nil {
-		return err
+		return xerrors.Errorf("couldn't store genesis payload: %v", err)
 	}
 
 	payload.Footprint = page.GetFootprint()
@@ -391,30 +391,39 @@ func (a actorLedger) Close() error {
 	return nil
 }
 
+// Governance is an implementation of viewchange.Governance so that the module
+// can act on the roster which is done through transactions.
+// TODO: implement the roster txs
+//
+// - implements viewchange.Governance
 type governance struct {
 	inventory     inventory.Inventory
 	rosterFactory rosterFactory
 }
 
+// GetAuthority implements viewchange.Governance. It returns the authority for
+// the given block index by reading the inventory page associated.
 func (gov governance) GetAuthority(index uint64) (viewchange.EvolvableAuthority, error) {
 	page, err := gov.inventory.GetPage(index)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("couldn't read page: %v", err)
 	}
 
 	rosterpb, err := page.Read(authorityKey)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("couldn't read roster: %v", err)
 	}
 
 	roster, err := gov.rosterFactory.FromProto(rosterpb)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("couldn't decode roster: %v", err)
 	}
 
 	return roster, nil
 }
 
+// GetChangeSet implements viewchange.Governance. It returns the change set for
+// that block by reading the transactions.
 func (gov governance) GetChangeSet(index uint64) viewchange.ChangeSet {
 	return viewchange.ChangeSet{}
 }

ledger/byzcoin/mod_test.go

@@ -11,6 +11,7 @@ import (
 	"go.dedis.ch/fabric/blockchain"
 	"go.dedis.ch/fabric/crypto"
 	"go.dedis.ch/fabric/crypto/bls"
+	"go.dedis.ch/fabric/encoding"
 	internal "go.dedis.ch/fabric/internal/testing"
 	"go.dedis.ch/fabric/internal/testing/fake"
 	"go.dedis.ch/fabric/ledger"
@@ -132,6 +133,38 @@ func TestLedger_GetInstance(t *testing.T) {
 	require.EqualError(t, err, "couldn't decode instance: oops")
 }
 
+func TestGovernance_GetAuthority(t *testing.T) {
+	factory := rosterFactory{
+		addressFactory: fake.AddressFactory{},
+		pubkeyFactory:  fake.PublicKeyFactory{},
+	}
+
+	roster := factory.New(fake.NewAuthority(3, fake.NewSigner))
+	rosterpb, err := roster.Pack(encoding.NewProtoEncoder())
+	require.NoError(t, err)
+
+	gov := governance{
+		rosterFactory: factory,
+		inventory:     fakeInventory{page: &fakePage{value: rosterpb}},
+	}
+
+	authority, err := gov.GetAuthority(3)
+	require.NoError(t, err)
+	require.Equal(t, 3, authority.Len())
+
+	gov.inventory = fakeInventory{err: xerrors.New("oops")}
+	_, err = gov.GetAuthority(3)
+	require.EqualError(t, err, "couldn't read page: oops")
+
+	gov.inventory = fakeInventory{page: &fakePage{err: xerrors.New("oops")}}
+	_, err = gov.GetAuthority(3)
+	require.EqualError(t, err, "couldn't read roster: oops")
+
+	gov.inventory = fakeInventory{page: &fakePage{}}
+	_, err = gov.GetAuthority(3)
+	require.EqualError(t, err, "couldn't decode roster: invalid message type '<nil>'")
+}
+
 // -----------------------------------------------------------------------------
 // Utility functions
 

ledger/byzcoin/roster.go

@@ -62,7 +62,8 @@ func (i *publicKeyIterator) GetNext() crypto.PublicKey {
 
 // roster contains a list of participants with their addresses and public keys.
 //
-// - implements crypto.CollectiveSigning
+// - implements crypto.CollectiveAuthority
+// - implements viewchange.EvolvableAuthority
 // - implements mino.Players
 // - implements encoding.Packable
 type roster struct {
@@ -87,7 +88,10 @@ func (r roster) Take(updaters ...mino.FilterUpdater) mino.Players {
 	return newRoster
 }
 
+// Apply implements viewchange.EvolvableAuthority. It returns a new authority
+// after applying the change set.
 func (r roster) Apply(viewchange.ChangeSet) viewchange.EvolvableAuthority {
+	// TODO: implement
 	return r
 }
 

ledger/byzcoin/txproc_test.go

@@ -112,6 +112,7 @@ type fakePage struct {
 	index     uint64
 	footprint []byte
 	err       error
+	value     proto.Message
 	calls     [][]interface{}
 }
 
@@ -124,7 +125,7 @@ func (p *fakePage) GetFootprint() []byte {
 }
 
 func (p *fakePage) Read([]byte) (proto.Message, error) {
-	return &empty.Empty{}, p.err
+	return p.value, p.err
 }
 
 func (p *fakePage) Write(key []byte, value proto.Message) error {