github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/common/privdata/store_test.go (about)

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