github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/chaincode/lifecycle/metadata_provider_test.go (about)

     1  /*
     2  Copyright hechain. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package lifecycle_test
     8  
     9  import (
    10  	"github.com/hechain20/hechain/common/chaincode"
    11  	"github.com/hechain20/hechain/common/policydsl"
    12  	"github.com/hechain20/hechain/core/chaincode/lifecycle"
    13  	"github.com/hechain20/hechain/core/chaincode/lifecycle/mock"
    14  	"github.com/hyperledger/fabric-protos-go/common"
    15  	"github.com/hyperledger/fabric-protos-go/msp"
    16  	pb "github.com/hyperledger/fabric-protos-go/peer"
    17  	lb "github.com/hyperledger/fabric-protos-go/peer/lifecycle"
    18  	"github.com/pkg/errors"
    19  
    20  	"github.com/hechain20/hechain/protoutil"
    21  	. "github.com/onsi/ginkgo"
    22  	. "github.com/onsi/gomega"
    23  )
    24  
    25  var _ = Describe("MetadataProvider", func() {
    26  	var (
    27  		fakeChaincodeInfoProvider          *mock.ChaincodeInfoProvider
    28  		fakeLegacyMetadataProvider         *mock.LegacyMetadataProvider
    29  		fakeChannelPolicyReferenceProvider *mock.ChannelPolicyReferenceProvider
    30  		fakeConvertedPolicy                *mock.ConvertiblePolicy
    31  		metadataProvider                   *lifecycle.MetadataProvider
    32  		ccInfo                             *lifecycle.LocalChaincodeInfo
    33  	)
    34  
    35  	BeforeEach(func() {
    36  		fakeChaincodeInfoProvider = &mock.ChaincodeInfoProvider{}
    37  		ccInfo = &lifecycle.LocalChaincodeInfo{
    38  			Definition: &lifecycle.ChaincodeDefinition{
    39  				Sequence: 1,
    40  				EndorsementInfo: &lb.ChaincodeEndorsementInfo{
    41  					Version: "cc-version",
    42  				},
    43  				ValidationInfo: &lb.ChaincodeValidationInfo{
    44  					ValidationParameter: protoutil.MarshalOrPanic(&pb.ApplicationPolicy{
    45  						Type: &pb.ApplicationPolicy_SignaturePolicy{
    46  							SignaturePolicy: policydsl.AcceptAllPolicy,
    47  						},
    48  					}),
    49  				},
    50  				Collections: &pb.CollectionConfigPackage{},
    51  			},
    52  		}
    53  		fakeChaincodeInfoProvider.ChaincodeInfoReturns(ccInfo, nil)
    54  
    55  		legacyCCMetadata := &chaincode.Metadata{
    56  			Name:               "legacy-cc",
    57  			Version:            "legacy-version",
    58  			Policy:             []byte("legacy-policy"),
    59  			CollectionPolicies: nil,
    60  			CollectionsConfig:  &pb.CollectionConfigPackage{},
    61  		}
    62  		fakeLegacyMetadataProvider = &mock.LegacyMetadataProvider{}
    63  		fakeLegacyMetadataProvider.MetadataReturns(legacyCCMetadata)
    64  
    65  		metadataProvider = lifecycle.NewMetadataProvider(fakeChaincodeInfoProvider, fakeLegacyMetadataProvider, nil)
    66  	})
    67  
    68  	It("returns metadata using the ChaincodeInfoProvider (SignaturePolicyEnvelope case)", func() {
    69  		metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1")
    70  		Expect(metadata).To(Equal(
    71  			&chaincode.Metadata{
    72  				Name:               "cc-name",
    73  				Version:            "1",
    74  				Policy:             policydsl.MarshaledAcceptAllPolicy,
    75  				CollectionPolicies: map[string][]byte{},
    76  				CollectionsConfig:  &pb.CollectionConfigPackage{},
    77  			},
    78  		))
    79  	})
    80  
    81  	It("returns metadata for implicit collections", func() {
    82  		metadata := metadataProvider.Metadata("testchannel", "cc-name", "_implicit_org_msp1")
    83  		Expect(metadata.CollectionPolicies).To(HaveKey("_implicit_org_msp1"))
    84  	})
    85  
    86  	Context("when the chaincode is not found by the ChaincodeInfoProvider", func() {
    87  		BeforeEach(func() {
    88  			fakeChaincodeInfoProvider.ChaincodeInfoReturns(nil, errors.New("scrumtrulescent"))
    89  		})
    90  
    91  		It("returns metadata using the LegacyMetadataProvider", func() {
    92  			metadata := metadataProvider.Metadata("testchannel", "legacy-cc", "col1")
    93  			Expect(metadata).To(Equal(
    94  				&chaincode.Metadata{
    95  					Name:               "legacy-cc",
    96  					Version:            "legacy-version",
    97  					Policy:             []byte("legacy-policy"),
    98  					CollectionPolicies: nil,
    99  					CollectionsConfig:  &pb.CollectionConfigPackage{},
   100  				},
   101  			))
   102  		})
   103  	})
   104  
   105  	Context("when the policy is bad", func() {
   106  		BeforeEach(func() {
   107  			ccInfo.Definition.ValidationInfo.ValidationParameter = []byte{0, 1, 2}
   108  			fakeChaincodeInfoProvider.ChaincodeInfoReturns(ccInfo, nil)
   109  		})
   110  
   111  		It("returns nil", func() {
   112  			metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1")
   113  			Expect(metadata).To(BeNil())
   114  		})
   115  	})
   116  
   117  	Context("when the policy is of the channel reference type", func() {
   118  		BeforeEach(func() {
   119  			ccInfo.Definition.ValidationInfo.ValidationParameter = protoutil.MarshalOrPanic(
   120  				&pb.ApplicationPolicy{
   121  					Type: &pb.ApplicationPolicy_ChannelConfigPolicyReference{
   122  						ChannelConfigPolicyReference: "barf",
   123  					},
   124  				})
   125  			fakeChaincodeInfoProvider.ChaincodeInfoReturns(ccInfo, nil)
   126  
   127  			fakeConvertedPolicy = &mock.ConvertiblePolicy{}
   128  			fakeConvertedPolicy.ConvertReturns(policydsl.AcceptAllPolicy, nil)
   129  
   130  			fakeChannelPolicyReferenceProvider = &mock.ChannelPolicyReferenceProvider{}
   131  			fakeChannelPolicyReferenceProvider.NewPolicyReturns(fakeConvertedPolicy, nil)
   132  			metadataProvider.ChannelPolicyReferenceProvider = fakeChannelPolicyReferenceProvider
   133  		})
   134  
   135  		It("returns metadata after translating the policy", func() {
   136  			metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1")
   137  			Expect(metadata).To(Equal(
   138  				&chaincode.Metadata{
   139  					Name:               "cc-name",
   140  					Version:            "1",
   141  					Policy:             policydsl.MarshaledAcceptAllPolicy,
   142  					CollectionPolicies: map[string][]byte{},
   143  					CollectionsConfig:  &pb.CollectionConfigPackage{},
   144  				},
   145  			))
   146  		})
   147  
   148  		Context("when NewPolicy returns an error", func() {
   149  			BeforeEach(func() {
   150  				fakeChannelPolicyReferenceProvider = &mock.ChannelPolicyReferenceProvider{}
   151  				fakeChannelPolicyReferenceProvider.NewPolicyReturns(nil, errors.New("go away"))
   152  				metadataProvider.ChannelPolicyReferenceProvider = fakeChannelPolicyReferenceProvider
   153  			})
   154  
   155  			It("returns nil", func() {
   156  				metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1")
   157  				Expect(metadata).To(BeNil())
   158  			})
   159  		})
   160  
   161  		Context("when the policy is not convertible", func() {
   162  			BeforeEach(func() {
   163  				fakeChannelPolicyReferenceProvider = &mock.ChannelPolicyReferenceProvider{}
   164  				fakeChannelPolicyReferenceProvider.NewPolicyReturns(&mock.InconvertiblePolicy{}, nil)
   165  				metadataProvider.ChannelPolicyReferenceProvider = fakeChannelPolicyReferenceProvider
   166  			})
   167  
   168  			It("returns nil", func() {
   169  				metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1")
   170  				Expect(metadata).To(BeNil())
   171  			})
   172  		})
   173  
   174  		Context("when conversion fails", func() {
   175  			BeforeEach(func() {
   176  				fakeConvertedPolicy = &mock.ConvertiblePolicy{}
   177  				fakeConvertedPolicy.ConvertReturns(nil, errors.New("go away"))
   178  
   179  				fakeChannelPolicyReferenceProvider = &mock.ChannelPolicyReferenceProvider{}
   180  				fakeChannelPolicyReferenceProvider.NewPolicyReturns(fakeConvertedPolicy, nil)
   181  				metadataProvider.ChannelPolicyReferenceProvider = fakeChannelPolicyReferenceProvider
   182  			})
   183  
   184  			It("returns nil", func() {
   185  				metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1")
   186  				Expect(metadata).To(BeNil())
   187  			})
   188  		})
   189  	})
   190  
   191  	Context("when collection endorsement policies exist", func() {
   192  		var (
   193  			expectedSignaturePolicy         *common.SignaturePolicyEnvelope
   194  			expectedCollectionConfigPackage *pb.CollectionConfigPackage
   195  		)
   196  
   197  		BeforeEach(func() {
   198  			expectedSignaturePolicy = &common.SignaturePolicyEnvelope{
   199  				Identities: []*msp.MSPPrincipal{
   200  					{
   201  						Principal: []byte("test"),
   202  					},
   203  				},
   204  			}
   205  
   206  			expectedCollectionConfigPackage = &pb.CollectionConfigPackage{
   207  				Config: []*pb.CollectionConfig{
   208  					{
   209  						Payload: &pb.CollectionConfig_StaticCollectionConfig{
   210  							StaticCollectionConfig: &pb.StaticCollectionConfig{
   211  								Name: "col1",
   212  								EndorsementPolicy: &pb.ApplicationPolicy{
   213  									Type: &pb.ApplicationPolicy_SignaturePolicy{
   214  										SignaturePolicy: expectedSignaturePolicy,
   215  									},
   216  								},
   217  							},
   218  						},
   219  					},
   220  					{
   221  						Payload: &pb.CollectionConfig_StaticCollectionConfig{
   222  							StaticCollectionConfig: &pb.StaticCollectionConfig{
   223  								Name: "col2",
   224  								EndorsementPolicy: &pb.ApplicationPolicy{
   225  									Type: &pb.ApplicationPolicy_SignaturePolicy{
   226  										SignaturePolicy: expectedSignaturePolicy,
   227  									},
   228  								},
   229  							},
   230  						},
   231  					},
   232  					{
   233  						Payload: &pb.CollectionConfig_StaticCollectionConfig{
   234  							StaticCollectionConfig: &pb.StaticCollectionConfig{
   235  								Name: "col3",
   236  								// col3 has no endorsement policy
   237  								EndorsementPolicy: nil,
   238  							},
   239  						},
   240  					},
   241  				},
   242  			}
   243  			ccInfo = &lifecycle.LocalChaincodeInfo{
   244  				Definition: &lifecycle.ChaincodeDefinition{
   245  					Sequence: 1,
   246  					EndorsementInfo: &lb.ChaincodeEndorsementInfo{
   247  						Version: "cc-version",
   248  					},
   249  					ValidationInfo: &lb.ChaincodeValidationInfo{
   250  						ValidationParameter: protoutil.MarshalOrPanic(&pb.ApplicationPolicy{
   251  							Type: &pb.ApplicationPolicy_SignaturePolicy{
   252  								SignaturePolicy: policydsl.AcceptAllPolicy,
   253  							},
   254  						}),
   255  					},
   256  					Collections: expectedCollectionConfigPackage,
   257  				},
   258  			}
   259  			fakeChaincodeInfoProvider.ChaincodeInfoReturns(ccInfo, nil)
   260  		})
   261  
   262  		It("returns metadata that includes the collection policies", func() {
   263  			metadata := metadataProvider.Metadata("testchannel", "cc-name", "col1", "col2", "col3")
   264  			Expect(metadata).To(Equal(
   265  				&chaincode.Metadata{
   266  					Name:    "cc-name",
   267  					Version: "1",
   268  					Policy:  policydsl.MarshaledAcceptAllPolicy,
   269  					CollectionPolicies: map[string][]byte{
   270  						"col1": protoutil.MarshalOrPanic(expectedSignaturePolicy),
   271  						"col2": protoutil.MarshalOrPanic(expectedSignaturePolicy),
   272  						// col3 has no endorsement policy
   273  					},
   274  					CollectionsConfig: expectedCollectionConfigPackage,
   275  				},
   276  			))
   277  		})
   278  	})
   279  })