-
Notifications
You must be signed in to change notification settings - Fork 6
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
1 parent
9fa9710
commit ea9cca1
Showing
1 changed file
with
114 additions
and
146 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,163 +1,131 @@ | ||
| package rpc | ||
|
|
||
| import ( | ||
| "encoding/json" | ||
| "os" | ||
| "path/filepath" | ||
| "fmt" | ||
| "net/http" | ||
| "net/http/httptest" | ||
| "testing" | ||
|
|
||
| "github.com/BlocSoc-iitr/selene/consensus/consensus_core" | ||
| "github.com/stretchr/testify/assert" | ||
| "github.com/stretchr/testify/require" | ||
| ) | ||
| func TestNewMockRpc(t *testing.T) { | ||
| path := "/tmp/testdata" | ||
| mockRpc := NewMockRpc(path) | ||
| if mockRpc.testdata != path { | ||
| t.Errorf("Expected testdata path to be %s, got %s", path, mockRpc.testdata) | ||
| } | ||
|
|
||
| func TestNewNimbusRpc(t *testing.T) { | ||
| rpcURL := "http://example.com" | ||
| nimbusRpc := NewNimbusRpc(rpcURL) | ||
| assert.Equal(t, rpcURL, nimbusRpc.rpc) | ||
| } | ||
| func TestGetBootstrap(t *testing.T) { | ||
| tempDir, err := os.MkdirTemp("", "mock_rpc_test") | ||
| if err != nil { | ||
| t.Fatalf("Failed to create temp dir: %v", err) | ||
| } | ||
| defer os.RemoveAll(tempDir) | ||
| mockBootstrap := BootstrapResponse{ | ||
| Data: consensus_core.Bootstrap{ | ||
| Header: consensus_core.Header{ | ||
| Slot: 1000, | ||
| func TestNimbusGetBootstrap(t *testing.T) { | ||
| blockRoot := [32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32} | ||
| expectedPath := fmt.Sprintf("/eth/v1/beacon/light_client/bootstrap/0x%x", blockRoot) | ||
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | ||
| assert.Equal(t, expectedPath, r.URL.Path) | ||
| response := BootstrapResponse{ | ||
| Data: consensus_core.Bootstrap{ | ||
| Header: consensus_core.Header{ | ||
| Slot: 1000, | ||
| }, | ||
| }, | ||
| }, | ||
| } | ||
| bootstrapJSON, _ := json.Marshal(mockBootstrap) | ||
| err = os.WriteFile(filepath.Join(tempDir, "bootstrap.json"), bootstrapJSON, 0644) | ||
| if err != nil { | ||
| t.Fatalf("Failed to write mock bootstrap file: %v", err) | ||
| } | ||
| mockRpc := NewMockRpc(tempDir) | ||
| bootstrap, err := mockRpc.GetBootstrap([]byte{}) | ||
| if err != nil { | ||
| t.Fatalf("GetBootstrap failed: %v", err) | ||
| } | ||
| if bootstrap.Header.Slot != 1000 { | ||
| t.Errorf("Expected bootstrap slot to be 1000, got %d", bootstrap.Header.Slot) | ||
| } | ||
| } | ||
| err := json.NewEncoder(w).Encode(response) | ||
| require.NoError(t, err) | ||
| })) | ||
| defer server.Close() | ||
| nimbusRpc := NewNimbusRpc(server.URL) | ||
| bootstrap, err := nimbusRpc.GetBootstrap(blockRoot) | ||
| assert.NoError(t, err) | ||
| assert.Equal(t, uint64(1000), bootstrap.Header.Slot) | ||
| } | ||
| func TestGetUpdates(t *testing.T) { | ||
| tempDir, err := os.MkdirTemp("", "mock_rpc_test") | ||
| if err != nil { | ||
| t.Fatalf("Failed to create temp dir: %v", err) | ||
| } | ||
| defer os.RemoveAll(tempDir) | ||
| mockUpdates := UpdateResponse{ | ||
| {Data: consensus_core.Update{SignatureSlot: 1}}, | ||
| {Data: consensus_core.Update{SignatureSlot: 2}}, | ||
| } | ||
| updatesJSON, _ := json.Marshal(mockUpdates) | ||
| err = os.WriteFile(filepath.Join(tempDir, "updates.json"), updatesJSON, 0644) | ||
| if err != nil { | ||
| t.Fatalf("Failed to write mock updates file: %v", err) | ||
| } | ||
| mockRpc := NewMockRpc(tempDir) | ||
| updates, err := mockRpc.GetUpdates(1, 2) | ||
| if err != nil { | ||
| t.Fatalf("GetUpdates failed: %v", err) | ||
| } | ||
| if len(updates) != 2 { | ||
| t.Errorf("Expected 2 updates, got %d", len(updates)) | ||
| } | ||
| if updates[0].SignatureSlot != 1 || updates[1].SignatureSlot != 2 { | ||
| t.Errorf("Unexpected update signature slots") | ||
| } | ||
| func TestNimbusGetUpdates(t *testing.T) { | ||
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | ||
| assert.Equal(t, "/eth/v1/beacon/light_client/updates", r.URL.Path) | ||
| assert.Equal(t, "start_period=1000&count=5", r.URL.RawQuery) | ||
| response := UpdateResponse{ | ||
| {Data: consensus_core.Update{AttestedHeader: consensus_core.Header{Slot: 1000}}}, | ||
| {Data: consensus_core.Update{AttestedHeader: consensus_core.Header{Slot: 1001}}}, | ||
| } | ||
| err := json.NewEncoder(w).Encode(response) | ||
| require.NoError(t, err) | ||
| })) | ||
| defer server.Close() | ||
| nimbusRpc := NewNimbusRpc(server.URL) | ||
| updates, err := nimbusRpc.GetUpdates(1000, 5) | ||
| assert.NoError(t, err) | ||
| assert.Len(t, updates, 2) | ||
| assert.Equal(t, uint64(1000), updates[0].AttestedHeader.Slot) | ||
| assert.Equal(t, uint64(1001), updates[1].AttestedHeader.Slot) | ||
| } | ||
| func TestGetFinalityUpdate(t *testing.T) { | ||
| tempDir, err := os.MkdirTemp("", "mock_rpc_test") | ||
| if err != nil { | ||
| t.Fatalf("Failed to create temp dir: %v", err) | ||
| } | ||
| defer os.RemoveAll(tempDir) | ||
| mockFinality := FinalityUpdateResponse{ | ||
| Data: consensus_core.FinalityUpdate{ | ||
| FinalizedHeader: consensus_core.Header{ | ||
| Slot: 2000, | ||
| func TestNimbusGetFinalityUpdate(t *testing.T) { | ||
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | ||
| assert.Equal(t, "/eth/v1/beacon/light_client/finality_update", r.URL.Path) | ||
| response := FinalityUpdateResponse{ | ||
| Data: consensus_core.FinalityUpdate{ | ||
| FinalizedHeader: consensus_core.Header{ | ||
| Slot: 2000, | ||
| }, | ||
| }, | ||
| }, | ||
| } | ||
| finalityJSON, _ := json.Marshal(mockFinality) | ||
| err = os.WriteFile(filepath.Join(tempDir, "finality.json"), finalityJSON, 0644) | ||
| if err != nil { | ||
| t.Fatalf("Failed to write mock finality file: %v", err) | ||
| } | ||
| mockRpc := NewMockRpc(tempDir) | ||
| finality, err := mockRpc.GetFinalityUpdate() | ||
| if err != nil { | ||
| t.Fatalf("GetFinalityUpdate failed: %v", err) | ||
| } | ||
| if finality.FinalizedHeader.Slot != 2000 { | ||
| t.Errorf("Expected finality slot to be 2000, got %d", finality.FinalizedHeader.Slot) | ||
| } | ||
| } | ||
| err := json.NewEncoder(w).Encode(response) | ||
| require.NoError(t, err) | ||
| })) | ||
| defer server.Close() | ||
| nimbusRpc := NewNimbusRpc(server.URL) | ||
| finalityUpdate, err := nimbusRpc.GetFinalityUpdate() | ||
| assert.NoError(t, err) | ||
| assert.Equal(t, uint64(2000), finalityUpdate.FinalizedHeader.Slot) | ||
| } | ||
| func TestGetOptimisticUpdate(t *testing.T) { | ||
| tempDir, err := os.MkdirTemp("", "mock_rpc_test") | ||
| if err != nil { | ||
| t.Fatalf("Failed to create temp dir: %v", err) | ||
| } | ||
| defer os.RemoveAll(tempDir) | ||
| mockOptimistic := OptimisticUpdateResponse{ | ||
| Data: consensus_core.OptimisticUpdate{ | ||
| SignatureSlot: 3000, | ||
| }, | ||
| } | ||
| optimisticJSON, _ := json.Marshal(mockOptimistic) | ||
| err = os.WriteFile(filepath.Join(tempDir, "optimistic.json"), optimisticJSON, 0644) | ||
| if err != nil { | ||
| t.Fatalf("Failed to write mock optimistic file: %v", err) | ||
| } | ||
| mockRpc := NewMockRpc(tempDir) | ||
| optimistic, err := mockRpc.GetOptimisticUpdate() | ||
| if err != nil { | ||
| t.Fatalf("GetOptimisticUpdate failed: %v", err) | ||
| } | ||
| if optimistic.SignatureSlot != 3000 { | ||
| t.Errorf("Expected optimistic signature slot to be 3000, got %d", optimistic.SignatureSlot) | ||
| } | ||
| func TestNimbusGetOptimisticUpdate(t *testing.T) { | ||
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | ||
| assert.Equal(t, "/eth/v1/beacon/light_client/optimistic_update", r.URL.Path) | ||
| response := OptimisticUpdateResponse{ | ||
| Data: consensus_core.OptimisticUpdate{ | ||
| SignatureSlot: 3000, | ||
| }, | ||
| } | ||
| err := json.NewEncoder(w).Encode(response) | ||
| require.NoError(t, err) | ||
| })) | ||
| defer server.Close() | ||
| nimbusRpc := NewNimbusRpc(server.URL) | ||
| optimisticUpdate, err := nimbusRpc.GetOptimisticUpdate() | ||
| assert.NoError(t, err) | ||
| assert.Equal(t, uint64(3000), optimisticUpdate.SignatureSlot) | ||
| } | ||
| func TestGetBlock(t *testing.T) { | ||
| tempDir, err := os.MkdirTemp("", "mock_rpc_test") | ||
| if err != nil { | ||
| t.Fatalf("Failed to create temp dir: %v", err) | ||
| } | ||
| defer os.RemoveAll(tempDir) | ||
| blocksDir := filepath.Join(tempDir, "blocks") | ||
| err = os.Mkdir(blocksDir, 0755) | ||
| if err != nil { | ||
| t.Fatalf("Failed to create blocks directory: %v", err) | ||
| } | ||
| mockBlock := BeaconBlockResponse{ | ||
| Data: struct { | ||
| Message consensus_core.BeaconBlock | ||
| }{ | ||
| Message: consensus_core.BeaconBlock{ | ||
| Slot: 4000, | ||
| func TestNimbusGetBlock(t *testing.T) { | ||
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | ||
| assert.Equal(t, "/eth/v2/beacon/blocks/4000", r.URL.Path) | ||
| response := BeaconBlockResponse{ | ||
| Data: BeaconBlockData{ | ||
| Message: consensus_core.BeaconBlock{ | ||
| Slot: 4000, | ||
| }, | ||
| }, | ||
| }, | ||
| } | ||
| blockJSON, _ := json.Marshal(mockBlock) | ||
| err = os.WriteFile(filepath.Join(blocksDir, "4000.json"), blockJSON, 0644) | ||
| if err != nil { | ||
| t.Fatalf("Failed to write mock block file: %v", err) | ||
| } | ||
| mockRpc := NewMockRpc(tempDir) | ||
| block, err := mockRpc.GetBlock(4000) | ||
| if err != nil { | ||
| t.Fatalf("GetBlock failed: %v", err) | ||
| } | ||
| if block.Slot != 4000 { | ||
| t.Errorf("Expected block slot to be 4000, got %d", block.Slot) | ||
| } | ||
| } | ||
| err := json.NewEncoder(w).Encode(response) | ||
| require.NoError(t, err) | ||
| })) | ||
| defer server.Close() | ||
| nimbusRpc := NewNimbusRpc(server.URL) | ||
| block, err := nimbusRpc.GetBlock(4000) | ||
| assert.NoError(t, err) | ||
| assert.Equal(t, uint64(4000), block.Slot) | ||
| } | ||
| func TestChainId(t *testing.T) { | ||
| mockRpc := NewMockRpc("/tmp/testdata") | ||
| _, err := mockRpc.ChainId() | ||
| if err == nil || err.Error() != "not implemented" { | ||
| t.Errorf("Expected 'not implemented' error, got %v", err) | ||
| } | ||
| func TestNimbusChainId(t *testing.T) { | ||
| server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { | ||
| assert.Equal(t, "/eth/v1/config/spec", r.URL.Path) | ||
| response := SpecResponse{ | ||
| Data: Spec{ | ||
| ChainId: 5000, | ||
| }, | ||
| } | ||
| err := json.NewEncoder(w).Encode(response) | ||
| require.NoError(t, err) | ||
| })) | ||
| defer server.Close() | ||
| nimbusRpc := NewNimbusRpc(server.URL) | ||
| chainId, err := nimbusRpc.ChainId() | ||
| assert.NoError(t, err) | ||
| assert.Equal(t, uint64(5000), chainId) | ||
| } |