github.com/lzy4123/fabric@v2.1.1+incompatible/core/common/validation/statebased/v20_test.go (about)

     1  /*
     2  Copyright IBM Corp. All Rights Reserved.
     3  
     4  SPDX-License-Identifier: Apache-2.0
     5  */
     6  
     7  package statebased
     8  
     9  import (
    10  	"testing"
    11  
    12  	verr "github.com/hyperledger/fabric/common/errors"
    13  	"github.com/hyperledger/fabric/core/common/validation/statebased/mocks"
    14  	"github.com/hyperledger/fabric/core/ledger"
    15  	"github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/rwsetutil"
    16  	"github.com/hyperledger/fabric/protoutil"
    17  	"github.com/pkg/errors"
    18  	"github.com/stretchr/testify/assert"
    19  	"github.com/stretchr/testify/mock"
    20  )
    21  
    22  func Test0(t *testing.T) {
    23  	t.Parallel()
    24  
    25  	// SCENARIO: no writes anywhere -> check the ccep
    26  
    27  	cc := "cc"
    28  	ccep := []byte("ccep")
    29  
    30  	ms := &mockStateFetcher{}
    31  
    32  	pm := &mocks.KeyLevelValidationParameterManager{}
    33  
    34  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
    35  
    36  	cr := &mocks.CollectionResources{}
    37  
    38  	pcf := NewV20Evaluator(pm, pe, cr, ms)
    39  
    40  	ev := pcf.Evaluator(ccep)
    41  
    42  	rwsb := rwsetutil.NewRWSetBuilder()
    43  	rws := rwsb.GetTxReadWriteSet()
    44  
    45  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
    46  	assert.Error(t, err)
    47  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
    48  }
    49  
    50  func Test1(t *testing.T) {
    51  	t.Parallel()
    52  
    53  	// SCENARIO: only one write in the public namespace -> check the ccep
    54  
    55  	cc := "cc"
    56  	key := "key"
    57  	ccep := []byte("ccep")
    58  
    59  	ms := &mockStateFetcher{}
    60  
    61  	pm := &mocks.KeyLevelValidationParameterManager{}
    62  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
    63  
    64  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
    65  
    66  	cr := &mocks.CollectionResources{}
    67  
    68  	pcf := NewV20Evaluator(pm, pe, cr, ms)
    69  
    70  	ev := pcf.Evaluator(ccep)
    71  
    72  	rwsb := rwsetutil.NewRWSetBuilder()
    73  	rwsb.AddToWriteSet(cc, key, []byte("value"))
    74  	rws := rwsb.GetTxReadWriteSet()
    75  
    76  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
    77  	assert.Error(t, err)
    78  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
    79  }
    80  
    81  func Test1Multiple(t *testing.T) {
    82  	t.Parallel()
    83  
    84  	// SCENARIO: only one write in the public namespace -> check the ccep
    85  
    86  	cc := "cc"
    87  	key := "key"
    88  	ccep := []byte("ccep")
    89  
    90  	ms := &mockStateFetcher{}
    91  
    92  	pm := &mocks.KeyLevelValidationParameterManager{}
    93  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
    94  
    95  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): nil}, EvaluateRV: errors.New("nope")}
    96  
    97  	cr := &mocks.CollectionResources{}
    98  
    99  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   100  
   101  	ev := pcf.Evaluator(ccep)
   102  
   103  	rwsb := rwsetutil.NewRWSetBuilder()
   104  	rwsb.AddToWriteSet(cc, key, []byte("value"))
   105  	rwsb.AddToWriteSet(cc, key+"1", []byte("value"))
   106  	rws := rwsb.GetTxReadWriteSet()
   107  
   108  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   109  	assert.NoError(t, err)
   110  }
   111  
   112  func Test1NoErr(t *testing.T) {
   113  	t.Parallel()
   114  
   115  	// SCENARIO: only one write in the public namespace -> check the ccep
   116  
   117  	cc := "cc"
   118  	key := "key"
   119  	ccep := []byte("ccep")
   120  
   121  	ms := &mockStateFetcher{}
   122  
   123  	pm := &mocks.KeyLevelValidationParameterManager{}
   124  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, &ledger.CollConfigNotDefinedError{})
   125  
   126  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
   127  
   128  	cr := &mocks.CollectionResources{}
   129  
   130  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   131  
   132  	ev := pcf.Evaluator(ccep)
   133  
   134  	rwsb := rwsetutil.NewRWSetBuilder()
   135  	rwsb.AddToWriteSet(cc, key, []byte("value"))
   136  	rws := rwsb.GetTxReadWriteSet()
   137  
   138  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   139  	assert.Error(t, err)
   140  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   141  }
   142  
   143  func Test1Err1(t *testing.T) {
   144  	t.Parallel()
   145  
   146  	// SCENARIO: error fetching validation params
   147  
   148  	cc := "cc"
   149  	key := "key"
   150  	ccep := []byte("ccep")
   151  
   152  	ms := &mockStateFetcher{}
   153  
   154  	pm := &mocks.KeyLevelValidationParameterManager{}
   155  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, &ValidationParameterUpdatedError{})
   156  
   157  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
   158  
   159  	cr := &mocks.CollectionResources{}
   160  
   161  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   162  
   163  	ev := pcf.Evaluator(ccep)
   164  
   165  	rwsb := rwsetutil.NewRWSetBuilder()
   166  	rwsb.AddToWriteSet(cc, key, []byte("value"))
   167  	rws := rwsb.GetTxReadWriteSet()
   168  
   169  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   170  	assert.Error(t, err)
   171  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   172  }
   173  
   174  func Test1Err2(t *testing.T) {
   175  	t.Parallel()
   176  
   177  	// SCENARIO: error fetching validation params
   178  
   179  	cc := "cc"
   180  	key := "key"
   181  	ccep := []byte("ccep")
   182  
   183  	ms := &mockStateFetcher{}
   184  
   185  	pm := &mocks.KeyLevelValidationParameterManager{}
   186  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, errors.New("heavy metal hamster"))
   187  
   188  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
   189  
   190  	cr := &mocks.CollectionResources{}
   191  
   192  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   193  
   194  	ev := pcf.Evaluator(ccep)
   195  
   196  	rwsb := rwsetutil.NewRWSetBuilder()
   197  	rwsb.AddToWriteSet(cc, key, []byte("value"))
   198  	rws := rwsb.GetTxReadWriteSet()
   199  
   200  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   201  	assert.Error(t, err)
   202  	assert.IsType(t, err, &verr.VSCCExecutionFailureError{})
   203  }
   204  
   205  func Test1Meta(t *testing.T) {
   206  	t.Parallel()
   207  
   208  	// SCENARIO: only one meta write in the public namespace -> check the ccep
   209  
   210  	cc := "cc"
   211  	key := "key"
   212  	ccep := []byte("ccep")
   213  
   214  	ms := &mockStateFetcher{}
   215  
   216  	pm := &mocks.KeyLevelValidationParameterManager{}
   217  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
   218  
   219  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
   220  
   221  	cr := &mocks.CollectionResources{}
   222  
   223  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   224  
   225  	ev := pcf.Evaluator(ccep)
   226  
   227  	rwsb := rwsetutil.NewRWSetBuilder()
   228  	rwsb.AddToMetadataWriteSet(cc, key, nil)
   229  	rws := rwsb.GetTxReadWriteSet()
   230  
   231  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   232  	assert.Error(t, err)
   233  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   234  }
   235  
   236  func Test1MetaMultiple(t *testing.T) {
   237  	t.Parallel()
   238  
   239  	// SCENARIO: only one meta write in the public namespace -> check the ccep
   240  
   241  	cc := "cc"
   242  	key := "key"
   243  	ccep := []byte("ccep")
   244  
   245  	ms := &mockStateFetcher{}
   246  
   247  	pm := &mocks.KeyLevelValidationParameterManager{}
   248  	pm.On("GetValidationParameterForKey", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
   249  
   250  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): nil}, EvaluateRV: errors.New("nope")}
   251  
   252  	cr := &mocks.CollectionResources{}
   253  
   254  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   255  
   256  	ev := pcf.Evaluator(ccep)
   257  
   258  	rwsb := rwsetutil.NewRWSetBuilder()
   259  	rwsb.AddToMetadataWriteSet(cc, key, nil)
   260  	rwsb.AddToMetadataWriteSet(cc, key+"1", nil)
   261  	rws := rwsb.GetTxReadWriteSet()
   262  
   263  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   264  	assert.NoError(t, err)
   265  }
   266  
   267  func Test2(t *testing.T) {
   268  	t.Parallel()
   269  
   270  	// SCENARIO: only one write in the public namespace with SBEP -> check the SBEP
   271  
   272  	cc := "cc"
   273  	key := "key"
   274  	ccep := []byte("ccep")
   275  	sbep := []byte("sbep")
   276  
   277  	ms := &mockStateFetcher{}
   278  
   279  	pm := &mocks.KeyLevelValidationParameterManager{}
   280  	pm.On("GetValidationParameterForKey", cc, "", key, mock.Anything, mock.Anything).Return(sbep, nil)
   281  
   282  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(sbep): errors.New("nope")}}
   283  
   284  	cr := &mocks.CollectionResources{}
   285  
   286  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   287  
   288  	ev := pcf.Evaluator(ccep)
   289  
   290  	rwsb := rwsetutil.NewRWSetBuilder()
   291  	rwsb.AddToWriteSet(cc, key, []byte("value"))
   292  	rws := rwsb.GetTxReadWriteSet()
   293  
   294  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   295  	assert.Error(t, err)
   296  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   297  }
   298  
   299  func Test3(t *testing.T) {
   300  	t.Parallel()
   301  
   302  	// SCENARIO: only one write in a collection without COLLEP or SBEP -> check the CCEP
   303  
   304  	cc := "cc"
   305  	key := "key"
   306  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   307  	coll := "coll"
   308  	ccep := []byte("ccep")
   309  
   310  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   311  
   312  	pm := &mocks.KeyLevelValidationParameterManager{}
   313  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(nil, nil)
   314  
   315  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
   316  
   317  	cr := &mocks.CollectionResources{}
   318  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(nil, nil, nil)
   319  
   320  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   321  
   322  	ev := pcf.Evaluator(ccep)
   323  
   324  	rwsb := rwsetutil.NewRWSetBuilder()
   325  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("Well I guess you took my youth and gave it all away"))
   326  	rws := rwsb.GetTxReadWriteSet()
   327  
   328  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   329  	assert.Error(t, err)
   330  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   331  }
   332  
   333  func Test3Meta(t *testing.T) {
   334  	t.Parallel()
   335  
   336  	// SCENARIO: only one meta write in a collection without COLLEP or SBEP -> check the CCEP
   337  
   338  	cc := "cc"
   339  	key := "key"
   340  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   341  	coll := "coll"
   342  	ccep := []byte("ccep")
   343  
   344  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   345  
   346  	pm := &mocks.KeyLevelValidationParameterManager{}
   347  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(nil, nil)
   348  
   349  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(ccep): errors.New("nope")}}
   350  
   351  	cr := &mocks.CollectionResources{}
   352  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(nil, nil, nil)
   353  
   354  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   355  
   356  	ev := pcf.Evaluator(ccep)
   357  
   358  	rwsb := rwsetutil.NewRWSetBuilder()
   359  	rwsb.AddToHashedMetadataWriteSet(cc, coll, key, nil)
   360  	rws := rwsb.GetTxReadWriteSet()
   361  
   362  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   363  	assert.Error(t, err)
   364  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   365  }
   366  
   367  func Test4(t *testing.T) {
   368  	t.Parallel()
   369  
   370  	// SCENARIO: only one write in a collection with COLLEP -> check COLLEP
   371  
   372  	cc := "cc"
   373  	key := "key"
   374  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   375  	coll := "coll"
   376  	ccep := []byte("ccep")
   377  	collep := []byte("collep")
   378  
   379  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   380  
   381  	pm := &mocks.KeyLevelValidationParameterManager{}
   382  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(nil, nil)
   383  
   384  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(collep): errors.New("nope")}}
   385  
   386  	cr := &mocks.CollectionResources{}
   387  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(collep, nil, nil)
   388  
   389  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   390  
   391  	ev := pcf.Evaluator(ccep)
   392  
   393  	rwsb := rwsetutil.NewRWSetBuilder()
   394  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("Well I guess you took my youth"))
   395  	rws := rwsb.GetTxReadWriteSet()
   396  
   397  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   398  	assert.Error(t, err)
   399  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   400  }
   401  
   402  func Test4Multiple(t *testing.T) {
   403  	t.Parallel()
   404  
   405  	// SCENARIO: only one write in a collection with COLLEP -> check COLLEP
   406  
   407  	cc := "cc"
   408  	key := "key"
   409  	coll := "coll"
   410  	ccep := []byte("ccep")
   411  	collep := []byte("collep")
   412  
   413  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   414  
   415  	pm := &mocks.KeyLevelValidationParameterManager{}
   416  	pm.On("GetValidationParameterForKey", cc, coll, mock.Anything, mock.Anything, mock.Anything).Return(nil, nil)
   417  
   418  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(collep): nil}, EvaluateRV: errors.New("nope")}
   419  
   420  	cr := &mocks.CollectionResources{}
   421  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(collep, nil, nil)
   422  
   423  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   424  
   425  	ev := pcf.Evaluator(ccep)
   426  
   427  	rwsb := rwsetutil.NewRWSetBuilder()
   428  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("As I was goin' over"))
   429  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key+"1", []byte("The Cork and Kerry Mountains"))
   430  	rws := rwsb.GetTxReadWriteSet()
   431  
   432  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   433  	assert.NoError(t, err)
   434  }
   435  
   436  func Test4Err(t *testing.T) {
   437  	t.Parallel()
   438  
   439  	// SCENARIO: error while retrieving COLLEP
   440  
   441  	cc := "cc"
   442  	key := "key"
   443  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   444  	coll := "coll"
   445  	ccep := []byte("ccep")
   446  
   447  	ms := &mockStateFetcher{FetchStateErr: errors.New("Dr. Stein grows funny creatures")}
   448  
   449  	pm := &mocks.KeyLevelValidationParameterManager{}
   450  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(nil, nil)
   451  
   452  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{}}
   453  
   454  	cr := &mocks.CollectionResources{}
   455  
   456  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   457  
   458  	ev := pcf.Evaluator(ccep)
   459  
   460  	rwsb := rwsetutil.NewRWSetBuilder()
   461  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("Well I guess you took my youth"))
   462  	rws := rwsb.GetTxReadWriteSet()
   463  
   464  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   465  	assert.Error(t, err)
   466  	assert.IsType(t, err, &verr.VSCCExecutionFailureError{})
   467  }
   468  
   469  func Test5(t *testing.T) {
   470  	t.Parallel()
   471  
   472  	// SCENARIO: only one write in a collection with SBEP -> check SBEP
   473  
   474  	cc := "cc"
   475  	key := "key"
   476  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   477  	coll := "coll"
   478  	ccep := []byte("ccep")
   479  	collep := []byte("collep")
   480  	sbep := []byte("sbep")
   481  
   482  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   483  
   484  	pm := &mocks.KeyLevelValidationParameterManager{}
   485  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(sbep, nil)
   486  
   487  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{string(sbep): errors.New("nope")}}
   488  
   489  	cr := &mocks.CollectionResources{}
   490  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(collep, nil, nil)
   491  
   492  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   493  
   494  	ev := pcf.Evaluator(ccep)
   495  
   496  	rwsb := rwsetutil.NewRWSetBuilder()
   497  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("Well I guess you took my youth and gave it all away"))
   498  	rws := rwsb.GetTxReadWriteSet()
   499  
   500  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   501  	assert.Error(t, err)
   502  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   503  }
   504  
   505  func Test6(t *testing.T) {
   506  	t.Parallel()
   507  
   508  	// SCENARIO: unexpected error while fetching collection validation info
   509  
   510  	cc := "cc"
   511  	key := "key"
   512  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   513  	coll := "coll"
   514  	ccep := []byte("ccep")
   515  
   516  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   517  
   518  	pm := &mocks.KeyLevelValidationParameterManager{}
   519  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(nil, nil)
   520  
   521  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{}}
   522  
   523  	cr := &mocks.CollectionResources{}
   524  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(nil, errors.New("two minutes to midnight"), nil)
   525  
   526  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   527  
   528  	ev := pcf.Evaluator(ccep)
   529  
   530  	rwsb := rwsetutil.NewRWSetBuilder()
   531  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("Well I guess you took my youth and gave it all away"))
   532  	rws := rwsb.GetTxReadWriteSet()
   533  
   534  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   535  	assert.Error(t, err)
   536  	assert.IsType(t, err, &verr.VSCCExecutionFailureError{})
   537  }
   538  
   539  func Test7(t *testing.T) {
   540  	t.Parallel()
   541  
   542  	// SCENARIO: deterministic error while fetching collection validation info
   543  
   544  	cc := "cc"
   545  	key := "key"
   546  	hashedKey := ",p\xe1+z\x06F\xf9\"y\xf4'dz\x8es4\xd8\xe58\x9c\xff\x16z\x1d\xc3\x0es\xf8&\xb6\x83"
   547  	coll := "coll"
   548  	ccep := []byte("ccep")
   549  
   550  	ms := &mockStateFetcher{FetchStateRv: &mockState{}}
   551  
   552  	pm := &mocks.KeyLevelValidationParameterManager{}
   553  	pm.On("GetValidationParameterForKey", cc, coll, hashedKey, mock.Anything, mock.Anything).Return(nil, nil)
   554  
   555  	pe := &mockPolicyEvaluator{EvaluateResByPolicy: map[string]error{}}
   556  
   557  	cr := &mocks.CollectionResources{}
   558  	cr.On("CollectionValidationInfo", cc, coll, mock.Anything).Return(nil, nil, errors.New("nope"))
   559  
   560  	pcf := NewV20Evaluator(pm, pe, cr, ms)
   561  
   562  	ev := pcf.Evaluator(ccep)
   563  
   564  	rwsb := rwsetutil.NewRWSetBuilder()
   565  	rwsb.AddToPvtAndHashedWriteSet(cc, coll, key, []byte("Well I guess you took my youth and gave it all away"))
   566  	rws := rwsb.GetTxReadWriteSet()
   567  
   568  	err := ev.Evaluate(1, 1, rws.NsRwSets, cc, []*protoutil.SignedData{{}})
   569  	assert.Error(t, err)
   570  	assert.IsType(t, err, &verr.VSCCEndorsementPolicyError{})
   571  }