github.com/leonlxy/hyperledger@v1.0.0-alpha.0.20170427033203-34922035d248/core/common/ccpackage/ccpackage_test.go (about) 1 /* 2 Copyright IBM Corp. 2016 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 ccpackage 18 19 import ( 20 "fmt" 21 "os" 22 "testing" 23 24 "github.com/golang/protobuf/proto" 25 "github.com/hyperledger/fabric/common/cauthdsl" 26 "github.com/hyperledger/fabric/msp" 27 mspmgmt "github.com/hyperledger/fabric/msp/mgmt" 28 "github.com/hyperledger/fabric/msp/mgmt/testtools" 29 "github.com/hyperledger/fabric/protos/common" 30 mspprotos "github.com/hyperledger/fabric/protos/msp" 31 "github.com/hyperledger/fabric/protos/peer" 32 "github.com/hyperledger/fabric/protos/utils" 33 ) 34 35 func ownerCreateCCDepSpec(codepackage []byte, sigpolicy *common.SignaturePolicyEnvelope, owner msp.SigningIdentity) (*common.Envelope, error) { 36 cds := &peer.ChaincodeDeploymentSpec{CodePackage: codepackage} 37 return OwnerCreateSignedCCDepSpec(cds, sigpolicy, owner) 38 } 39 40 // create an instantiation policy with just the local msp admin 41 func createInstantiationPolicy(mspid string, role mspprotos.MSPRole_MSPRoleType) *common.SignaturePolicyEnvelope { 42 principals := []*mspprotos.MSPPrincipal{&mspprotos.MSPPrincipal{ 43 PrincipalClassification: mspprotos.MSPPrincipal_ROLE, 44 Principal: utils.MarshalOrPanic(&mspprotos.MSPRole{Role: role, MspIdentifier: mspid})}} 45 sigspolicy := []*common.SignaturePolicy{cauthdsl.SignedBy(int32(0))} 46 47 // create the policy: it requires exactly 1 signature from any of the principals 48 p := &common.SignaturePolicyEnvelope{ 49 Version: 0, 50 Policy: cauthdsl.NOutOf(1, sigspolicy), 51 Identities: principals, 52 } 53 54 return p 55 } 56 57 func TestOwnerCreateSignedCCDepSpec(t *testing.T) { 58 mspid, _ := localmsp.GetIdentifier() 59 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 60 env, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 61 if err != nil || env == nil { 62 t.Fatalf("error owner creating package %s", err) 63 return 64 } 65 } 66 67 func TestAddSignature(t *testing.T) { 68 mspid, _ := localmsp.GetIdentifier() 69 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 70 env, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 71 if err != nil || env == nil { 72 t.Fatalf("error owner creating package %s", err) 73 return 74 } 75 //add one more with the same signer (we don't have another signer to test with) 76 env, err = SignExistingPackage(env, signer) 77 if err != nil || env == nil { 78 t.Fatalf("error signing existing package %s", err) 79 return 80 } 81 //...and sign aother for luck 82 env, err = SignExistingPackage(env, signer) 83 if err != nil || env == nil { 84 t.Fatalf("error signing existing package %s", err) 85 return 86 } 87 88 p := &common.Payload{} 89 if err = proto.Unmarshal(env.Payload, p); err != nil { 90 t.Fatalf("fatal error unmarshal payload") 91 return 92 } 93 94 sigdepspec := &peer.SignedChaincodeDeploymentSpec{} 95 if err = proto.Unmarshal(p.Data, sigdepspec); err != nil || sigdepspec == nil { 96 t.Fatalf("fatal error unmarshal sigdepspec") 97 return 98 } 99 100 if len(sigdepspec.OwnerEndorsements) != 3 { 101 t.Fatalf("invalid number of endorsements %d", len(sigdepspec.OwnerEndorsements)) 102 return 103 } 104 } 105 106 func TestMissingSigaturePolicy(t *testing.T) { 107 env, err := ownerCreateCCDepSpec([]byte("codepackage"), nil, signer) 108 if err == nil || env != nil { 109 t.Fatalf("expected error on missing signature policy") 110 return 111 } 112 } 113 114 func TestCreateSignedCCDepSpecForInstall(t *testing.T) { 115 mspid, _ := localmsp.GetIdentifier() 116 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 117 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, nil) 118 if err != nil || env1 == nil { 119 t.Fatalf("error owner creating package %s", err) 120 return 121 } 122 123 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, nil) 124 if err != nil || env2 == nil { 125 t.Fatalf("error owner creating package %s", err) 126 return 127 } 128 129 pack := []*common.Envelope{env1, env2} 130 env, err := CreateSignedCCDepSpecForInstall(pack) 131 if err != nil || env == nil { 132 t.Fatalf("error creating install package %s", err) 133 return 134 } 135 136 p := &common.Payload{} 137 if err = proto.Unmarshal(env.Payload, p); err != nil { 138 t.Fatalf("fatal error unmarshal payload") 139 return 140 } 141 142 cip2 := &peer.SignedChaincodeDeploymentSpec{} 143 if err = proto.Unmarshal(p.Data, cip2); err != nil { 144 t.Fatalf("fatal error unmarshal cip") 145 return 146 } 147 148 p = &common.Payload{} 149 if err = proto.Unmarshal(env1.Payload, p); err != nil { 150 t.Fatalf("fatal error unmarshal payload") 151 return 152 } 153 154 cip1 := &peer.SignedChaincodeDeploymentSpec{} 155 if err = proto.Unmarshal(p.Data, cip1); err != nil { 156 t.Fatalf("fatal error unmarshal cip") 157 return 158 } 159 160 if err = ValidateCip(cip1, cip2); err != nil { 161 t.Fatalf("fatal error validating cip1 (%v) against cip2(%v)", cip1, cip2) 162 return 163 } 164 } 165 166 func TestMismatchedCodePackages(t *testing.T) { 167 mspid, _ := localmsp.GetIdentifier() 168 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 169 env1, err := ownerCreateCCDepSpec([]byte("codepackage1"), sigpolicy, nil) 170 if err != nil || env1 == nil { 171 t.Fatalf("error owner creating package %s", err) 172 return 173 } 174 175 env2, err := ownerCreateCCDepSpec([]byte("codepackage2"), sigpolicy, nil) 176 if err != nil || env2 == nil { 177 t.Fatalf("error owner creating package %s", err) 178 return 179 } 180 pack := []*common.Envelope{env1, env2} 181 env, err := CreateSignedCCDepSpecForInstall(pack) 182 if err == nil || env != nil { 183 t.Fatalf("expected error creating install from mismatched code package but succeeded") 184 return 185 } 186 } 187 188 func TestMismatchedEndorsements(t *testing.T) { 189 mspid, _ := localmsp.GetIdentifier() 190 sigpolicy := createInstantiationPolicy(mspid, mspprotos.MSPRole_ADMIN) 191 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, signer) 192 if err != nil || env1 == nil { 193 t.Fatalf("error owner creating package %s", err) 194 return 195 } 196 197 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy, nil) 198 if err != nil || env2 == nil { 199 t.Fatalf("error owner creating package %s", err) 200 return 201 } 202 pack := []*common.Envelope{env1, env2} 203 env, err := CreateSignedCCDepSpecForInstall(pack) 204 if err == nil || env != nil { 205 t.Fatalf("expected error creating install from mismatched endorsed package but succeeded") 206 return 207 } 208 } 209 210 func TestMismatchedSigPolicy(t *testing.T) { 211 sigpolicy1 := createInstantiationPolicy("mspid1", mspprotos.MSPRole_ADMIN) 212 env1, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy1, signer) 213 if err != nil || env1 == nil { 214 t.Fatalf("error owner creating package %s", err) 215 return 216 } 217 218 sigpolicy2 := createInstantiationPolicy("mspid2", mspprotos.MSPRole_ADMIN) 219 env2, err := ownerCreateCCDepSpec([]byte("codepackage"), sigpolicy2, signer) 220 if err != nil || env2 == nil { 221 t.Fatalf("error owner creating package %s", err) 222 return 223 } 224 pack := []*common.Envelope{env1, env2} 225 env, err := CreateSignedCCDepSpecForInstall(pack) 226 if err == nil || env != nil { 227 t.Fatalf("expected error creating install from mismatched signature policies but succeeded") 228 return 229 } 230 } 231 232 var localmsp msp.MSP 233 var signer msp.SigningIdentity 234 var signerSerialized []byte 235 236 func TestMain(m *testing.M) { 237 // setup the MSP manager so that we can sign/verify 238 err := msptesttools.LoadMSPSetupForTesting() 239 if err != nil { 240 os.Exit(-1) 241 fmt.Printf("Could not initialize msp") 242 return 243 } 244 localmsp = mspmgmt.GetLocalMSP() 245 if localmsp == nil { 246 os.Exit(-1) 247 fmt.Printf("Could not get msp") 248 return 249 } 250 signer, err = localmsp.GetDefaultSigningIdentity() 251 if err != nil { 252 os.Exit(-1) 253 fmt.Printf("Could not get signer") 254 return 255 } 256 257 signerSerialized, err = signer.Serialize() 258 if err != nil { 259 os.Exit(-1) 260 fmt.Printf("Could not serialize identity") 261 return 262 } 263 264 os.Exit(m.Run()) 265 }