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 }