github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/cache/depositcache/pending_deposits_test.go (about)

     1  package depositcache
     2  
     3  import (
     4  	"context"
     5  	"math/big"
     6  	"testing"
     7  
     8  	dbpb "github.com/prysmaticlabs/prysm/proto/beacon/db"
     9  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
    10  	"github.com/prysmaticlabs/prysm/shared/bytesutil"
    11  	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
    12  	"google.golang.org/protobuf/proto"
    13  )
    14  
    15  var _ PendingDepositsFetcher = (*DepositCache)(nil)
    16  
    17  func TestInsertPendingDeposit_OK(t *testing.T) {
    18  	dc := DepositCache{}
    19  	dc.InsertPendingDeposit(context.Background(), &ethpb.Deposit{}, 111, 100, [32]byte{})
    20  
    21  	assert.Equal(t, 1, len(dc.pendingDeposits), "Deposit not inserted")
    22  }
    23  
    24  func TestInsertPendingDeposit_ignoresNilDeposit(t *testing.T) {
    25  	dc := DepositCache{}
    26  	dc.InsertPendingDeposit(context.Background(), nil /*deposit*/, 0 /*blockNum*/, 0, [32]byte{})
    27  
    28  	assert.Equal(t, 0, len(dc.pendingDeposits))
    29  }
    30  
    31  func TestRemovePendingDeposit_OK(t *testing.T) {
    32  	db := DepositCache{}
    33  	proof1 := makeDepositProof()
    34  	proof1[0] = bytesutil.PadTo([]byte{'A'}, 32)
    35  	proof2 := makeDepositProof()
    36  	proof2[0] = bytesutil.PadTo([]byte{'A'}, 32)
    37  	data := &ethpb.Deposit_Data{
    38  		PublicKey:             make([]byte, 48),
    39  		WithdrawalCredentials: make([]byte, 32),
    40  		Amount:                0,
    41  		Signature:             make([]byte, 96),
    42  	}
    43  	depToRemove := &ethpb.Deposit{Proof: proof1, Data: data}
    44  	otherDep := &ethpb.Deposit{Proof: proof2, Data: data}
    45  	db.pendingDeposits = []*dbpb.DepositContainer{
    46  		{Deposit: depToRemove, Index: 1},
    47  		{Deposit: otherDep, Index: 5},
    48  	}
    49  	db.RemovePendingDeposit(context.Background(), depToRemove)
    50  
    51  	if len(db.pendingDeposits) != 1 || !proto.Equal(db.pendingDeposits[0].Deposit, otherDep) {
    52  		t.Error("Failed to remove deposit")
    53  	}
    54  }
    55  
    56  func TestRemovePendingDeposit_IgnoresNilDeposit(t *testing.T) {
    57  	dc := DepositCache{}
    58  	dc.pendingDeposits = []*dbpb.DepositContainer{{Deposit: &ethpb.Deposit{}}}
    59  	dc.RemovePendingDeposit(context.Background(), nil /*deposit*/)
    60  	assert.Equal(t, 1, len(dc.pendingDeposits), "Deposit unexpectedly removed")
    61  }
    62  
    63  func TestPendingDeposit_RoundTrip(t *testing.T) {
    64  	dc := DepositCache{}
    65  	proof := makeDepositProof()
    66  	proof[0] = bytesutil.PadTo([]byte{'A'}, 32)
    67  	data := &ethpb.Deposit_Data{
    68  		PublicKey:             make([]byte, 48),
    69  		WithdrawalCredentials: make([]byte, 32),
    70  		Amount:                0,
    71  		Signature:             make([]byte, 96),
    72  	}
    73  	dep := &ethpb.Deposit{Proof: proof, Data: data}
    74  	dc.InsertPendingDeposit(context.Background(), dep, 111, 100, [32]byte{})
    75  	dc.RemovePendingDeposit(context.Background(), dep)
    76  	assert.Equal(t, 0, len(dc.pendingDeposits), "Failed to insert & delete a pending deposit")
    77  }
    78  
    79  func TestPendingDeposits_OK(t *testing.T) {
    80  	dc := DepositCache{}
    81  
    82  	dc.pendingDeposits = []*dbpb.DepositContainer{
    83  		{Eth1BlockHeight: 2, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("A")}}},
    84  		{Eth1BlockHeight: 4, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("B")}}},
    85  		{Eth1BlockHeight: 6, Deposit: &ethpb.Deposit{Proof: [][]byte{[]byte("c")}}},
    86  	}
    87  
    88  	deposits := dc.PendingDeposits(context.Background(), big.NewInt(4))
    89  	expected := []*ethpb.Deposit{
    90  		{Proof: [][]byte{[]byte("A")}},
    91  		{Proof: [][]byte{[]byte("B")}},
    92  	}
    93  	assert.DeepSSZEqual(t, expected, deposits)
    94  
    95  	all := dc.PendingDeposits(context.Background(), nil)
    96  	assert.Equal(t, len(dc.pendingDeposits), len(all), "PendingDeposits(ctx, nil) did not return all deposits")
    97  }
    98  
    99  func TestPrunePendingDeposits_ZeroMerkleIndex(t *testing.T) {
   100  	dc := DepositCache{}
   101  
   102  	dc.pendingDeposits = []*dbpb.DepositContainer{
   103  		{Eth1BlockHeight: 2, Index: 2},
   104  		{Eth1BlockHeight: 4, Index: 4},
   105  		{Eth1BlockHeight: 6, Index: 6},
   106  		{Eth1BlockHeight: 8, Index: 8},
   107  		{Eth1BlockHeight: 10, Index: 10},
   108  		{Eth1BlockHeight: 12, Index: 12},
   109  	}
   110  
   111  	dc.PrunePendingDeposits(context.Background(), 0)
   112  	expected := []*dbpb.DepositContainer{
   113  		{Eth1BlockHeight: 2, Index: 2},
   114  		{Eth1BlockHeight: 4, Index: 4},
   115  		{Eth1BlockHeight: 6, Index: 6},
   116  		{Eth1BlockHeight: 8, Index: 8},
   117  		{Eth1BlockHeight: 10, Index: 10},
   118  		{Eth1BlockHeight: 12, Index: 12},
   119  	}
   120  	assert.DeepEqual(t, expected, dc.pendingDeposits)
   121  }
   122  
   123  func TestPrunePendingDeposits_OK(t *testing.T) {
   124  	dc := DepositCache{}
   125  
   126  	dc.pendingDeposits = []*dbpb.DepositContainer{
   127  		{Eth1BlockHeight: 2, Index: 2},
   128  		{Eth1BlockHeight: 4, Index: 4},
   129  		{Eth1BlockHeight: 6, Index: 6},
   130  		{Eth1BlockHeight: 8, Index: 8},
   131  		{Eth1BlockHeight: 10, Index: 10},
   132  		{Eth1BlockHeight: 12, Index: 12},
   133  	}
   134  
   135  	dc.PrunePendingDeposits(context.Background(), 6)
   136  	expected := []*dbpb.DepositContainer{
   137  		{Eth1BlockHeight: 6, Index: 6},
   138  		{Eth1BlockHeight: 8, Index: 8},
   139  		{Eth1BlockHeight: 10, Index: 10},
   140  		{Eth1BlockHeight: 12, Index: 12},
   141  	}
   142  
   143  	assert.DeepEqual(t, expected, dc.pendingDeposits)
   144  
   145  	dc.pendingDeposits = []*dbpb.DepositContainer{
   146  		{Eth1BlockHeight: 2, Index: 2},
   147  		{Eth1BlockHeight: 4, Index: 4},
   148  		{Eth1BlockHeight: 6, Index: 6},
   149  		{Eth1BlockHeight: 8, Index: 8},
   150  		{Eth1BlockHeight: 10, Index: 10},
   151  		{Eth1BlockHeight: 12, Index: 12},
   152  	}
   153  
   154  	dc.PrunePendingDeposits(context.Background(), 10)
   155  	expected = []*dbpb.DepositContainer{
   156  		{Eth1BlockHeight: 10, Index: 10},
   157  		{Eth1BlockHeight: 12, Index: 12},
   158  	}
   159  
   160  	assert.DeepEqual(t, expected, dc.pendingDeposits)
   161  }