From e3188cf60584695c2003ab14906ea6919f3e2728 Mon Sep 17 00:00:00 2001 From: Gari Singh Date: Sun, 24 Nov 2019 06:29:59 -0500 Subject: [PATCH] FAB-16437 Remove common/mocks from v12 validator - stop using common/mocks in core/handlers/validation/builtin/v12 - stop using mock cc as it adds more complexity than needed when you can simply "create" lscc records Change-Id: I22430f467b9cb95661688daa5fde42a55b870a43 Signed-off-by: Gari Singh --- .../v12/mocks/identity_deserializer.go | 6 +- .../builtin/v12/mocks/policy_evaluator.go | 6 +- .../validation/builtin/v12/mocks/state.go | 398 ++++++++++ .../builtin/v12/mocks/state_fetcher.go | 6 +- .../builtin/v12/validation_logic_test.go | 734 +++++------------- 5 files changed, 583 insertions(+), 567 deletions(-) create mode 100644 core/handlers/validation/builtin/v12/mocks/state.go diff --git a/core/handlers/validation/builtin/v12/mocks/identity_deserializer.go b/core/handlers/validation/builtin/v12/mocks/identity_deserializer.go index 7c63752b028..fea884dd733 100644 --- a/core/handlers/validation/builtin/v12/mocks/identity_deserializer.go +++ b/core/handlers/validation/builtin/v12/mocks/identity_deserializer.go @@ -2,11 +2,9 @@ package mocks -import ( - mock "github.com/stretchr/testify/mock" +import mock "github.com/stretchr/testify/mock" - validation "github.com/hyperledger/fabric/core/handlers/validation/api/identities" -) +import validation "github.com/hyperledger/fabric/core/handlers/validation/api/identities" // IdentityDeserializer is an autogenerated mock type for the IdentityDeserializer type type IdentityDeserializer struct { diff --git a/core/handlers/validation/builtin/v12/mocks/policy_evaluator.go b/core/handlers/validation/builtin/v12/mocks/policy_evaluator.go index c5942269030..e14c21bc606 100644 --- a/core/handlers/validation/builtin/v12/mocks/policy_evaluator.go +++ b/core/handlers/validation/builtin/v12/mocks/policy_evaluator.go @@ -2,10 +2,8 @@ package mocks -import ( - protoutil "github.com/hyperledger/fabric/protoutil" - mock "github.com/stretchr/testify/mock" -) +import mock "github.com/stretchr/testify/mock" +import protoutil "github.com/hyperledger/fabric/protoutil" // PolicyEvaluator is an autogenerated mock type for the PolicyEvaluator type type PolicyEvaluator struct { diff --git a/core/handlers/validation/builtin/v12/mocks/state.go b/core/handlers/validation/builtin/v12/mocks/state.go new file mode 100644 index 00000000000..51033438cba --- /dev/null +++ b/core/handlers/validation/builtin/v12/mocks/state.go @@ -0,0 +1,398 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package mocks + +import ( + "sync" + + validation "github.com/hyperledger/fabric/core/handlers/validation/api/state" +) + +type State struct { + DoneStub func() + doneMutex sync.RWMutex + doneArgsForCall []struct { + } + GetPrivateDataMetadataByHashStub func(string, string, []byte) (map[string][]byte, error) + getPrivateDataMetadataByHashMutex sync.RWMutex + getPrivateDataMetadataByHashArgsForCall []struct { + arg1 string + arg2 string + arg3 []byte + } + getPrivateDataMetadataByHashReturns struct { + result1 map[string][]byte + result2 error + } + getPrivateDataMetadataByHashReturnsOnCall map[int]struct { + result1 map[string][]byte + result2 error + } + GetStateMetadataStub func(string, string) (map[string][]byte, error) + getStateMetadataMutex sync.RWMutex + getStateMetadataArgsForCall []struct { + arg1 string + arg2 string + } + getStateMetadataReturns struct { + result1 map[string][]byte + result2 error + } + getStateMetadataReturnsOnCall map[int]struct { + result1 map[string][]byte + result2 error + } + GetStateMultipleKeysStub func(string, []string) ([][]byte, error) + getStateMultipleKeysMutex sync.RWMutex + getStateMultipleKeysArgsForCall []struct { + arg1 string + arg2 []string + } + getStateMultipleKeysReturns struct { + result1 [][]byte + result2 error + } + getStateMultipleKeysReturnsOnCall map[int]struct { + result1 [][]byte + result2 error + } + GetStateRangeScanIteratorStub func(string, string, string) (validation.ResultsIterator, error) + getStateRangeScanIteratorMutex sync.RWMutex + getStateRangeScanIteratorArgsForCall []struct { + arg1 string + arg2 string + arg3 string + } + getStateRangeScanIteratorReturns struct { + result1 validation.ResultsIterator + result2 error + } + getStateRangeScanIteratorReturnsOnCall map[int]struct { + result1 validation.ResultsIterator + result2 error + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *State) Done() { + fake.doneMutex.Lock() + fake.doneArgsForCall = append(fake.doneArgsForCall, struct { + }{}) + fake.recordInvocation("Done", []interface{}{}) + fake.doneMutex.Unlock() + if fake.DoneStub != nil { + fake.DoneStub() + } +} + +func (fake *State) DoneCallCount() int { + fake.doneMutex.RLock() + defer fake.doneMutex.RUnlock() + return len(fake.doneArgsForCall) +} + +func (fake *State) DoneCalls(stub func()) { + fake.doneMutex.Lock() + defer fake.doneMutex.Unlock() + fake.DoneStub = stub +} + +func (fake *State) GetPrivateDataMetadataByHash(arg1 string, arg2 string, arg3 []byte) (map[string][]byte, error) { + var arg3Copy []byte + if arg3 != nil { + arg3Copy = make([]byte, len(arg3)) + copy(arg3Copy, arg3) + } + fake.getPrivateDataMetadataByHashMutex.Lock() + ret, specificReturn := fake.getPrivateDataMetadataByHashReturnsOnCall[len(fake.getPrivateDataMetadataByHashArgsForCall)] + fake.getPrivateDataMetadataByHashArgsForCall = append(fake.getPrivateDataMetadataByHashArgsForCall, struct { + arg1 string + arg2 string + arg3 []byte + }{arg1, arg2, arg3Copy}) + fake.recordInvocation("GetPrivateDataMetadataByHash", []interface{}{arg1, arg2, arg3Copy}) + fake.getPrivateDataMetadataByHashMutex.Unlock() + if fake.GetPrivateDataMetadataByHashStub != nil { + return fake.GetPrivateDataMetadataByHashStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getPrivateDataMetadataByHashReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *State) GetPrivateDataMetadataByHashCallCount() int { + fake.getPrivateDataMetadataByHashMutex.RLock() + defer fake.getPrivateDataMetadataByHashMutex.RUnlock() + return len(fake.getPrivateDataMetadataByHashArgsForCall) +} + +func (fake *State) GetPrivateDataMetadataByHashCalls(stub func(string, string, []byte) (map[string][]byte, error)) { + fake.getPrivateDataMetadataByHashMutex.Lock() + defer fake.getPrivateDataMetadataByHashMutex.Unlock() + fake.GetPrivateDataMetadataByHashStub = stub +} + +func (fake *State) GetPrivateDataMetadataByHashArgsForCall(i int) (string, string, []byte) { + fake.getPrivateDataMetadataByHashMutex.RLock() + defer fake.getPrivateDataMetadataByHashMutex.RUnlock() + argsForCall := fake.getPrivateDataMetadataByHashArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *State) GetPrivateDataMetadataByHashReturns(result1 map[string][]byte, result2 error) { + fake.getPrivateDataMetadataByHashMutex.Lock() + defer fake.getPrivateDataMetadataByHashMutex.Unlock() + fake.GetPrivateDataMetadataByHashStub = nil + fake.getPrivateDataMetadataByHashReturns = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *State) GetPrivateDataMetadataByHashReturnsOnCall(i int, result1 map[string][]byte, result2 error) { + fake.getPrivateDataMetadataByHashMutex.Lock() + defer fake.getPrivateDataMetadataByHashMutex.Unlock() + fake.GetPrivateDataMetadataByHashStub = nil + if fake.getPrivateDataMetadataByHashReturnsOnCall == nil { + fake.getPrivateDataMetadataByHashReturnsOnCall = make(map[int]struct { + result1 map[string][]byte + result2 error + }) + } + fake.getPrivateDataMetadataByHashReturnsOnCall[i] = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *State) GetStateMetadata(arg1 string, arg2 string) (map[string][]byte, error) { + fake.getStateMetadataMutex.Lock() + ret, specificReturn := fake.getStateMetadataReturnsOnCall[len(fake.getStateMetadataArgsForCall)] + fake.getStateMetadataArgsForCall = append(fake.getStateMetadataArgsForCall, struct { + arg1 string + arg2 string + }{arg1, arg2}) + fake.recordInvocation("GetStateMetadata", []interface{}{arg1, arg2}) + fake.getStateMetadataMutex.Unlock() + if fake.GetStateMetadataStub != nil { + return fake.GetStateMetadataStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateMetadataReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *State) GetStateMetadataCallCount() int { + fake.getStateMetadataMutex.RLock() + defer fake.getStateMetadataMutex.RUnlock() + return len(fake.getStateMetadataArgsForCall) +} + +func (fake *State) GetStateMetadataCalls(stub func(string, string) (map[string][]byte, error)) { + fake.getStateMetadataMutex.Lock() + defer fake.getStateMetadataMutex.Unlock() + fake.GetStateMetadataStub = stub +} + +func (fake *State) GetStateMetadataArgsForCall(i int) (string, string) { + fake.getStateMetadataMutex.RLock() + defer fake.getStateMetadataMutex.RUnlock() + argsForCall := fake.getStateMetadataArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *State) GetStateMetadataReturns(result1 map[string][]byte, result2 error) { + fake.getStateMetadataMutex.Lock() + defer fake.getStateMetadataMutex.Unlock() + fake.GetStateMetadataStub = nil + fake.getStateMetadataReturns = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *State) GetStateMetadataReturnsOnCall(i int, result1 map[string][]byte, result2 error) { + fake.getStateMetadataMutex.Lock() + defer fake.getStateMetadataMutex.Unlock() + fake.GetStateMetadataStub = nil + if fake.getStateMetadataReturnsOnCall == nil { + fake.getStateMetadataReturnsOnCall = make(map[int]struct { + result1 map[string][]byte + result2 error + }) + } + fake.getStateMetadataReturnsOnCall[i] = struct { + result1 map[string][]byte + result2 error + }{result1, result2} +} + +func (fake *State) GetStateMultipleKeys(arg1 string, arg2 []string) ([][]byte, error) { + var arg2Copy []string + if arg2 != nil { + arg2Copy = make([]string, len(arg2)) + copy(arg2Copy, arg2) + } + fake.getStateMultipleKeysMutex.Lock() + ret, specificReturn := fake.getStateMultipleKeysReturnsOnCall[len(fake.getStateMultipleKeysArgsForCall)] + fake.getStateMultipleKeysArgsForCall = append(fake.getStateMultipleKeysArgsForCall, struct { + arg1 string + arg2 []string + }{arg1, arg2Copy}) + fake.recordInvocation("GetStateMultipleKeys", []interface{}{arg1, arg2Copy}) + fake.getStateMultipleKeysMutex.Unlock() + if fake.GetStateMultipleKeysStub != nil { + return fake.GetStateMultipleKeysStub(arg1, arg2) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateMultipleKeysReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *State) GetStateMultipleKeysCallCount() int { + fake.getStateMultipleKeysMutex.RLock() + defer fake.getStateMultipleKeysMutex.RUnlock() + return len(fake.getStateMultipleKeysArgsForCall) +} + +func (fake *State) GetStateMultipleKeysCalls(stub func(string, []string) ([][]byte, error)) { + fake.getStateMultipleKeysMutex.Lock() + defer fake.getStateMultipleKeysMutex.Unlock() + fake.GetStateMultipleKeysStub = stub +} + +func (fake *State) GetStateMultipleKeysArgsForCall(i int) (string, []string) { + fake.getStateMultipleKeysMutex.RLock() + defer fake.getStateMultipleKeysMutex.RUnlock() + argsForCall := fake.getStateMultipleKeysArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2 +} + +func (fake *State) GetStateMultipleKeysReturns(result1 [][]byte, result2 error) { + fake.getStateMultipleKeysMutex.Lock() + defer fake.getStateMultipleKeysMutex.Unlock() + fake.GetStateMultipleKeysStub = nil + fake.getStateMultipleKeysReturns = struct { + result1 [][]byte + result2 error + }{result1, result2} +} + +func (fake *State) GetStateMultipleKeysReturnsOnCall(i int, result1 [][]byte, result2 error) { + fake.getStateMultipleKeysMutex.Lock() + defer fake.getStateMultipleKeysMutex.Unlock() + fake.GetStateMultipleKeysStub = nil + if fake.getStateMultipleKeysReturnsOnCall == nil { + fake.getStateMultipleKeysReturnsOnCall = make(map[int]struct { + result1 [][]byte + result2 error + }) + } + fake.getStateMultipleKeysReturnsOnCall[i] = struct { + result1 [][]byte + result2 error + }{result1, result2} +} + +func (fake *State) GetStateRangeScanIterator(arg1 string, arg2 string, arg3 string) (validation.ResultsIterator, error) { + fake.getStateRangeScanIteratorMutex.Lock() + ret, specificReturn := fake.getStateRangeScanIteratorReturnsOnCall[len(fake.getStateRangeScanIteratorArgsForCall)] + fake.getStateRangeScanIteratorArgsForCall = append(fake.getStateRangeScanIteratorArgsForCall, struct { + arg1 string + arg2 string + arg3 string + }{arg1, arg2, arg3}) + fake.recordInvocation("GetStateRangeScanIterator", []interface{}{arg1, arg2, arg3}) + fake.getStateRangeScanIteratorMutex.Unlock() + if fake.GetStateRangeScanIteratorStub != nil { + return fake.GetStateRangeScanIteratorStub(arg1, arg2, arg3) + } + if specificReturn { + return ret.result1, ret.result2 + } + fakeReturns := fake.getStateRangeScanIteratorReturns + return fakeReturns.result1, fakeReturns.result2 +} + +func (fake *State) GetStateRangeScanIteratorCallCount() int { + fake.getStateRangeScanIteratorMutex.RLock() + defer fake.getStateRangeScanIteratorMutex.RUnlock() + return len(fake.getStateRangeScanIteratorArgsForCall) +} + +func (fake *State) GetStateRangeScanIteratorCalls(stub func(string, string, string) (validation.ResultsIterator, error)) { + fake.getStateRangeScanIteratorMutex.Lock() + defer fake.getStateRangeScanIteratorMutex.Unlock() + fake.GetStateRangeScanIteratorStub = stub +} + +func (fake *State) GetStateRangeScanIteratorArgsForCall(i int) (string, string, string) { + fake.getStateRangeScanIteratorMutex.RLock() + defer fake.getStateRangeScanIteratorMutex.RUnlock() + argsForCall := fake.getStateRangeScanIteratorArgsForCall[i] + return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 +} + +func (fake *State) GetStateRangeScanIteratorReturns(result1 validation.ResultsIterator, result2 error) { + fake.getStateRangeScanIteratorMutex.Lock() + defer fake.getStateRangeScanIteratorMutex.Unlock() + fake.GetStateRangeScanIteratorStub = nil + fake.getStateRangeScanIteratorReturns = struct { + result1 validation.ResultsIterator + result2 error + }{result1, result2} +} + +func (fake *State) GetStateRangeScanIteratorReturnsOnCall(i int, result1 validation.ResultsIterator, result2 error) { + fake.getStateRangeScanIteratorMutex.Lock() + defer fake.getStateRangeScanIteratorMutex.Unlock() + fake.GetStateRangeScanIteratorStub = nil + if fake.getStateRangeScanIteratorReturnsOnCall == nil { + fake.getStateRangeScanIteratorReturnsOnCall = make(map[int]struct { + result1 validation.ResultsIterator + result2 error + }) + } + fake.getStateRangeScanIteratorReturnsOnCall[i] = struct { + result1 validation.ResultsIterator + result2 error + }{result1, result2} +} + +func (fake *State) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + fake.doneMutex.RLock() + defer fake.doneMutex.RUnlock() + fake.getPrivateDataMetadataByHashMutex.RLock() + defer fake.getPrivateDataMetadataByHashMutex.RUnlock() + fake.getStateMetadataMutex.RLock() + defer fake.getStateMetadataMutex.RUnlock() + fake.getStateMultipleKeysMutex.RLock() + defer fake.getStateMultipleKeysMutex.RUnlock() + fake.getStateRangeScanIteratorMutex.RLock() + defer fake.getStateRangeScanIteratorMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *State) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} diff --git a/core/handlers/validation/builtin/v12/mocks/state_fetcher.go b/core/handlers/validation/builtin/v12/mocks/state_fetcher.go index badcade9aa5..93061caea56 100644 --- a/core/handlers/validation/builtin/v12/mocks/state_fetcher.go +++ b/core/handlers/validation/builtin/v12/mocks/state_fetcher.go @@ -2,11 +2,9 @@ package mocks -import ( - mock "github.com/stretchr/testify/mock" +import mock "github.com/stretchr/testify/mock" - validation "github.com/hyperledger/fabric/core/handlers/validation/api/state" -) +import validation "github.com/hyperledger/fabric/core/handlers/validation/api/state" // StateFetcher is an autogenerated mock type for the StateFetcher type type StateFetcher struct { diff --git a/core/handlers/validation/builtin/v12/validation_logic_test.go b/core/handlers/validation/builtin/v12/validation_logic_test.go index 81a2874cae8..ccdb658ce78 100644 --- a/core/handlers/validation/builtin/v12/validation_logic_test.go +++ b/core/handlers/validation/builtin/v12/validation_logic_test.go @@ -15,8 +15,6 @@ import ( "testing" "github.com/golang/protobuf/proto" - "github.com/hyperledger/fabric-chaincode-go/shim" - "github.com/hyperledger/fabric-chaincode-go/shimtest" "github.com/hyperledger/fabric-protos-go/common" "github.com/hyperledger/fabric-protos-go/ledger/rwset/kvrwset" mspproto "github.com/hyperledger/fabric-protos-go/msp" @@ -25,16 +23,12 @@ import ( "github.com/hyperledger/fabric/common/capabilities" "github.com/hyperledger/fabric/common/cauthdsl" "github.com/hyperledger/fabric/common/channelconfig" - mc "github.com/hyperledger/fabric/common/mocks/config" - lm "github.com/hyperledger/fabric/common/mocks/ledger" - "github.com/hyperledger/fabric/common/mocks/scc" - aclmocks "github.com/hyperledger/fabric/core/aclmgmt/mocks" "github.com/hyperledger/fabric/core/committer/txvalidator/v14" - mocks2 "github.com/hyperledger/fabric/core/committer/txvalidator/v14/mocks" "github.com/hyperledger/fabric/core/common/ccpackage" "github.com/hyperledger/fabric/core/common/ccprovider" "github.com/hyperledger/fabric/core/common/privdata" validation "github.com/hyperledger/fabric/core/handlers/validation/api/capabilities" + vs "github.com/hyperledger/fabric/core/handlers/validation/api/state" "github.com/hyperledger/fabric/core/handlers/validation/builtin/v12/mocks" "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/rwsetutil" "github.com/hyperledger/fabric/core/scc/lscc" @@ -46,6 +40,12 @@ import ( "github.com/stretchr/testify/assert" ) +//go:generate counterfeiter -o mocks/state.go -fake-name State . vsState + +type vsState interface { + vs.State +} + func createTx(endorsedByDuplicatedIdentity bool) (*common.Envelope, error) { ccid := &peer.ChaincodeID{Name: "foo", Version: "v1"} cis := &peer.ChaincodeInvocationSpec{ChaincodeSpec: &peer.ChaincodeSpec{ChaincodeId: ccid}} @@ -341,13 +341,25 @@ func getSignedByMSPAdminPolicy(mspID string) ([]byte, error) { } func newValidationInstance(state map[string]map[string][]byte) *Validator { - qec := &mocks2.QueryExecutorCreator{} - qec.On("NewQueryExecutor").Return(lm.NewMockQueryExecutor(state), nil) - return newCustomValidationInstance(qec, &mc.MockApplicationCapabilities{}) + c := &mocks.Capabilities{} + c.On("PrivateChannelData").Return(false) + c.On("V1_1Validation").Return(false) + c.On("V1_2Validation").Return(false) + vs := &mocks.State{} + vs.GetStateMultipleKeysStub = func(namespace string, keys []string) ([][]byte, error) { + if ns, ok := state[namespace]; ok { + return [][]byte{ns[keys[0]]}, nil + + } else { + return nil, fmt.Errorf("could not retrieve namespace %s", namespace) + } + } + sf := &mocks.StateFetcher{} + sf.On("FetchState").Return(vs, nil) + return newCustomValidationInstance(sf, c) } -func newCustomValidationInstance(qec txvalidator.QueryExecutorCreator, c validation.Capabilities) *Validator { - sf := &txvalidator.StateFetcherImpl{QueryExecutorCreator: qec} +func newCustomValidationInstance(sf StateFetcher, c validation.Capabilities) *Validator { is := &mocks.IdentityDeserializer{} pe := &txvalidator.PolicyEvaluator{ IdentityDeserializer: mspmgmt.GetManagerForChain("testchannelid"), @@ -478,36 +490,10 @@ func TestInvoke(t *testing.T) { func TestRWSetTooBig(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - - r := stublccc.MockInit("1", [][]byte{}) - if r.Status != shim.OK { - fmt.Println("Init failed", string(r.Message)) - t.FailNow() - } - ccname := "mycc" ccver := "1" @@ -545,33 +531,15 @@ func TestRWSetTooBig(t *testing.T) { b := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "LSCC can only issue a single putState upon deploy") + t.Logf("error: %s", err) } func TestValidateDeployFail(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State ccname := "mycc" ccver := "1" @@ -598,7 +566,7 @@ func TestValidateDeployFail(t *testing.T) { b := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "No read write set for lscc was found") /************************/ /* test bogus write set */ @@ -628,7 +596,7 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "unmarhsalling of ChaincodeData failed, error unexpected EOF") /**********************/ /* test bad LSCC args */ @@ -655,7 +623,7 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "Wrong number of arguments for invocation lscc(deploy): expected at least 2, received 1") /**********************/ /* test bad LSCC args */ @@ -682,7 +650,7 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "GetChaincodeDeploymentSpec error error unmarshaling ChaincodeDeploymentSpec: unexpected EOF") /***********************/ /* test bad cc version */ @@ -709,7 +677,7 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "expected cc version 1, found 1.1") /*************/ /* bad rwset */ @@ -733,7 +701,7 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "txRWSet.FromProtoBytes error unexpected EOF") /********************/ /* test bad cc name */ @@ -759,7 +727,7 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "expected key mycc, found mycc.badbad") /**********************/ /* test bad cc name 2 */ @@ -785,10 +753,10 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "expected cc name mycc, found mycc.badbad") /************************/ - /* test suprious writes */ + /* test spurious writes */ /************************/ cd := &ccprovider.ChaincodeData{ @@ -822,56 +790,21 @@ func TestValidateDeployFail(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "LSCC invocation is attempting to write to namespace bogusbogus") } func TestAlreadyDeployed(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State ccname := "mycc" ccver := "alreadydeployed" - path := "mychaincode" - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, true) - if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() - } - - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() - } - - sProp2, _ := protoutil.MockSignedEndorserProposal2OrPanic(chainId, &peer.ChaincodeSpec{}, id) - args := [][]byte{[]byte("deploy"), []byte(ccname), b} - if res := stublccc.MockInvokeWithSignedProposal("1", args, sProp2); res.Status != shim.OK { - fmt.Printf("%#v\n", res) - t.FailNow() - } + // create state for ccname to simulate deployment + state["lscc"][ccname] = []byte{} simresres, err := createCCDataRWset(ccname, ccname, ccver, nil) assert.NoError(t, err) @@ -894,13 +827,17 @@ func TestAlreadyDeployed(t *testing.T) { bl := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "Chaincode mycc is already instantiated") } func TestValidateDeployNoLedger(t *testing.T) { - qec := &mocks2.QueryExecutorCreator{} - qec.On("NewQueryExecutor").Return(nil, errors.New("failed obtaining query executor")) - v := newCustomValidationInstance(qec, &mc.MockApplicationCapabilities{}) + sf := &mocks.StateFetcher{} + sf.On("FetchState").Return(nil, errors.New("failed obtaining query executor")) + capabilities := &mocks.Capabilities{} + capabilities.On("PrivateChannelData").Return(false) + capabilities.On("V1_1Validation").Return(false) + capabilities.On("V1_2Validation").Return(false) + v := newCustomValidationInstance(sf, capabilities) ccname := "mycc" ccver := "1" @@ -928,35 +865,15 @@ func TestValidateDeployNoLedger(t *testing.T) { b := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "could not retrieve QueryExecutor for channel testchannelid, error failed obtaining query executor") } func TestValidateDeployNOKNilChaincodeSpec(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - mockAclProvider := &aclmocks.MockACLProvider{} - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "1" @@ -1004,30 +921,10 @@ func TestValidateDeployNOKNilChaincodeSpec(t *testing.T) { func TestValidateDeployOK(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "1" @@ -1074,30 +971,10 @@ func TestValidateDeployNOK(t *testing.T) { // create validator and policy state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - mockAclProvider := &aclmocks.MockACLProvider{} - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - policy, err := getSignedByMSPAdminPolicy(mspid) assert.NoError(t, err) @@ -1129,41 +1006,24 @@ func testChaincodeDeployNOK(t *testing.T, ccName, ccVersion, errMsg string, v *V func TestValidateDeployWithCollection(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{ - PrivateChannelDataRv: true, - }}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) - - qec := &mocks2.QueryExecutorCreator{} - qec.On("NewQueryExecutor").Return(lm.NewMockQueryExecutor(state), nil) - v := newCustomValidationInstance(qec, &mc.MockApplicationCapabilities{ - PrivateChannelDataRv: true, - }) + state["lscc"] = make(map[string][]byte) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State + vs := &mocks.State{} + vs.GetStateMultipleKeysStub = func(namespace string, keys []string) ([][]byte, error) { + if ns, ok := state[namespace]; ok { + return [][]byte{ns[keys[0]]}, nil - r := stublccc.MockInit("1", [][]byte{}) - if r.Status != shim.OK { - fmt.Println("Init failed", string(r.Message)) - t.FailNow() + } else { + return nil, fmt.Errorf("could not retrieve namespace %s", namespace) + } } + sf := &mocks.StateFetcher{} + sf.On("FetchState").Return(vs, nil) + capabilities := &mocks.Capabilities{} + capabilities.On("PrivateChannelData").Return(true) + capabilities.On("V1_1Validation").Return(true) + capabilities.On("V1_2Validation").Return(false) + v := newCustomValidationInstance(sf, capabilities) ccname := "mycc" ccver := "1" @@ -1236,66 +1096,22 @@ func TestValidateDeployWithCollection(t *testing.T) { assert.NoError(t, err) // Test 3: Once the V1_2Validation is enabled, validation should fail due to duplicate collection configs - state = make(map[string]map[string][]byte) - mp = (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{ - PrivateChannelDataRv: true, - V1_2ValidationRv: true, - }}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) - - v = newValidationInstance(state) - lccc = &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc = shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - - r = stublccc.MockInit("1", [][]byte{}) - if r.Status != shim.OK { - fmt.Println("Init failed", string(r.Message)) - t.FailNow() - } + capabilities = &mocks.Capabilities{} + capabilities.On("PrivateChannelData").Return(true) + capabilities.On("V1_2Validation").Return(true) + v = newCustomValidationInstance(sf, capabilities) b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) + assert.EqualError(t, err, "collection-name: mycollection1 -- found duplicate collection configuration") } func TestValidateDeployWithPolicies(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "1" @@ -1351,35 +1167,15 @@ func TestValidateDeployWithPolicies(t *testing.T) { b = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "chaincode instantiation policy violated, error signature set did not satisfy policy") } func TestInvalidUpgrade(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "2" @@ -1404,58 +1200,34 @@ func TestInvalidUpgrade(t *testing.T) { b := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(b, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "Upgrading non-existent chaincode mycc") } func TestValidateUpgradeOK(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "upgradeok" - path := "mychaincode" + ccver = "2" - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, true) + // policy signed by the right MSP + policy, err := getSignedByMSPMemberPolicy(mspid) if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() + t.Fatalf("failed getting policy, err %s", err) } - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() + // create lscc record + cd := &ccprovider.ChaincodeData{ + InstantiationPolicy: policy, } - - sProp2, _ := protoutil.MockSignedEndorserProposal2OrPanic(chainId, &peer.ChaincodeSpec{}, id) - args := [][]byte{[]byte("deploy"), []byte(ccname), b} - if res := stublccc.MockInvokeWithSignedProposal("1", args, sProp2); res.Status != shim.OK { - fmt.Printf("%#v\n", res) - t.FailNow() + cdbytes, err := proto.Marshal(cd) + if err != nil { + t.Fatalf("Failed to marshal ChaincodeData: %s", err) } - - ccver = "2" + state["lscc"][ccname] = cdbytes simresres, err := createCCDataRWset(ccname, ccname, ccver, nil) assert.NoError(t, err) @@ -1470,12 +1242,6 @@ func TestValidateUpgradeOK(t *testing.T) { t.Fatalf("GetBytesEnvelope returned err %s", err) } - // good path: signed by the right MSP - policy, err := getSignedByMSPMemberPolicy(mspid) - if err != nil { - t.Fatalf("failed getting policy, err %s", err) - } - bl := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) assert.NoError(t, err) @@ -1483,51 +1249,29 @@ func TestValidateUpgradeOK(t *testing.T) { func TestInvalidateUpgradeBadVersion(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "upgradebadversion" - path := "mychaincode" - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, true) + // policy signed by the right MSP + policy, err := getSignedByMSPMemberPolicy(mspid) if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() + t.Fatalf("failed getting policy, err %s", err) } - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() + // create lscc record + cd := &ccprovider.ChaincodeData{ + InstantiationPolicy: policy, + Version: ccver, } - - sProp2, _ := protoutil.MockSignedEndorserProposal2OrPanic(chainId, &peer.ChaincodeSpec{}, id) - args := [][]byte{[]byte("deploy"), []byte(ccname), b} - if res := stublccc.MockInvokeWithSignedProposal("1", args, sProp2); res.Status != shim.OK { - fmt.Printf("%#v\n", res) - t.FailNow() + cdbytes, err := proto.Marshal(cd) + if err != nil { + t.Fatalf("Failed to marshal ChaincodeData: %s", err) } + state["lscc"][ccname] = cdbytes simresres, err := createCCDataRWset(ccname, ccname, ccver, nil) assert.NoError(t, err) @@ -1542,79 +1286,49 @@ func TestInvalidateUpgradeBadVersion(t *testing.T) { t.Fatalf("GetBytesEnvelope returned err %s", err) } - // good path: signed by the right MSP - policy, err := getSignedByMSPMemberPolicy(mspid) - if err != nil { - t.Fatalf("failed getting policy, err %s", err) - } - bl := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, fmt.Sprintf("Existing version of the cc on the ledger (%s) should be different from the upgraded one", ccver)) } func validateUpgradeWithCollection(t *testing.T, ccver string, V1_2Validation bool) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{ - PrivateChannelDataRv: true, - V1_2ValidationRv: V1_2Validation, - }}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) - - qec := &mocks2.QueryExecutorCreator{} - qec.On("NewQueryExecutor").Return(lm.NewMockQueryExecutor(state), nil) - v := newCustomValidationInstance(qec, &mc.MockApplicationCapabilities{ - PrivateChannelDataRv: true, - V1_2ValidationRv: V1_2Validation, - }) + state["lscc"] = make(map[string][]byte) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State + vs := &mocks.State{} + vs.GetStateMultipleKeysStub = func(namespace string, keys []string) ([][]byte, error) { + if ns, ok := state[namespace]; ok { + return [][]byte{ns[keys[0]]}, nil - r := stublccc.MockInit("1", [][]byte{}) - if r.Status != shim.OK { - fmt.Println("Init failed", string(r.Message)) - t.FailNow() + } else { + return nil, fmt.Errorf("could not retrieve namespace %s", namespace) + } } + sf := &mocks.StateFetcher{} + sf.On("FetchState").Return(vs, nil) + capabilities := &mocks.Capabilities{} + capabilities.On("PrivateChannelData").Return(true) + capabilities.On("V1_1Validation").Return(true) + capabilities.On("V1_2Validation").Return(V1_2Validation) + v := newCustomValidationInstance(sf, capabilities) ccname := "mycc" - path := "mychaincode" + ccver = "2" - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, true) + policy, err := getSignedByMSPMemberPolicy(mspid) if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() + t.Fatalf("failed getting policy, err %s", err) } - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() + // create lscc record + cd := &ccprovider.ChaincodeData{ + InstantiationPolicy: policy, } - - sProp2, _ := protoutil.MockSignedEndorserProposal2OrPanic(chainId, &peer.ChaincodeSpec{}, id) - args := [][]byte{[]byte("deploy"), []byte(ccname), b} - if res := stublccc.MockInvokeWithSignedProposal("1", args, sProp2); res.Status != shim.OK { - fmt.Printf("%#v\n", res) - t.FailNow() + cdbytes, err := proto.Marshal(cd) + if err != nil { + t.Fatalf("Failed to marshal ChaincodeData: %s", err) } - - ccver = "2" + state["lscc"][ccname] = cdbytes collName1 := "mycollection1" collName2 := "mycollection2" @@ -1652,12 +1366,6 @@ func validateUpgradeWithCollection(t *testing.T, ccver string, V1_2Validation bo t.Fatalf("GetBytesEnvelope returned err %s", err) } - // good path: signed by the right MSP - policy, err := getSignedByMSPMemberPolicy(mspid) - if err != nil { - t.Fatalf("failed getting policy, err %s", err) - } - bl := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) if V1_2Validation { @@ -1720,7 +1428,6 @@ func validateUpgradeWithCollection(t *testing.T, ccver string, V1_2Validation bo t.Fatalf("GetBytesEnvelope returned err %s", err) } - args = [][]byte{[]byte("dv"), envBytes, policy, ccpBytes} bl = &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) assert.Error(t, err, "existing collection named mycollection2 is missing in the new collection configuration package") @@ -1761,55 +1468,28 @@ func TestValidateUpgradeWithCollection(t *testing.T) { func TestValidateUpgradeWithPoliciesOK(t *testing.T) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - ccname := "mycc" ccver := "upgradewithpoliciesok" - path := "mychaincode" - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, false) + // policy signed by the right MSP + policy, err := getSignedByMSPMemberPolicy(mspid) if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() + t.Fatalf("failed getting policy, err %s", err) } - _, err = processSignedCDS(cds, cauthdsl.AcceptAllPolicy) - assert.NoError(t, err) - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() + // create lscc record + cd := &ccprovider.ChaincodeData{ + InstantiationPolicy: policy, } - - sProp2, _ := protoutil.MockSignedEndorserProposal2OrPanic(chainId, &peer.ChaincodeSpec{}, id) - args := [][]byte{[]byte("deploy"), []byte(ccname), b} - if res := stublccc.MockInvokeWithSignedProposal("1", args, sProp2); res.Status != shim.OK { - fmt.Printf("%#v\n", res) - t.FailNow() + cdbytes, err := proto.Marshal(cd) + if err != nil { + t.Fatalf("Failed to marshal ChaincodeData: %s", err) } - - ccver = "2" + state["lscc"][ccname] = cdbytes simresres, err := createCCDataRWset(ccname, ccname, ccver, nil) assert.NoError(t, err) @@ -1824,13 +1504,6 @@ func TestValidateUpgradeWithPoliciesOK(t *testing.T) { t.Fatalf("GetBytesEnvelope returned err %s", err) } - // good path: signed by the right MSP - policy, err := getSignedByMSPMemberPolicy(mspid) - if err != nil { - t.Fatalf("failed getting policy, err %s", err) - } - - args = [][]byte{[]byte("dv"), envBytes, policy} bl := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) assert.NoError(t, err) @@ -1852,65 +1525,43 @@ func TestValidateUpgradeWithNewFailAllIP(t *testing.T) { func validateUpgradeWithNewFailAllIP(t *testing.T, ccver string, v11capability, expecterr bool) { state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{V1_1ValidationRv: v11capability}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) - qec := &mocks2.QueryExecutorCreator{} - capabilities := &mc.MockApplicationCapabilities{} - if v11capability { - capabilities.V1_1ValidationRv = true - } - qec.On("NewQueryExecutor").Return(lm.NewMockQueryExecutor(state), nil) - v := newCustomValidationInstance(qec, capabilities) + vs := &mocks.State{} + vs.GetStateMultipleKeysStub = func(namespace string, keys []string) ([][]byte, error) { + if ns, ok := state[namespace]; ok { + return [][]byte{ns[keys[0]]}, nil - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, + } else { + return nil, fmt.Errorf("could not retrieve namespace %s", namespace) + } } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - - // deploy the chaincode with an accept all policy + sf := &mocks.StateFetcher{} + sf.On("FetchState").Return(vs, nil) + capabilities := &mocks.Capabilities{} + capabilities.On("PrivateChannelData").Return(true) + capabilities.On("V1_1Validation").Return(v11capability) + capabilities.On("V1_2Validation").Return(false) + v := newCustomValidationInstance(sf, capabilities) ccname := "mycc" - path := "mychaincode" + ccver = "2" - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, false) + // create lscc record with accept all instantiation policy + ipbytes, err := proto.Marshal(cauthdsl.AcceptAllPolicy) if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() + t.Fatalf("Failed to marshal AcceptAllPolicy: %s", err) } - _, err = processSignedCDS(cds, cauthdsl.AcceptAllPolicy) - assert.NoError(t, err) - - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() + cd := &ccprovider.ChaincodeData{ + InstantiationPolicy: ipbytes, } - - sProp2, _ := protoutil.MockSignedEndorserProposal2OrPanic(chainId, &peer.ChaincodeSpec{}, id) - args := [][]byte{[]byte("deploy"), []byte(ccname), b} - if res := stublccc.MockInvokeWithSignedProposal("1", args, sProp2); res.Status != shim.OK { - fmt.Printf("%#v\n", res) - t.FailNow() + cdbytes, err := proto.Marshal(cd) + if err != nil { + t.Fatalf("Failed to marshal ChaincodeData: %s", err) } - - // if we're here, we have a cc deployed with an accept all IP + state["lscc"][ccname] = cdbytes // now we upgrade, with v 2 of the same cc, with the crucial difference that it has a reject all IP - ccver = ccver + ".2" simresres, err := createCCDataRWset(ccname, ccname, ccver, @@ -1946,57 +1597,30 @@ func validateUpgradeWithNewFailAllIP(t *testing.T, ccver string, v11capability, } func TestValidateUpgradeWithPoliciesFail(t *testing.T) { + ccname := "mycc" + ccver := "upgradewithpoliciesfail" + state := make(map[string]map[string][]byte) - mp := (&scc.MocksccProviderFactory{ - Qe: lm.NewMockQueryExecutor(state), - ApplicationConfigBool: true, - ApplicationConfigRv: &mc.MockApplication{CapabilitiesRv: &mc.MockApplicationCapabilities{}}, - }).NewSystemChaincodeProvider().(*scc.MocksccProviderImpl) + state["lscc"] = make(map[string][]byte) v := newValidationInstance(state) - mockAclProvider := &aclmocks.MockACLProvider{} - cryptoProvider, err := sw.NewDefaultSecurityLevelWithKeystore(sw.NewDummyKeyStore()) - assert.NoError(t, err) - lccc := &lscc.SCC{ - Support: &lscc.SupportImpl{ - GetMSPIDs: mockMSPIDGetter, - }, - SCCProvider: mp, - ACLProvider: mockAclProvider, - GetMSPIDs: mockMSPIDGetter, - PolicyChecker: &mockPolicyChecker{}, - BCCSP: cryptoProvider, - } - stublccc := shimtest.NewMockStub("lscc", lccc) - state["lscc"] = stublccc.State - - ccname := "mycc" - ccver := "upgradewithpoliciesfail" - path := "mychaincode" - - cds, err := constructDeploymentSpec(ccname, path, ccver, [][]byte{[]byte("init"), []byte("a"), []byte("100"), []byte("b"), []byte("200")}, false) + // create lscc record with reject all instantiation policy + ipbytes, err := proto.Marshal(cauthdsl.RejectAllPolicy) if err != nil { - fmt.Printf("%s\n", err) - t.FailNow() + t.Fatalf("Failed to marshal RejectAllPolicy: %s", err) } - cdbytes, err := processSignedCDS(cds, cauthdsl.RejectAllPolicy) - assert.NoError(t, err) - - var b []byte - if b, err = proto.Marshal(cds); err != nil || b == nil { - t.FailNow() + cd := &ccprovider.ChaincodeData{ + InstantiationPolicy: ipbytes, + Version: ccver, } - - // Simulate the lscc invocation whilst skipping the policy validation, - // otherwise we wouldn't be able to deploy a chaincode with a reject all policy - stublccc.MockTransactionStart("barf") - err = stublccc.PutState(ccname, cdbytes) - assert.NoError(t, err) - stublccc.MockTransactionEnd("barf") + cdbytes, err := proto.Marshal(cd) + if err != nil { + t.Fatalf("Failed to marshal ChaincodeData: %s", err) + } + state["lscc"][ccname] = cdbytes ccver = "2" - simresres, err := createCCDataRWset(ccname, ccname, ccver, nil) assert.NoError(t, err) @@ -2018,7 +1642,7 @@ func TestValidateUpgradeWithPoliciesFail(t *testing.T) { bl := &common.Block{Data: &common.BlockData{Data: [][]byte{envBytes}}} err = v.Validate(bl, "lscc", 0, 0, policy) - assert.Error(t, err) + assert.EqualError(t, err, "chaincode instantiation policy violated, error signature set did not satisfy policy") } var id msp.SigningIdentity