github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/rpc/eth/v1/beacon/state_test.go (about)

     1  package beacon
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  	"time"
     7  
     8  	chainMock "github.com/prysmaticlabs/prysm/beacon-chain/blockchain/testing"
     9  	"github.com/prysmaticlabs/prysm/beacon-chain/rpc/testutil"
    10  	pb "github.com/prysmaticlabs/prysm/proto/beacon/p2p/v1"
    11  	ethpb "github.com/prysmaticlabs/prysm/proto/eth/v1"
    12  	eth "github.com/prysmaticlabs/prysm/proto/eth/v1alpha1"
    13  	"github.com/prysmaticlabs/prysm/shared/bytesutil"
    14  	"github.com/prysmaticlabs/prysm/shared/params"
    15  	sharedtestutil "github.com/prysmaticlabs/prysm/shared/testutil"
    16  	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
    17  	"github.com/prysmaticlabs/prysm/shared/testutil/require"
    18  	"google.golang.org/protobuf/types/known/emptypb"
    19  )
    20  
    21  func TestGetGenesis(t *testing.T) {
    22  	ctx := context.Background()
    23  	params.SetupTestConfigCleanup(t)
    24  	config := params.BeaconConfig()
    25  	config.GenesisForkVersion = []byte("genesis")
    26  	params.OverrideBeaconConfig(config)
    27  	genesis := time.Date(2021, 1, 1, 0, 0, 0, 0, time.UTC)
    28  	validatorsRoot := [32]byte{1, 2, 3, 4, 5, 6}
    29  
    30  	t.Run("OK", func(t *testing.T) {
    31  		chainService := &chainMock.ChainService{
    32  			Genesis:        genesis,
    33  			ValidatorsRoot: validatorsRoot,
    34  		}
    35  		s := Server{
    36  			GenesisTimeFetcher: chainService,
    37  			ChainInfoFetcher:   chainService,
    38  		}
    39  		resp, err := s.GetGenesis(ctx, &emptypb.Empty{})
    40  		require.NoError(t, err)
    41  		assert.Equal(t, genesis.Unix(), resp.Data.GenesisTime.Seconds)
    42  		assert.Equal(t, int32(0), resp.Data.GenesisTime.Nanos)
    43  		assert.DeepEqual(t, validatorsRoot[:], resp.Data.GenesisValidatorsRoot)
    44  		assert.DeepEqual(t, []byte("genesis"), resp.Data.GenesisForkVersion)
    45  	})
    46  
    47  	t.Run("No genesis time", func(t *testing.T) {
    48  		chainService := &chainMock.ChainService{
    49  			Genesis:        time.Time{},
    50  			ValidatorsRoot: validatorsRoot,
    51  		}
    52  		s := Server{
    53  			GenesisTimeFetcher: chainService,
    54  			ChainInfoFetcher:   chainService,
    55  		}
    56  		_, err := s.GetGenesis(ctx, &emptypb.Empty{})
    57  		assert.ErrorContains(t, "Chain genesis info is not yet known", err)
    58  	})
    59  
    60  	t.Run("No genesis validator root", func(t *testing.T) {
    61  		chainService := &chainMock.ChainService{
    62  			Genesis:        genesis,
    63  			ValidatorsRoot: [32]byte{},
    64  		}
    65  		s := Server{
    66  			GenesisTimeFetcher: chainService,
    67  			ChainInfoFetcher:   chainService,
    68  		}
    69  		_, err := s.GetGenesis(ctx, &emptypb.Empty{})
    70  		assert.ErrorContains(t, "Chain genesis info is not yet known", err)
    71  	})
    72  }
    73  
    74  func TestGetStateRoot(t *testing.T) {
    75  	ctx := context.Background()
    76  	fakeState, err := sharedtestutil.NewBeaconState()
    77  	require.NoError(t, err)
    78  	stateRoot, err := fakeState.HashTreeRoot(ctx)
    79  	require.NoError(t, err)
    80  	server := &Server{
    81  		StateFetcher: &testutil.MockFetcher{
    82  			BeaconStateRoot: stateRoot[:],
    83  		},
    84  	}
    85  
    86  	resp, err := server.GetStateRoot(context.Background(), &ethpb.StateRequest{
    87  		StateId: make([]byte, 0),
    88  	})
    89  	require.NoError(t, err)
    90  	assert.NotNil(t, resp)
    91  	assert.DeepEqual(t, stateRoot[:], resp.Data.Root)
    92  }
    93  
    94  func TestGetStateFork(t *testing.T) {
    95  	fillFork := func(state *pb.BeaconState) error {
    96  		state.Fork = &pb.Fork{
    97  			PreviousVersion: []byte("prev"),
    98  			CurrentVersion:  []byte("curr"),
    99  			Epoch:           123,
   100  		}
   101  		return nil
   102  	}
   103  	fakeState, err := sharedtestutil.NewBeaconState(fillFork)
   104  	require.NoError(t, err)
   105  	server := &Server{
   106  		StateFetcher: &testutil.MockFetcher{
   107  			BeaconState: fakeState,
   108  		},
   109  	}
   110  
   111  	resp, err := server.GetStateFork(context.Background(), &ethpb.StateRequest{
   112  		StateId: make([]byte, 0),
   113  	})
   114  	require.NoError(t, err)
   115  	assert.NotNil(t, resp)
   116  	expectedFork := fakeState.Fork()
   117  	assert.Equal(t, expectedFork.Epoch, resp.Data.Epoch)
   118  	assert.DeepEqual(t, expectedFork.CurrentVersion, resp.Data.CurrentVersion)
   119  	assert.DeepEqual(t, expectedFork.PreviousVersion, resp.Data.PreviousVersion)
   120  }
   121  
   122  func TestGetFinalityCheckpoints(t *testing.T) {
   123  	fillCheckpoints := func(state *pb.BeaconState) error {
   124  		state.PreviousJustifiedCheckpoint = &eth.Checkpoint{
   125  			Root:  bytesutil.PadTo([]byte("previous"), 32),
   126  			Epoch: 113,
   127  		}
   128  		state.CurrentJustifiedCheckpoint = &eth.Checkpoint{
   129  			Root:  bytesutil.PadTo([]byte("current"), 32),
   130  			Epoch: 123,
   131  		}
   132  		state.FinalizedCheckpoint = &eth.Checkpoint{
   133  			Root:  bytesutil.PadTo([]byte("finalized"), 32),
   134  			Epoch: 103,
   135  		}
   136  		return nil
   137  	}
   138  	fakeState, err := sharedtestutil.NewBeaconState(fillCheckpoints)
   139  	require.NoError(t, err)
   140  	server := &Server{
   141  		StateFetcher: &testutil.MockFetcher{
   142  			BeaconState: fakeState,
   143  		},
   144  	}
   145  
   146  	resp, err := server.GetFinalityCheckpoints(context.Background(), &ethpb.StateRequest{
   147  		StateId: make([]byte, 0),
   148  	})
   149  	require.NoError(t, err)
   150  	assert.NotNil(t, resp)
   151  	assert.Equal(t, fakeState.FinalizedCheckpoint().Epoch, resp.Data.Finalized.Epoch)
   152  	assert.DeepEqual(t, fakeState.FinalizedCheckpoint().Root, resp.Data.Finalized.Root)
   153  	assert.Equal(t, fakeState.CurrentJustifiedCheckpoint().Epoch, resp.Data.CurrentJustified.Epoch)
   154  	assert.DeepEqual(t, fakeState.CurrentJustifiedCheckpoint().Root, resp.Data.CurrentJustified.Root)
   155  	assert.Equal(t, fakeState.PreviousJustifiedCheckpoint().Epoch, resp.Data.PreviousJustified.Epoch)
   156  	assert.DeepEqual(t, fakeState.PreviousJustifiedCheckpoint().Root, resp.Data.PreviousJustified.Root)
   157  }