github.com/baptiste-b-pegasys/quorum/v22@v22.4.2/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  		}
    58  		//CommitAndWrite to db
    59  		privateStateRepo.CommitAndWrite(false, block)
    60  
    61  		for _, privateReceipt := range privateReceipts {
    62  			expectedContractAddress := privateReceipt.ContractAddress
    63  			latestBlockRoot := block.Root()
    64  			//contract exists on default state
    65  			_, privDb, _ := blockchain.StateAtPSI(latestBlockRoot, types.DefaultPrivateStateIdentifier)
    66  			assert.True(t, privDb.Exist(expectedContractAddress))
    67  			assert.NotEqual(t, privDb.GetCodeSize(expectedContractAddress), 0)
    68  			//legacy psm doesnt have concept of emptystate
    69  			_, _, err := blockchain.StateAtPSI(latestBlockRoot, types.ToPrivateStateIdentifier("empty"))
    70  			assert.Error(t, err, "only the 'private' psi is supported by the default private state manager")
    71  			//legacy psm doesnt support other private states
    72  			_, _, err = blockchain.StateAtPSI(latestBlockRoot, types.ToPrivateStateIdentifier("other"))
    73  			assert.Error(t, err, "only the 'private' psi is supported by the default private state manager")
    74  		}
    75  	}
    76  }
    77  
    78  func TestDefaultResolver(t *testing.T) {
    79  	mockCtrl := gomock.NewController(t)
    80  	defer mockCtrl.Finish()
    81  
    82  	mockptm := private.NewMockPrivateTransactionManager(mockCtrl)
    83  
    84  	saved := private.P
    85  	defer func() {
    86  		private.P = saved
    87  	}()
    88  	private.P = mockptm
    89  
    90  	mockptm.EXPECT().Receive(gomock.Not(common.EncryptedPayloadHash{})).Return("", []string{}, common.FromHex(testCode), nil, nil).AnyTimes()
    91  	mockptm.EXPECT().Receive(common.EncryptedPayloadHash{}).Return("", []string{}, common.EncryptedPayloadHash{}.Bytes(), nil, nil).AnyTimes()
    92  
    93  	_, _, blockchain := buildTestChain(1, params.QuorumTestChainConfig)
    94  
    95  	privateCacheProvider := privatecache.NewPrivateCacheProvider(blockchain.db, nil, nil, false)
    96  
    97  	mpsm := newDefaultPrivateStateManager(blockchain.db, privateCacheProvider)
    98  
    99  	psm1, _ := mpsm.ResolveForManagedParty("TEST")
   100  	assert.Equal(t, psm1, mps.DefaultPrivateStateMetadata)
   101  
   102  	ctx := rpc.WithPrivateStateIdentifier(context.Background(), types.DefaultPrivateStateIdentifier)
   103  	psm1, _ = mpsm.ResolveForUserContext(ctx)
   104  	assert.Equal(t, psm1, &mps.PrivateStateMetadata{ID: "private", Type: mps.Resident})
   105  	psm1, _ = mpsm.ResolveForUserContext(context.Background())
   106  	assert.Equal(t, psm1, &mps.PrivateStateMetadata{ID: "private", Type: mps.Resident})
   107  
   108  	assert.Equal(t, mpsm.PSIs(), []types.PrivateStateIdentifier{types.DefaultPrivateStateIdentifier})
   109  }