github.com/baptiste-b-pegasys/quorum/v22@v22.4.2/private/engine/qlightptm/caching_proxy_test.go (about)

     1  package qlightptm
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/ethereum/go-ethereum/common"
     8  	"github.com/ethereum/go-ethereum/private/engine"
     9  	"github.com/ethereum/go-ethereum/rpc"
    10  	"github.com/golang/mock/gomock"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestCachingProxy_ReceiveWithDataAvailableInCache(t *testing.T) {
    15  	assert := assert.New(t)
    16  
    17  	cpTM := New()
    18  	cpTM.Cache(&CachablePrivateTransactionData{
    19  		Hash: common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")),
    20  		QuorumPrivateTxData: engine.QuorumPayloadExtra{
    21  			Payload: fmt.Sprintf("0x%x", []byte("payload")),
    22  			ExtraMetaData: &engine.ExtraMetadata{
    23  				ACHashes:            nil,
    24  				ACMerkleRoot:        common.Hash{},
    25  				PrivacyFlag:         0,
    26  				ManagedParties:      nil,
    27  				Sender:              "sender1",
    28  				MandatoryRecipients: nil,
    29  			},
    30  			IsSender: false,
    31  		},
    32  	})
    33  
    34  	cpTM.Cache(&CachablePrivateTransactionData{
    35  		Hash: common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash2")),
    36  		QuorumPrivateTxData: engine.QuorumPayloadExtra{
    37  			Payload: fmt.Sprintf("0x%x", []byte("payload")),
    38  			ExtraMetaData: &engine.ExtraMetadata{
    39  				ACHashes:            nil,
    40  				ACMerkleRoot:        common.Hash{},
    41  				PrivacyFlag:         0,
    42  				ManagedParties:      nil,
    43  				Sender:              "sender2",
    44  				MandatoryRecipients: nil,
    45  			},
    46  			IsSender: true,
    47  		},
    48  	})
    49  
    50  	sender, _, payload, extraMetaData, err := cpTM.Receive(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
    51  
    52  	assert.Nil(err)
    53  	assert.Equal("sender1", sender)
    54  	assert.Equal([]byte("payload"), payload)
    55  	assert.NotNil(extraMetaData)
    56  
    57  	isSender, err := cpTM.IsSender(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
    58  
    59  	assert.Nil(err)
    60  	assert.False(isSender)
    61  
    62  	isSender, err = cpTM.IsSender(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash2")))
    63  
    64  	assert.Nil(err)
    65  	assert.True(isSender)
    66  }
    67  
    68  func TestCachingProxy_ReceiveWithDataNotAvailableInCache(t *testing.T) {
    69  	assert := assert.New(t)
    70  
    71  	cpTM := New()
    72  	cpTM.CheckAndAddEmptyToCache(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
    73  
    74  	_, _, payload, extraMetaData, err := cpTM.Receive(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
    75  
    76  	assert.Nil(err)
    77  	assert.Nil(payload)
    78  	assert.Nil(extraMetaData)
    79  
    80  	isSender, err := cpTM.IsSender(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
    81  
    82  	assert.Nil(err)
    83  	assert.False(isSender)
    84  }
    85  
    86  func TestCachingProxy_ReceiveWithDataMissingFromCacheAvailableRemotely(t *testing.T) {
    87  	assert := assert.New(t)
    88  	ctrl := gomock.NewController(t)
    89  	defer ctrl.Finish()
    90  
    91  	cpTM := New()
    92  	mockRPCClient := NewMockRPCClientCaller(ctrl)
    93  	mockRPCClient.EXPECT().Call(gomock.Any(), gomock.Eq("eth_getQuorumPayloadExtra"),
    94  		gomock.Eq(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")).Hex())).DoAndReturn(
    95  		func(result interface{}, method string, args ...interface{}) error {
    96  			res, _ := result.(*engine.QuorumPayloadExtra)
    97  			res.IsSender = false
    98  			res.ExtraMetaData = &engine.ExtraMetadata{
    99  				ACHashes:            nil,
   100  				ACMerkleRoot:        common.Hash{},
   101  				PrivacyFlag:         0,
   102  				ManagedParties:      nil,
   103  				Sender:              "sender1",
   104  				MandatoryRecipients: nil,
   105  			}
   106  			res.Payload = fmt.Sprintf("0x%x", []byte("payload"))
   107  			return nil
   108  		})
   109  
   110  	cpTM.SetRPCClientCaller(mockRPCClient)
   111  
   112  	sender, _, payload, extraMetaData, err := cpTM.Receive(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
   113  
   114  	assert.Nil(err)
   115  	assert.Equal("sender1", sender)
   116  	assert.Equal([]byte("payload"), payload)
   117  	assert.NotNil(extraMetaData)
   118  }
   119  
   120  func TestCachingProxy_ReceiveWithDataMissingFromCacheUnavailableRemotely(t *testing.T) {
   121  	assert := assert.New(t)
   122  	ctrl := gomock.NewController(t)
   123  	defer ctrl.Finish()
   124  
   125  	cpTM := New()
   126  	mockRPCClient := NewMockRPCClientCaller(ctrl)
   127  	mockRPCClient.EXPECT().Call(gomock.Any(), gomock.Eq("eth_getQuorumPayloadExtra"),
   128  		gomock.Eq(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")).Hex())).Return(nil)
   129  
   130  	cpTM.SetRPCClientCaller(mockRPCClient)
   131  
   132  	sender, _, payload, extraMetaData, err := cpTM.Receive(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
   133  
   134  	assert.Nil(err)
   135  	assert.Equal("", sender)
   136  	assert.Nil(payload)
   137  	assert.Nil(extraMetaData)
   138  }
   139  
   140  func TestCachingProxy_ReceiveWithDataMissingFromCacheAndRPCError(t *testing.T) {
   141  	assert := assert.New(t)
   142  	ctrl := gomock.NewController(t)
   143  	defer ctrl.Finish()
   144  
   145  	cpTM := New()
   146  	mockRPCClient := NewMockRPCClientCaller(ctrl)
   147  	mockRPCClient.EXPECT().Call(gomock.Any(), gomock.Eq("eth_getQuorumPayloadExtra"),
   148  		gomock.Eq(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")).Hex())).Return(fmt.Errorf("RPC Error"))
   149  
   150  	cpTM.SetRPCClientCaller(mockRPCClient)
   151  
   152  	_, _, _, _, err := cpTM.Receive(common.BytesToEncryptedPayloadHash([]byte("encryptedpayloadhash1")))
   153  
   154  	assert.EqualError(err, "RPC Error")
   155  }
   156  
   157  func TestCachingProxy_DecryptPayloadSuccess(t *testing.T) {
   158  	assert := assert.New(t)
   159  	ctrl := gomock.NewController(t)
   160  	defer ctrl.Finish()
   161  
   162  	cpTM := New()
   163  	mockRPCClient := NewMockRPCClientCaller(ctrl)
   164  	mockRPCClient.EXPECT().Call(gomock.Any(), gomock.Eq("eth_decryptQuorumPayload"),
   165  		gomock.Any()).DoAndReturn(
   166  		func(result interface{}, method string, args ...interface{}) error {
   167  			res, _ := result.(*engine.QuorumPayloadExtra)
   168  			res.IsSender = false
   169  			res.ExtraMetaData = &engine.ExtraMetadata{
   170  				ACHashes:            nil,
   171  				ACMerkleRoot:        common.Hash{},
   172  				PrivacyFlag:         0,
   173  				ManagedParties:      nil,
   174  				Sender:              "sender1",
   175  				MandatoryRecipients: nil,
   176  			}
   177  			res.Payload = fmt.Sprintf("0x%x", []byte("payload"))
   178  			return nil
   179  		})
   180  
   181  	cpTM.SetRPCClientCaller(mockRPCClient)
   182  
   183  	payload, extraMetaData, err := cpTM.DecryptPayload(common.DecryptRequest{
   184  		SenderKey:       []byte("sender1"),
   185  		CipherText:      []byte("ciphertext"),
   186  		CipherTextNonce: []byte("nonce"),
   187  		RecipientBoxes:  nil,
   188  		RecipientNonce:  []byte("nonce"),
   189  		RecipientKeys:   nil,
   190  	})
   191  
   192  	assert.Nil(err)
   193  	assert.Equal("sender1", extraMetaData.Sender)
   194  	assert.Equal([]byte("payload"), payload)
   195  	assert.NotNil(extraMetaData)
   196  }
   197  
   198  func TestCachingProxy_DecryptPayloadErrorInCall(t *testing.T) {
   199  	assert := assert.New(t)
   200  	ctrl := gomock.NewController(t)
   201  	defer ctrl.Finish()
   202  
   203  	cpTM := New()
   204  	mockRPCClient := NewMockRPCClientCaller(ctrl)
   205  	mockRPCClient.EXPECT().Call(gomock.Any(), gomock.Eq("eth_decryptQuorumPayload"),
   206  		gomock.Any()).Return(fmt.Errorf("RPC Error"))
   207  
   208  	cpTM.SetRPCClientCaller(mockRPCClient)
   209  
   210  	_, _, err := cpTM.DecryptPayload(common.DecryptRequest{
   211  		SenderKey:       []byte("sender1"),
   212  		CipherText:      []byte("ciphertext"),
   213  		CipherTextNonce: []byte("nonce"),
   214  		RecipientBoxes:  nil,
   215  		RecipientNonce:  []byte("nonce"),
   216  		RecipientKeys:   nil,
   217  	})
   218  
   219  	assert.EqualError(err, "RPC Error")
   220  }
   221  
   222  type HasRPCClient interface {
   223  	SetRPCClient(client *rpc.Client)
   224  }
   225  
   226  func TestCachingProxy_HasRPCClient(t *testing.T) {
   227  	assert := assert.New(t)
   228  	var cpTM interface{} = New()
   229  
   230  	_, ok := cpTM.(HasRPCClient)
   231  	assert.True(ok)
   232  }