github.com/dim4egster/coreth@v0.10.2/plugin/evm/message/leafs_request_test.go (about)

     1  // (c) 2021-2022, Ava Labs, Inc. All rights reserved.
     2  // See the file LICENSE for licensing terms.
     3  
     4  package message
     5  
     6  import (
     7  	"bytes"
     8  	"context"
     9  	"encoding/base64"
    10  	"math/rand"
    11  	"testing"
    12  
    13  	"github.com/dim4egster/qmallgo/ids"
    14  
    15  	"github.com/ethereum/go-ethereum/common"
    16  	"github.com/stretchr/testify/assert"
    17  )
    18  
    19  // TestMarshalLeafsRequest asserts that the structure or serialization logic hasn't changed, primarily to
    20  // ensure compatibility with the network.
    21  func TestMarshalLeafsRequest(t *testing.T) {
    22  	// generate some random code data
    23  	// set random seed for deterministic random
    24  	rand.Seed(1)
    25  
    26  	startBytes := make([]byte, common.HashLength)
    27  	endBytes := make([]byte, common.HashLength)
    28  
    29  	_, err := rand.Read(startBytes)
    30  	assert.NoError(t, err)
    31  
    32  	_, err = rand.Read(endBytes)
    33  	assert.NoError(t, err)
    34  
    35  	leafsRequest := LeafsRequest{
    36  		Root:     common.BytesToHash([]byte("im ROOTing for ya")),
    37  		Start:    startBytes,
    38  		End:      endBytes,
    39  		Limit:    1024,
    40  		NodeType: StateTrieNode,
    41  	}
    42  
    43  	base64LeafsRequest := "AAAAAAAAAAAAAAAAAAAAAABpbSBST09UaW5nIGZvciB5YQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIFL9/AchgmVPFj9fD5piHXKVZsdNEAN8TXu7BAfR4sZJAAAAIIGFWthoHQ2G0ekeABZ5OctmlNLEIqzSCKAHKTlIf2mZBAAB"
    44  
    45  	leafsRequestBytes, err := Codec.Marshal(Version, leafsRequest)
    46  	assert.NoError(t, err)
    47  	assert.Equal(t, base64LeafsRequest, base64.StdEncoding.EncodeToString(leafsRequestBytes))
    48  
    49  	var l LeafsRequest
    50  	_, err = Codec.Unmarshal(leafsRequestBytes, &l)
    51  	assert.NoError(t, err)
    52  	assert.Equal(t, leafsRequest.Root, l.Root)
    53  	assert.Equal(t, leafsRequest.Start, l.Start)
    54  	assert.Equal(t, leafsRequest.End, l.End)
    55  	assert.Equal(t, leafsRequest.Limit, l.Limit)
    56  	assert.Equal(t, leafsRequest.NodeType, l.NodeType)
    57  }
    58  
    59  // TestMarshalLeafsResponse asserts that the structure or serialization logic hasn't changed, primarily to
    60  // ensure compatibility with the network.
    61  func TestMarshalLeafsResponse(t *testing.T) {
    62  	// generate some random code data
    63  	// set random seed for deterministic random
    64  	rand.Seed(1)
    65  
    66  	keysBytes := make([][]byte, 16)
    67  	valsBytes := make([][]byte, 16)
    68  	for i := range keysBytes {
    69  		keysBytes[i] = make([]byte, common.HashLength)
    70  		valsBytes[i] = make([]byte, rand.Intn(8)+8) // min 8 bytes, max 16 bytes
    71  
    72  		_, err := rand.Read(keysBytes[i])
    73  		assert.NoError(t, err)
    74  		_, err = rand.Read(valsBytes[i])
    75  		assert.NoError(t, err)
    76  	}
    77  
    78  	nextKey := make([]byte, common.HashLength)
    79  	_, err := rand.Read(nextKey)
    80  	assert.NoError(t, err)
    81  
    82  	proofVals := make([][]byte, 4)
    83  	for i := range proofVals {
    84  		proofVals[i] = make([]byte, rand.Intn(8)+8) // min 8 bytes, max 16 bytes
    85  
    86  		_, err = rand.Read(proofVals[i])
    87  		assert.NoError(t, err)
    88  	}
    89  
    90  	leafsResponse := LeafsResponse{
    91  		Keys:      keysBytes,
    92  		Vals:      valsBytes,
    93  		More:      true,
    94  		ProofVals: proofVals,
    95  	}
    96  
    97  	base64LeafsResponse := "AAAAAAAQAAAAIE8WP18PmmIdcpVmx00QA3xNe7sEB9HixkmBhVrYaB0NAAAAIGagByk5SH9pmeudGKRHhARdh/PGfPInRumVr1olNnlRAAAAIK2zfFghtmgLTnyLdjobHUnUlVyEhiFjJSU/7HON16niAAAAIIYVu9oIMfUFmHWSHmaKW98sf8SERZLSVyvNBmjS1sUvAAAAIHHb2Wiw9xcu2FeUuzWLDDtSXaF4b5//CUJ52xlE69ehAAAAIPhMiSs77qX090OR9EXRWv1ClAQDdPaSS5jL+HE/jZYtAAAAIMr8yuOmvI+effHZKTM/+ZOTO+pvWzr23gN0NmxHGeQ6AAAAIBZZpE856x5YScYHfbtXIvVxeiiaJm+XZHmBmY6+qJwLAAAAIHOq53hmZ/fpNs1PJKv334ZrqlYDg2etYUXeHuj0qLCZAAAAIHiN5WOvpGfUnexqQOmh0AfwM8KCMGG90Oqln45NpkMBAAAAIKAQ13yW6oCnpmX2BvamO389/SVnwYl55NYPJmhtm/L7AAAAIAfuKbpk+Eq0PKDG5rkcH9O+iZBDQXnTr0SRo2kBLbktAAAAILsXyQKL6ZFOt2ScbJNHgAl50YMDVvKlTD3qsqS0R11jAAAAIOqxOTXzHYRIRRfpJK73iuFRwAdVklg2twdYhWUMMOwpAAAAIHnqPf5BNqv3UrO4Jx0D6USzyds2a3UEX479adIq5UEZAAAAIDLWEMqsbjP+qjJjo5lDcCS6nJsUZ4onTwGpEK4pX277AAAAEAAAAAmG0ekeABZ5OcsAAAAMuqL/bNRxxIPxX7kLAAAACov5IRGcFg8HAkQAAAAIUFTi0INr+EwAAAAOnQ97usvgJVqlt9RL7EAAAAAJfI0BkZLCQiTiAAAACxsGfYm8fwHx9XOYAAAADUs3OXARXoLtb0ElyPoAAAAKPr34iDoK2L6cOQAAAAoFIg0LKWiLc0uOAAAACCbJAf81TN4WAAAADBhPw50XNP9XFkKJUwAAAAuvvo+1aYfHf1gYUgAAAAqjcDk0v1CijaECAAAADkfLVT12lCZ670686kBrAAAADf5fWr9EzN4mO1YGYz4AAAAEAAAADlcyXwVWMEo+Pq4Uwo0MAAAADeo50qHks46vP0TGxu8AAAAOg2Ly9WQIVMFd/KyqiiwAAAAL7M5aOpS00zilFD4="
    98  
    99  	leafsResponseBytes, err := Codec.Marshal(Version, leafsResponse)
   100  	assert.NoError(t, err)
   101  	assert.Equal(t, base64LeafsResponse, base64.StdEncoding.EncodeToString(leafsResponseBytes))
   102  
   103  	var l LeafsResponse
   104  	_, err = Codec.Unmarshal(leafsResponseBytes, &l)
   105  	assert.NoError(t, err)
   106  	assert.Equal(t, leafsResponse.Keys, l.Keys)
   107  	assert.Equal(t, leafsResponse.Vals, l.Vals)
   108  	assert.False(t, l.More) // make sure it is not serialized
   109  	assert.Equal(t, leafsResponse.ProofVals, l.ProofVals)
   110  }
   111  
   112  func TestLeafsRequestValidation(t *testing.T) {
   113  	mockRequestHandler := &mockHandler{}
   114  
   115  	tests := map[string]struct {
   116  		request        LeafsRequest
   117  		assertResponse func(t *testing.T)
   118  	}{
   119  		"node type StateTrieNode": {
   120  			request: LeafsRequest{
   121  				Root:     common.BytesToHash([]byte("some hash goes here")),
   122  				Start:    bytes.Repeat([]byte{0x00}, common.HashLength),
   123  				End:      bytes.Repeat([]byte{0xff}, common.HashLength),
   124  				Limit:    10,
   125  				NodeType: StateTrieNode,
   126  			},
   127  			assertResponse: func(t *testing.T) {
   128  				assert.True(t, mockRequestHandler.handleStateTrieCalled)
   129  				assert.False(t, mockRequestHandler.handleAtomicTrieCalled)
   130  				assert.False(t, mockRequestHandler.handleBlockRequestCalled)
   131  				assert.False(t, mockRequestHandler.handleCodeRequestCalled)
   132  			},
   133  		},
   134  		"node type AtomicTrieNode": {
   135  			request: LeafsRequest{
   136  				Root:     common.BytesToHash([]byte("some hash goes here")),
   137  				Start:    bytes.Repeat([]byte{0x00}, common.HashLength),
   138  				End:      bytes.Repeat([]byte{0xff}, common.HashLength),
   139  				Limit:    10,
   140  				NodeType: AtomicTrieNode,
   141  			},
   142  			assertResponse: func(t *testing.T) {
   143  				assert.False(t, mockRequestHandler.handleStateTrieCalled)
   144  				assert.True(t, mockRequestHandler.handleAtomicTrieCalled)
   145  				assert.False(t, mockRequestHandler.handleBlockRequestCalled)
   146  				assert.False(t, mockRequestHandler.handleCodeRequestCalled)
   147  			},
   148  		},
   149  		"unknown node type": {
   150  			request: LeafsRequest{
   151  				Root:     common.BytesToHash([]byte("some hash goes here")),
   152  				Start:    bytes.Repeat([]byte{0x00}, common.HashLength),
   153  				End:      bytes.Repeat([]byte{0xff}, common.HashLength),
   154  				Limit:    10,
   155  				NodeType: NodeType(11),
   156  			},
   157  			assertResponse: func(t *testing.T) {
   158  				assert.False(t, mockRequestHandler.handleStateTrieCalled)
   159  				assert.False(t, mockRequestHandler.handleAtomicTrieCalled)
   160  				assert.False(t, mockRequestHandler.handleBlockRequestCalled)
   161  				assert.False(t, mockRequestHandler.handleCodeRequestCalled)
   162  			},
   163  		},
   164  	}
   165  	for name, test := range tests {
   166  		t.Run(name, func(t *testing.T) {
   167  			_, _ = test.request.Handle(context.Background(), ids.GenerateTestNodeID(), 1, mockRequestHandler)
   168  			test.assertResponse(t)
   169  			mockRequestHandler.reset()
   170  		})
   171  	}
   172  }
   173  
   174  var _ RequestHandler = &mockHandler{}
   175  
   176  type mockHandler struct {
   177  	handleStateTrieCalled,
   178  	handleAtomicTrieCalled,
   179  	handleBlockRequestCalled,
   180  	handleCodeRequestCalled bool
   181  }
   182  
   183  func (m *mockHandler) HandleStateTrieLeafsRequest(context.Context, ids.NodeID, uint32, LeafsRequest) ([]byte, error) {
   184  	m.handleStateTrieCalled = true
   185  	return nil, nil
   186  }
   187  
   188  func (m *mockHandler) HandleAtomicTrieLeafsRequest(context.Context, ids.NodeID, uint32, LeafsRequest) ([]byte, error) {
   189  	m.handleAtomicTrieCalled = true
   190  	return nil, nil
   191  }
   192  
   193  func (m *mockHandler) HandleBlockRequest(context.Context, ids.NodeID, uint32, BlockRequest) ([]byte, error) {
   194  	m.handleBlockRequestCalled = true
   195  	return nil, nil
   196  }
   197  
   198  func (m *mockHandler) HandleCodeRequest(context.Context, ids.NodeID, uint32, CodeRequest) ([]byte, error) {
   199  	m.handleCodeRequestCalled = true
   200  	return nil, nil
   201  }
   202  
   203  func (m *mockHandler) reset() {
   204  	m.handleStateTrieCalled = false
   205  	m.handleAtomicTrieCalled = false
   206  	m.handleBlockRequestCalled = false
   207  	m.handleCodeRequestCalled = false
   208  }