github.com/Unheilbar/quorum@v1.0.0/core/default_psm_test.go (about)

     1  package core
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/ethereum/go-ethereum/common"
     8  	"github.com/ethereum/go-ethereum/core/mps"
     9  	"github.com/ethereum/go-ethereum/core/privatecache"
    10  	"github.com/ethereum/go-ethereum/core/state"
    11  	"github.com/ethereum/go-ethereum/core/types"
    12  	"github.com/ethereum/go-ethereum/core/vm"
    13  	"github.com/ethereum/go-ethereum/params"
    14  	"github.com/ethereum/go-ethereum/private"
    15  	"github.com/ethereum/go-ethereum/rpc"
    16  	"github.com/golang/mock/gomock"
    17  	"github.com/stretchr/testify/assert"
    18  )
    19  
    20  // Tests DefaultState, StatePSI, CommitAndWrite
    21  func TestLegacyPrivateStateCreated(t *testing.T) {
    22  	mockCtrl := gomock.NewController(t)
    23  	defer mockCtrl.Finish()
    24  
    25  	mockptm := private.NewMockPrivateTransactionManager(mockCtrl)
    26  
    27  	saved := private.P
    28  	defer func() {
    29  		private.P = saved
    30  	}()
    31  	private.P = mockptm
    32  
    33  	mockptm.EXPECT().Receive(gomock.Not(common.EncryptedPayloadHash{})).Return("", []string{"psi1", "psi2"}, common.FromHex(testCode), nil, nil).AnyTimes()
    34  
    35  	blocks, blockmap, blockchain := buildTestChain(2, params.QuorumTestChainConfig)
    36  
    37  	for _, block := range blocks {
    38  		parent := blockmap[block.ParentHash()]
    39  		statedb, _ := state.New(parent.Root(), blockchain.StateCache(), nil)
    40  		privateStateRepo, _ := blockchain.PrivateStateManager().StateRepository(parent.Root())
    41  
    42  		_, privateReceipts, _, _, _ := blockchain.Processor().Process(block, statedb, privateStateRepo, vm.Config{})
    43  
    44  		for _, privateReceipt := range privateReceipts {
    45  			expectedContractAddress := privateReceipt.ContractAddress
    46  
    47  			assert.False(t, privateStateRepo.IsMPS())
    48  			privateState, _ := privateStateRepo.DefaultState()
    49  			assert.True(t, privateState.Exist(expectedContractAddress))
    50  			assert.NotEqual(t, privateState.GetCodeSize(expectedContractAddress), 0)
    51  			defaultPrivateState, _ := privateStateRepo.StatePSI(types.DefaultPrivateStateIdentifier)
    52  			assert.True(t, defaultPrivateState.Exist(expectedContractAddress))
    53  			assert.NotEqual(t, defaultPrivateState.GetCodeSize(expectedContractAddress), 0)
    54  			_, err := privateStateRepo.StatePSI(types.PrivateStateIdentifier("empty"))
    55  			assert.Error(t, err, "only the 'private' psi is supported by the default private state manager")
    56  		}
    57  		//CommitAndWrite to db
    58  		privateStateRepo.CommitAndWrite(false, block)
    59  
    60  		for _, privateReceipt := range privateReceipts {
    61  			expectedContractAddress := privateReceipt.ContractAddress
    62  			latestBlockRoot := block.Root()
    63  			//contract exists on default state
    64  			_, privDb, _ := blockchain.StateAtPSI(latestBlockRoot, types.DefaultPrivateStateIdentifier)
    65  			assert.True(t, privDb.Exist(expectedContractAddress))
    66  			assert.NotEqual(t, privDb.GetCodeSize(expectedContractAddress), 0)
    67  			//legacy psm doesnt have concept of emptystate
    68  			_, _, err := blockchain.StateAtPSI(latestBlockRoot, types.ToPrivateStateIdentifier("empty"))
    69  			assert.Error(t, err, "only the 'private' psi is supported by the default private state manager")
    70  			//legacy psm doesnt support other private states
    71  			_, _, err = blockchain.StateAtPSI(latestBlockRoot, types.ToPrivateStateIdentifier("other"))
    72  			assert.Error(t, err, "only the 'private' psi is supported by the default private state manager")
    73  		}
    74  	}
    75  }
    76  
    77  func TestDefaultResolver(t *testing.T) {
    78  	mockCtrl := gomock.NewController(t)
    79  	defer mockCtrl.Finish()
    80  
    81  	mockptm := private.NewMockPrivateTransactionManager(mockCtrl)
    82  
    83  	saved := private.P
    84  	defer func() {
    85  		private.P = saved
    86  	}()
    87  	private.P = mockptm
    88  
    89  	mockptm.EXPECT().Receive(gomock.Not(common.EncryptedPayloadHash{})).Return("", []string{}, common.FromHex(testCode), nil, nil).AnyTimes()
    90  	mockptm.EXPECT().Receive(common.EncryptedPayloadHash{}).Return("", []string{}, common.EncryptedPayloadHash{}.Bytes(), nil, nil).AnyTimes()
    91  
    92  	_, _, blockchain := buildTestChain(1, params.QuorumTestChainConfig)
    93  
    94  	privateCacheProvider := privatecache.NewPrivateCacheProvider(blockchain.db, nil, nil, false)
    95  
    96  	mpsm := newDefaultPrivateStateManager(blockchain.db, privateCacheProvider)
    97  
    98  	psm1, _ := mpsm.ResolveForManagedParty("TEST")
    99  	assert.Equal(t, psm1, mps.DefaultPrivateStateMetadata)
   100  
   101  	ctx := rpc.WithPrivateStateIdentifier(context.Background(), types.DefaultPrivateStateIdentifier)
   102  	psm1, _ = mpsm.ResolveForUserContext(ctx)
   103  	assert.Equal(t, psm1, &mps.PrivateStateMetadata{ID: "private", Type: mps.Resident})
   104  	psm1, _ = mpsm.ResolveForUserContext(context.Background())
   105  	assert.Equal(t, psm1, &mps.PrivateStateMetadata{ID: "private", Type: mps.Resident})
   106  
   107  	assert.Equal(t, mpsm.PSIs(), []types.PrivateStateIdentifier{types.DefaultPrivateStateIdentifier})
   108  }