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  }