github.com/yacovm/fabric@v2.0.0-alpha.0.20191128145320-c5d4087dc723+incompatible/core/common/privdata/store_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package privdata
     8  
     9  import (
    10  	"testing"
    11  
    12  	"github.com/hyperledger/fabric-protos-go/peer"
    13  	"github.com/hyperledger/fabric/common/cauthdsl"
    14  	lm "github.com/hyperledger/fabric/common/mocks/ledger"
    15  	"github.com/hyperledger/fabric/core/common/privdata/mock"
    16  	"github.com/hyperledger/fabric/core/ledger"
    17  	"github.com/hyperledger/fabric/protoutil"
    18  	"github.com/pkg/errors"
    19  	"github.com/stretchr/testify/assert"
    20  )
    21  
    22  // local interfaces to avoid import cycles
    23  //go:generate counterfeiter -o mock/query_executor_factory.go -fake-name QueryExecutorFactory . queryExecutorFactory
    24  //go:generate counterfeiter -o mock/chaincode_info_provider.go -fake-name ChaincodeInfoProvider . chaincodeInfoProvider
    25  //go:generate counterfeiter -o mock/identity_deserializer_factory.go -fake-name IdentityDeserializerFactory . identityDeserializerFactory
    26  
    27  type queryExecutorFactory interface{ QueryExecutorFactory }
    28  type chaincodeInfoProvider interface{ ChaincodeInfoProvider }
    29  type identityDeserializerFactory interface{ IdentityDeserializerFactory }
    30  
    31  func TestNewSimpleCollectionStore(t *testing.T) {
    32  	mockQueryExecutorFactory := &mock.QueryExecutorFactory{}
    33  	mockCCInfoProvider := &mock.ChaincodeInfoProvider{}
    34  
    35  	cs := NewSimpleCollectionStore(mockQueryExecutorFactory, mockCCInfoProvider)
    36  	assert.NotNil(t, cs)
    37  	assert.Exactly(t, mockQueryExecutorFactory, cs.qeFactory)
    38  	assert.Exactly(t, mockCCInfoProvider, cs.ccInfoProvider)
    39  	assert.NotNil(t, cs.idDeserializerFactory)
    40  }
    41  
    42  func TestCollectionStore(t *testing.T) {
    43  	mockQueryExecutorFactory := &mock.QueryExecutorFactory{}
    44  	mockCCInfoProvider := &mock.ChaincodeInfoProvider{}
    45  	mockCCInfoProvider.AllCollectionsConfigPkgReturns(nil, errors.New("Chaincode [non-existing-chaincode] does not exist"))
    46  	mockIDDeserializerFactory := &mock.IdentityDeserializerFactory{}
    47  	mockIDDeserializerFactory.GetIdentityDeserializerReturns(&mockDeserializer{})
    48  
    49  	cs := &SimpleCollectionStore{
    50  		qeFactory:             mockQueryExecutorFactory,
    51  		ccInfoProvider:        mockCCInfoProvider,
    52  		idDeserializerFactory: mockIDDeserializerFactory,
    53  	}
    54  
    55  	mockQueryExecutorFactory.NewQueryExecutorReturns(nil, errors.New("new-query-executor-failed"))
    56  	_, err := cs.RetrieveCollection(CollectionCriteria{})
    57  	assert.Contains(t, err.Error(), "could not retrieve query executor for collection criteria")
    58  
    59  	mockQueryExecutorFactory.NewQueryExecutorReturns(&lm.MockQueryExecutor{}, nil)
    60  	_, err = cs.retrieveCollectionConfigPackage(CollectionCriteria{Namespace: "non-existing-chaincode"}, nil)
    61  	assert.EqualError(t, err, "Chaincode [non-existing-chaincode] does not exist")
    62  
    63  	_, err = cs.RetrieveCollection(CollectionCriteria{})
    64  	assert.Contains(t, err.Error(), "could not be found")
    65  
    66  	ccr := CollectionCriteria{Channel: "ch", Namespace: "cc", Collection: "mycollection"}
    67  	mockCCInfoProvider.CollectionInfoReturns(nil, errors.New("collection-info-error"))
    68  	_, err = cs.RetrieveCollection(ccr)
    69  	assert.EqualError(t, err, "collection-info-error")
    70  
    71  	scc := &peer.StaticCollectionConfig{Name: "mycollection"}
    72  	mockCCInfoProvider.CollectionInfoReturns(scc, nil)
    73  	_, err = cs.RetrieveCollection(ccr)
    74  	assert.Contains(t, err.Error(), "error setting up collection for collection criteria")
    75  
    76  	var signers = [][]byte{[]byte("signer0"), []byte("signer1")}
    77  	policyEnvelope := cauthdsl.Envelope(cauthdsl.Or(cauthdsl.SignedBy(0), cauthdsl.SignedBy(1)), signers)
    78  	accessPolicy := createCollectionPolicyConfig(policyEnvelope)
    79  
    80  	scc = &peer.StaticCollectionConfig{
    81  		Name:             "mycollection",
    82  		MemberOrgsPolicy: accessPolicy,
    83  		MemberOnlyRead:   false,
    84  		MemberOnlyWrite:  false,
    85  	}
    86  
    87  	mockCCInfoProvider.CollectionInfoReturns(scc, nil)
    88  	c, err := cs.RetrieveCollection(ccr)
    89  	assert.NoError(t, err)
    90  	assert.NotNil(t, c)
    91  
    92  	ca, err := cs.RetrieveCollectionAccessPolicy(ccr)
    93  	assert.NoError(t, err)
    94  	assert.NotNil(t, ca)
    95  
    96  	scc = &peer.StaticCollectionConfig{
    97  		Name:             "mycollection",
    98  		MemberOrgsPolicy: accessPolicy,
    99  		MemberOnlyRead:   true,
   100  		MemberOnlyWrite:  true,
   101  	}
   102  	cc := &peer.CollectionConfig{
   103  		Payload: &peer.CollectionConfig_StaticCollectionConfig{StaticCollectionConfig: scc},
   104  	}
   105  	ccp := &peer.CollectionConfigPackage{Config: []*peer.CollectionConfig{cc}}
   106  
   107  	mockCCInfoProvider.CollectionInfoReturns(scc, nil)
   108  	mockCCInfoProvider.ChaincodeInfoReturns(
   109  		&ledger.DeployedChaincodeInfo{ExplicitCollectionConfigPkg: ccp},
   110  		nil,
   111  	)
   112  	mockCCInfoProvider.AllCollectionsConfigPkgReturns(ccp, nil)
   113  
   114  	ccc, err := cs.RetrieveCollectionConfigPackage(ccr)
   115  	assert.NoError(t, err)
   116  	assert.NotNil(t, ccc)
   117  
   118  	signedProp, _ := protoutil.MockSignedEndorserProposalOrPanic("A", &peer.ChaincodeSpec{}, []byte("signer0"), []byte("msg1"))
   119  	readP, writeP, err := cs.RetrieveReadWritePermission(ccr, signedProp, &lm.MockQueryExecutor{})
   120  	assert.NoError(t, err)
   121  	assert.True(t, readP)
   122  	assert.True(t, writeP)
   123  
   124  	// only signer0 and signer1 are the members
   125  	signedProp, _ = protoutil.MockSignedEndorserProposalOrPanic("A", &peer.ChaincodeSpec{}, []byte("signer2"), []byte("msg1"))
   126  	readP, writeP, err = cs.RetrieveReadWritePermission(ccr, signedProp, &lm.MockQueryExecutor{})
   127  	assert.NoError(t, err)
   128  	assert.False(t, readP)
   129  	assert.False(t, writeP)
   130  
   131  	scc = &peer.StaticCollectionConfig{
   132  		Name:             "mycollection",
   133  		MemberOrgsPolicy: accessPolicy,
   134  		MemberOnlyRead:   false,
   135  		MemberOnlyWrite:  false,
   136  	}
   137  	mockCCInfoProvider.CollectionInfoReturns(scc, nil)
   138  
   139  	// only signer0 and signer1 are the members
   140  	signedProp, _ = protoutil.MockSignedEndorserProposalOrPanic("A", &peer.ChaincodeSpec{}, []byte("signer2"), []byte("msg1"))
   141  	readP, writeP, err = cs.RetrieveReadWritePermission(ccr, signedProp, &lm.MockQueryExecutor{})
   142  	assert.NoError(t, err)
   143  	assert.True(t, readP)
   144  	assert.True(t, writeP)
   145  }