Add tests to static bootstrap helper

The static package did not contain any tests - this changeset fixes that.
These simple tests deconstruct the nested message that ultimately gave us
the genesis block and check that its values have been set properly.

UPDATE: Revised for the latest proto changes.

Change-Id: If0afcbcebb18d59158f05b70b7cc63c1752286cb
Signed-off-by: Kostas Christidis <[email protected]>

Author: kchristidis

orderer/common/bootstrap/static/static.go

@@ -53,7 +53,7 @@ func errorlessMarshal(thing proto.Message) []byte {
 	return data
 }
 
-func makeChainHeader(headerType cb.HeaderType, version int32, chainID []byte) *cb.ChainHeader {
+func makeChainHeader(headerType cb.HeaderType, version int32, chainID []byte, epoch uint64) *cb.ChainHeader {
 	return &cb.ChainHeader{
 		Type:    int32(headerType),
 		Version: version,
@@ -62,6 +62,7 @@ func makeChainHeader(headerType cb.HeaderType, version int32, chainID []byte) *c
 			Nanos:   0,
 		},
 		ChainID: chainID,
+		Epoch:   epoch,
 	}
 }
 
@@ -74,7 +75,7 @@ func makeSignatureHeader(serializedCreatorCertChain []byte, nonce []byte) *cb.Si
 
 func (b *bootstrapper) makeSignedConfigurationItem(configurationItemType cb.ConfigurationItem_ConfigurationType, modificationPolicyID string, key string, value []byte) *cb.SignedConfigurationItem {
 	marshaledConfigurationItem := errorlessMarshal(&cb.ConfigurationItem{
-		Header:             makeChainHeader(cb.HeaderType_CONFIGURATION_ITEM, 1, b.chainID),
+		Header:             makeChainHeader(cb.HeaderType_CONFIGURATION_ITEM, 1, b.chainID, 0),
 		Type:               configurationItemType,
 		LastModified:       0,
 		ModificationPolicy: modificationPolicyID,
@@ -101,7 +102,7 @@ func (b *bootstrapper) makeEnvelope(configurationEnvelope *cb.ConfigurationEnvel
 	}
 	marshaledPayload := errorlessMarshal(&cb.Payload{
 		Header: &cb.Header{
-			ChainHeader:     makeChainHeader(cb.HeaderType_CONFIGURATION_TRANSACTION, 1, b.chainID),
+			ChainHeader:     makeChainHeader(cb.HeaderType_CONFIGURATION_TRANSACTION, 1, b.chainID, 0),
 			SignatureHeader: makeSignatureHeader(nil, nonce),
 		},
 		Data: errorlessMarshal(configurationEnvelope),

orderer/common/bootstrap/static/static_test.go

@@ -0,0 +1,171 @@
+/*
+Copyright IBM Corp. 2016 All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+                 http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package static
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/hyperledger/fabric/orderer/common/cauthdsl"
+	"github.com/hyperledger/fabric/orderer/common/configtx"
+	cb "github.com/hyperledger/fabric/protos/common"
+
+	"github.com/golang/protobuf/proto"
+)
+
+func TestGenesisBlockCreation(t *testing.T) {
+	_, err := New().GenesisBlock()
+	if err != nil {
+		t.Fatalf("Cannot create genesis block: %s", err)
+	}
+}
+
+func TestGenesisBlockHeader(t *testing.T) {
+	expectedHeaderNumber := uint64(0)
+
+	genesisBlock, _ := New().GenesisBlock() // The error has been checked in a previous test
+
+	if genesisBlock.Header.Number != expectedHeaderNumber {
+		t.Fatalf("Expected header number %d, got %d", expectedHeaderNumber, genesisBlock.Header.Number)
+	}
+
+	if !bytes.Equal(genesisBlock.Header.PreviousHash, nil) {
+		t.Fatalf("Expected header previousHash to be nil, got %x", genesisBlock.Header.PreviousHash)
+	}
+}
+
+func TestGenesisBlockData(t *testing.T) {
+	expectedBlockDataLength := 1
+	expectedPayloadChainHeaderType := int32(cb.HeaderType_CONFIGURATION_TRANSACTION)
+	expectedChainHeaderVersion := int32(1)
+	expectedChainHeaderEpoch := uint64(0)
+	expectedConfigEnvelopeItemsLength := 1
+	expectedConfigurationItemChainHeaderType := int32(cb.HeaderType_CONFIGURATION_ITEM)
+	expectedConfigurationItemChainHeaderVersion := int32(1)
+	expectedConfigurationItemType := cb.ConfigurationItem_Policy
+	expectedConfigEnvelopeSequence := uint64(0)
+	expectedConfigurationItemModificationPolicy := configtx.DefaultModificationPolicyID
+	expectedConfigurationItemValueSignaturePolicyEnvelope := cauthdsl.RejectAllPolicy
+
+	genesisBlock, _ := New().GenesisBlock() // The error has been checked in a previous test
+
+	if len(genesisBlock.Data.Data) != expectedBlockDataLength {
+		t.Fatalf("Expected genesis block data length %d, got %d", expectedBlockDataLength, len(genesisBlock.Data.Data))
+	}
+
+	marshaledEnvelope := genesisBlock.Data.Data[0]
+	envelope := &cb.Envelope{}
+	if err := proto.Unmarshal(marshaledEnvelope, envelope); err != nil {
+		t.Fatalf("Expected genesis block to carry an Envelope")
+	}
+
+	envelopeSignature := envelope.Signature
+	if !bytes.Equal(envelopeSignature, nil) {
+		t.Fatalf("Expected envelope signature to be nil, got %x", envelopeSignature)
+	}
+
+	marshaledPayload := envelope.Payload
+	payload := &cb.Payload{}
+	if err := proto.Unmarshal(marshaledPayload, payload); err != nil {
+		t.Fatalf("Expected genesis block to carry a Payload")
+	}
+
+	signatureHeader := payload.Header.SignatureHeader
+	if !bytes.Equal(signatureHeader.Creator, nil) {
+		t.Fatalf("Expected payload signature header creator to be nil, got %x", signatureHeader.Creator)
+	}
+	if bytes.Equal(signatureHeader.Nonce, nil) {
+		t.Fatal("Expected non-nil nonce")
+	}
+
+	payloadChainHeader := payload.Header.ChainHeader
+	if payloadChainHeader.Type != expectedPayloadChainHeaderType {
+		t.Fatalf("Expected payload chain header type %d, got %d", expectedPayloadChainHeaderType, payloadChainHeader.Type)
+	}
+	if payloadChainHeader.Version != expectedChainHeaderVersion {
+		t.Fatalf("Expected payload chain header version %d, got %d", expectedChainHeaderVersion, payloadChainHeader.Version)
+	}
+	if payloadChainHeader.Epoch != expectedChainHeaderEpoch {
+		t.Fatalf("Expected payload chain header epoch to be %d, got %d", expectedChainHeaderEpoch, payloadChainHeader.Epoch)
+	}
+
+	marshaledConfigurationEnvelope := payload.Data
+	configurationEnvelope := &cb.ConfigurationEnvelope{}
+	if err := proto.Unmarshal(marshaledConfigurationEnvelope, configurationEnvelope); err != nil {
+		t.Fatalf("Expected genesis block to carry a ConfigurationEnvelope")
+	}
+	if len(configurationEnvelope.Items) != expectedConfigEnvelopeItemsLength {
+		t.Fatalf("Expected configuration envelope to have %d configuration item(s), got %d", expectedConfigEnvelopeItemsLength, len(configurationEnvelope.Items))
+	}
+
+	signedConfigurationItem := configurationEnvelope.Items[0]
+	marshaledConfigurationItem := signedConfigurationItem.ConfigurationItem
+	configurationItem := &cb.ConfigurationItem{}
+	if err := proto.Unmarshal(marshaledConfigurationItem, configurationItem); err != nil {
+		t.Fatalf("Expected genesis block to carry a ConfigurationItem")
+	}
+
+	configurationItemChainHeader := configurationItem.Header
+	if configurationItemChainHeader.Type != expectedConfigurationItemChainHeaderType {
+		t.Fatalf("Expected configuration item chain header type %d, got %d", expectedConfigurationItemChainHeaderType, configurationItemChainHeader.Type)
+	}
+	if configurationItemChainHeader.Version != expectedConfigurationItemChainHeaderVersion {
+		t.Fatalf("Expected configuration item chain header version %d, got %d", expectedConfigurationItemChainHeaderVersion, configurationItemChainHeader.Version)
+	}
+	if !bytes.Equal(configurationItemChainHeader.ChainID, payloadChainHeader.ChainID) {
+		t.Fatalf("Expected chain ID in chain headers of configuration item and payload to match, got %x and %x respectively", configurationItemChainHeader.ChainID, payloadChainHeader.ChainID)
+	}
+	if configurationItemChainHeader.Epoch != payloadChainHeader.Epoch {
+		t.Fatalf("Expected epoch in chain headers of configuration item and payload to match, got %d, and %d respectively", configurationItemChainHeader.Epoch, payloadChainHeader.Epoch)
+	}
+
+	if configurationItem.Type != expectedConfigurationItemType {
+		t.Fatalf("Expected configuration item type %s, got %s", expectedConfigurationItemType.String(), configurationItem.Type.String())
+	}
+	if configurationItem.LastModified != expectedConfigEnvelopeSequence {
+		t.Fatalf("Expected configuration item sequence to match configuration envelope sequence %d, got %d", expectedConfigEnvelopeSequence, configurationItem.LastModified)
+	}
+	if configurationItem.ModificationPolicy != expectedConfigurationItemModificationPolicy {
+		t.Fatalf("Expected configuration item modification policy %s, got %s", expectedConfigurationItemModificationPolicy, configurationItem.ModificationPolicy)
+	}
+	if configurationItem.Key != expectedConfigurationItemModificationPolicy {
+		t.Fatalf("Expected configuration item key to be equal to the modification policy %s, got %s", expectedConfigurationItemModificationPolicy, configurationItem.Key)
+	}
+
+	marshaledPolicy := configurationItem.Value
+	policy := &cb.Policy{}
+	if err := proto.Unmarshal(marshaledPolicy, policy); err != nil {
+		t.Fatalf("Expected genesis block to carry a policy in its configuration item value")
+	}
+	switch policy.GetType().(type) {
+	case *cb.Policy_SignaturePolicy:
+	default:
+		t.Fatalf("Got unexpected configuration item value policy type")
+	}
+	signaturePolicyEnvelope := policy.GetSignaturePolicy()
+	if !proto.Equal(signaturePolicyEnvelope, expectedConfigurationItemValueSignaturePolicyEnvelope) {
+		t.Fatalf("Expected configuration item value signature policy envelope %s, got %s", expectedConfigurationItemValueSignaturePolicyEnvelope.String(), signaturePolicyEnvelope.String())
+	}
+}
+
+func TestGenesisMetadata(t *testing.T) {
+	genesisBlock, _ := New().GenesisBlock() // The error has been checked in a previous test
+
+	if genesisBlock.Metadata != nil {
+		t.Fatalf("Expected metadata nil, got %x", genesisBlock.Metadata)
+	}
+}