github.com/darrenli6/fabric-sdk-example@v0.0.0-20220109053535-94b13b56df8c/common/configtx/template_test.go (about)

     1  /*
     2  Copyright IBM Corp. 2017 All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8                   http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package configtx
    18  
    19  import (
    20  	"fmt"
    21  	"testing"
    22  
    23  	"github.com/hyperledger/fabric/common/config"
    24  	configmsp "github.com/hyperledger/fabric/common/config/msp"
    25  	mmsp "github.com/hyperledger/fabric/common/mocks/msp"
    26  	cb "github.com/hyperledger/fabric/protos/common"
    27  	"github.com/hyperledger/fabric/protos/utils"
    28  
    29  	"github.com/golang/protobuf/proto"
    30  	"github.com/stretchr/testify/assert"
    31  )
    32  
    33  func verifyItemsResult(t *testing.T, template Template, count int) {
    34  	newChainID := "foo"
    35  
    36  	configEnv, err := template.Envelope(newChainID)
    37  	if err != nil {
    38  		t.Fatalf("Should not have errored: %s", err)
    39  	}
    40  
    41  	configNext, err := UnmarshalConfigUpdate(configEnv.ConfigUpdate)
    42  	if err != nil {
    43  		t.Fatalf("Should not have errored: %s", err)
    44  	}
    45  
    46  	assert.Equal(t, len(configNext.WriteSet.Values), count, "Not the right number of config values")
    47  
    48  	for i := 0; i < len(configNext.WriteSet.Values); i++ {
    49  		_, ok := configNext.WriteSet.Values[fmt.Sprintf("%d", i)]
    50  		assert.True(t, ok, "Expected %d but did not find it", i)
    51  	}
    52  }
    53  
    54  func simpleGroup(index int) *cb.ConfigGroup {
    55  	group := cb.NewConfigGroup()
    56  	group.Values[fmt.Sprintf("%d", index)] = &cb.ConfigValue{}
    57  	return group
    58  }
    59  
    60  func TestSimpleTemplate(t *testing.T) {
    61  	simple := NewSimpleTemplate(
    62  		simpleGroup(0),
    63  		simpleGroup(1),
    64  	)
    65  	verifyItemsResult(t, simple, 2)
    66  }
    67  
    68  func TestCompositeTemplate(t *testing.T) {
    69  	composite := NewCompositeTemplate(
    70  		NewSimpleTemplate(
    71  			simpleGroup(0),
    72  			simpleGroup(1),
    73  		),
    74  		NewSimpleTemplate(
    75  			simpleGroup(2),
    76  		),
    77  	)
    78  
    79  	verifyItemsResult(t, composite, 3)
    80  }
    81  
    82  func TestModPolicySettingTemplate(t *testing.T) {
    83  	existingModPolicy := "bar"
    84  
    85  	subGroup := "group"
    86  	subGroupExistingModPolicy := "otherGroup"
    87  	input := cb.NewConfigGroup()
    88  	input.Groups[subGroup] = cb.NewConfigGroup()
    89  	input.Groups[subGroupExistingModPolicy] = &cb.ConfigGroup{ModPolicy: existingModPolicy}
    90  
    91  	policyName := "policy"
    92  	valueName := "value"
    93  	policyExistingModPolicy := "otherPolicy"
    94  	valueExistingModPolicy := "otherValue"
    95  	for _, group := range []*cb.ConfigGroup{input, input.Groups[subGroup]} {
    96  		group.Values[valueName] = &cb.ConfigValue{}
    97  		group.Policies[policyName] = &cb.ConfigPolicy{}
    98  		group.Values[valueExistingModPolicy] = &cb.ConfigValue{ModPolicy: existingModPolicy}
    99  		group.Policies[policyExistingModPolicy] = &cb.ConfigPolicy{ModPolicy: existingModPolicy}
   100  	}
   101  
   102  	modPolicyName := "foo"
   103  	mpst := NewModPolicySettingTemplate(modPolicyName, NewSimpleTemplate(input))
   104  	output, err := mpst.Envelope("bar")
   105  	assert.NoError(t, err, "Creating envelope")
   106  
   107  	configUpdate := UnmarshalConfigUpdateOrPanic(output.ConfigUpdate)
   108  
   109  	assert.Equal(t, modPolicyName, configUpdate.WriteSet.ModPolicy)
   110  	assert.Equal(t, modPolicyName, configUpdate.WriteSet.Values[valueName].ModPolicy)
   111  	assert.Equal(t, modPolicyName, configUpdate.WriteSet.Policies[policyName].ModPolicy)
   112  	assert.Equal(t, existingModPolicy, configUpdate.WriteSet.Values[valueExistingModPolicy].ModPolicy)
   113  	assert.Equal(t, existingModPolicy, configUpdate.WriteSet.Policies[policyExistingModPolicy].ModPolicy)
   114  	assert.Equal(t, modPolicyName, configUpdate.WriteSet.Groups[subGroup].ModPolicy)
   115  	assert.Equal(t, modPolicyName, configUpdate.WriteSet.Groups[subGroup].Values[valueName].ModPolicy)
   116  	assert.Equal(t, modPolicyName, configUpdate.WriteSet.Groups[subGroup].Policies[policyName].ModPolicy)
   117  	assert.Equal(t, existingModPolicy, configUpdate.WriteSet.Groups[subGroup].Values[valueExistingModPolicy].ModPolicy)
   118  	assert.Equal(t, existingModPolicy, configUpdate.WriteSet.Groups[subGroup].Policies[policyExistingModPolicy].ModPolicy)
   119  	assert.Equal(t, existingModPolicy, configUpdate.WriteSet.Groups[subGroupExistingModPolicy].ModPolicy)
   120  }
   121  
   122  func TestNewChainTemplate(t *testing.T) {
   123  	consortiumName := "Test"
   124  	orgs := []string{"org1", "org2", "org3"}
   125  	nct := NewChainCreationTemplate(consortiumName, orgs)
   126  
   127  	newChainID := "foo"
   128  	configEnv, err := nct.Envelope(newChainID)
   129  	if err != nil {
   130  		t.Fatalf("Error creation a chain creation config")
   131  	}
   132  
   133  	configUpdate, err := UnmarshalConfigUpdate(configEnv.ConfigUpdate)
   134  	if err != nil {
   135  		t.Fatalf("Should not have errored: %s", err)
   136  	}
   137  
   138  	consortiumProto := &cb.Consortium{}
   139  	err = proto.Unmarshal(configUpdate.WriteSet.Values[config.ConsortiumKey].Value, consortiumProto)
   140  	assert.NoError(t, err)
   141  	assert.Equal(t, consortiumName, consortiumProto.Name, "Should have set correct consortium name")
   142  
   143  	assert.Equal(t, configUpdate.WriteSet.Groups[config.ApplicationGroupKey].Version, uint64(1))
   144  
   145  	assert.Len(t, configUpdate.WriteSet.Groups[config.ApplicationGroupKey].Groups, len(orgs))
   146  
   147  	for _, org := range orgs {
   148  		group, ok := configUpdate.WriteSet.Groups[config.ApplicationGroupKey].Groups[org]
   149  		assert.True(t, ok, "Expected to find %s but did not", org)
   150  		for _, policy := range group.Policies {
   151  			assert.Equal(t, configmsp.AdminsPolicyKey, policy.ModPolicy)
   152  		}
   153  	}
   154  }
   155  
   156  func TestMakeChainCreationTransactionWithSigner(t *testing.T) {
   157  	channelID := "foo"
   158  
   159  	signer, err := mmsp.NewNoopMsp().GetDefaultSigningIdentity()
   160  	assert.NoError(t, err, "Creating noop MSP")
   161  
   162  	cct, err := MakeChainCreationTransaction(channelID, "test", signer)
   163  	assert.NoError(t, err, "Making chain creation tx")
   164  
   165  	assert.NotEmpty(t, cct.Signature, "Should have signature")
   166  
   167  	payload, err := utils.UnmarshalPayload(cct.Payload)
   168  	assert.NoError(t, err, "Unmarshaling payload")
   169  
   170  	configUpdateEnv, err := UnmarshalConfigUpdateEnvelope(payload.Data)
   171  	assert.NoError(t, err, "Unmarshaling ConfigUpdateEnvelope")
   172  
   173  	assert.NotEmpty(t, configUpdateEnv.Signatures, "Should have config env sigs")
   174  
   175  	sigHeader, err := utils.GetSignatureHeader(payload.Header.SignatureHeader)
   176  	assert.NoError(t, err, "Unmarshaling SignatureHeader")
   177  	assert.NotEmpty(t, sigHeader.Creator, "Creator specified")
   178  }
   179  
   180  func TestMakeChainCreationTransactionNoSigner(t *testing.T) {
   181  	channelID := "foo"
   182  	cct, err := MakeChainCreationTransaction(channelID, "test", nil)
   183  	assert.NoError(t, err, "Making chain creation tx")
   184  
   185  	assert.Empty(t, cct.Signature, "Should have empty signature")
   186  
   187  	payload, err := utils.UnmarshalPayload(cct.Payload)
   188  	assert.NoError(t, err, "Unmarshaling payload")
   189  
   190  	configUpdateEnv, err := UnmarshalConfigUpdateEnvelope(payload.Data)
   191  	assert.NoError(t, err, "Unmarshaling ConfigUpdateEnvelope")
   192  
   193  	assert.Empty(t, configUpdateEnv.Signatures, "Should have no config env sigs")
   194  
   195  	sigHeader, err := utils.GetSignatureHeader(payload.Header.SignatureHeader)
   196  	assert.NoError(t, err, "Unmarshaling SignatureHeader")
   197  	assert.Empty(t, sigHeader.Creator, "No creator specified")
   198  }