mirror of
https://gitlab.com/pulsechaincom/prysm-pulse.git
synced 2025-01-03 16:37:39 +00:00
5a66807989
* First take at updating everything to v5 * Patch gRPC gateway to use prysm v5 Fix patch * Update go ssz --------- Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com>
252 lines
8.4 KiB
Go
252 lines
8.4 KiB
Go
package node
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/p2p/enode"
|
|
"github.com/ethereum/go-ethereum/p2p/enr"
|
|
corenet "github.com/libp2p/go-libp2p/core/network"
|
|
"github.com/libp2p/go-libp2p/core/peer"
|
|
libp2ptest "github.com/libp2p/go-libp2p/p2p/host/peerstore/test"
|
|
ma "github.com/multiformats/go-multiaddr"
|
|
"github.com/prysmaticlabs/prysm/v5/api/server/structs"
|
|
"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
|
|
"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
|
|
mockp2p "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
|
|
"github.com/prysmaticlabs/prysm/v5/network/httputil"
|
|
"github.com/prysmaticlabs/prysm/v5/testing/assert"
|
|
"github.com/prysmaticlabs/prysm/v5/testing/require"
|
|
)
|
|
|
|
type testIdentity enode.ID
|
|
|
|
func (_ testIdentity) Verify(_ *enr.Record, _ []byte) error { return nil }
|
|
func (id testIdentity) NodeAddr(_ *enr.Record) []byte { return id[:] }
|
|
|
|
func TestListTrustedPeer(t *testing.T) {
|
|
ids := libp2ptest.GeneratePeerIDs(9)
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
peerStatus := peerFetcher.Peers()
|
|
|
|
for i, id := range ids {
|
|
if i == len(ids)-1 {
|
|
var p2pAddr = "/ip4/127.0.0." + strconv.Itoa(i) + "/udp/12000/p2p/16Uiu2HAm7yD5fhhw1Kihg5pffaGbvKV3k7sqxRGHMZzkb7u9UUxQ"
|
|
p2pMultiAddr, err := ma.NewMultiaddr(p2pAddr)
|
|
require.NoError(t, err)
|
|
peerStatus.Add(nil, id, p2pMultiAddr, corenet.DirUnknown)
|
|
continue
|
|
}
|
|
enrRecord := &enr.Record{}
|
|
err := enrRecord.SetSig(testIdentity{1}, []byte{42})
|
|
require.NoError(t, err)
|
|
enrRecord.Set(enr.IPv4{127, 0, 0, byte(i)})
|
|
err = enrRecord.SetSig(testIdentity{}, []byte{})
|
|
require.NoError(t, err)
|
|
var p2pAddr = "/ip4/127.0.0." + strconv.Itoa(i) + "/udp/12000/p2p/16Uiu2HAm7yD5fhhw1Kihg5pffaGbvKV3k7sqxRGHMZzkb7u9UUxQ"
|
|
p2pMultiAddr, err := ma.NewMultiaddr(p2pAddr)
|
|
require.NoError(t, err)
|
|
|
|
var direction corenet.Direction
|
|
if i%2 == 0 {
|
|
direction = corenet.DirInbound
|
|
} else {
|
|
direction = corenet.DirOutbound
|
|
}
|
|
peerStatus.Add(enrRecord, id, p2pMultiAddr, direction)
|
|
|
|
switch i {
|
|
case 0, 1:
|
|
peerStatus.SetConnectionState(id, peers.PeerConnecting)
|
|
case 2, 3:
|
|
peerStatus.SetConnectionState(id, peers.PeerConnected)
|
|
case 4, 5:
|
|
peerStatus.SetConnectionState(id, peers.PeerDisconnecting)
|
|
case 6, 7:
|
|
peerStatus.SetConnectionState(id, peers.PeerDisconnected)
|
|
default:
|
|
t.Fatalf("Failed to set connection state for peer")
|
|
}
|
|
}
|
|
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
// set all peers as trusted peers
|
|
s.PeersFetcher.Peers().SetTrustedPeers(ids)
|
|
|
|
t.Run("Peer data OK", func(t *testing.T) {
|
|
url := "http://anything.is.fine"
|
|
request := httptest.NewRequest("GET", url, nil)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.ListTrustedPeer(writer, request)
|
|
assert.Equal(t, http.StatusOK, writer.Code)
|
|
resp := &structs.PeersResponse{}
|
|
require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
|
|
peers := resp.Peers
|
|
// assert number of trusted peer is right
|
|
assert.Equal(t, 9, len(peers))
|
|
|
|
for i := 0; i < 9; i++ {
|
|
pid, err := peer.Decode(peers[i].PeerId)
|
|
require.NoError(t, err)
|
|
if pid == ids[8] {
|
|
assert.Equal(t, "", peers[i].Enr)
|
|
assert.Equal(t, "", peers[i].LastSeenP2PAddress)
|
|
assert.Equal(t, "DISCONNECTED", peers[i].State)
|
|
assert.Equal(t, "UNKNOWN", peers[i].Direction)
|
|
continue
|
|
}
|
|
expectedEnr, err := peerStatus.ENR(pid)
|
|
require.NoError(t, err)
|
|
serializeENR, err := p2p.SerializeENR(expectedEnr)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "enr:"+serializeENR, peers[i].Enr)
|
|
expectedP2PAddr, err := peerStatus.Address(pid)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, expectedP2PAddr.String(), peers[i].LastSeenP2PAddress)
|
|
switch pid {
|
|
case ids[0]:
|
|
assert.Equal(t, "CONNECTING", peers[i].State)
|
|
assert.Equal(t, "INBOUND", peers[i].Direction)
|
|
case ids[1]:
|
|
assert.Equal(t, "CONNECTING", peers[i].State)
|
|
assert.Equal(t, "OUTBOUND", peers[i].Direction)
|
|
case ids[2]:
|
|
assert.Equal(t, "CONNECTED", peers[i].State)
|
|
assert.Equal(t, "INBOUND", peers[i].Direction)
|
|
case ids[3]:
|
|
assert.Equal(t, "CONNECTED", peers[i].State)
|
|
assert.Equal(t, "OUTBOUND", peers[i].Direction)
|
|
case ids[4]:
|
|
assert.Equal(t, "DISCONNECTING", peers[i].State)
|
|
assert.Equal(t, "INBOUND", peers[i].Direction)
|
|
case ids[5]:
|
|
assert.Equal(t, "DISCONNECTING", peers[i].State)
|
|
assert.Equal(t, "OUTBOUND", peers[i].Direction)
|
|
case ids[6]:
|
|
assert.Equal(t, "DISCONNECTED", peers[i].State)
|
|
assert.Equal(t, "INBOUND", peers[i].Direction)
|
|
case ids[7]:
|
|
assert.Equal(t, "DISCONNECTED", peers[i].State)
|
|
assert.Equal(t, "OUTBOUND", peers[i].Direction)
|
|
default:
|
|
t.Fatalf("Failed to get connection state and direction for peer")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestListTrustedPeers_NoPeersReturnsEmptyArray(t *testing.T) {
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
|
|
url := "http://anything.is.fine"
|
|
request := httptest.NewRequest("GET", url, nil)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.ListTrustedPeer(writer, request)
|
|
assert.Equal(t, http.StatusOK, writer.Code)
|
|
resp := &structs.PeersResponse{}
|
|
require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
|
|
peers := resp.Peers
|
|
assert.Equal(t, 0, len(peers))
|
|
}
|
|
|
|
func TestAddTrustedPeer(t *testing.T) {
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
|
|
url := "http://anything.is.fine"
|
|
addr := &structs.AddrRequest{
|
|
Addr: "/ip4/127.0.0.1/tcp/30303/p2p/16Uiu2HAm1n583t4huDMMqEUUBuQs6bLts21mxCfX3tiqu9JfHvRJ",
|
|
}
|
|
addrJson, err := json.Marshal(addr)
|
|
require.NoError(t, err)
|
|
var body bytes.Buffer
|
|
_, err = body.Write(addrJson)
|
|
require.NoError(t, err)
|
|
request := httptest.NewRequest("POST", url, &body)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.AddTrustedPeer(writer, request)
|
|
assert.Equal(t, http.StatusOK, writer.Code)
|
|
}
|
|
|
|
func TestAddTrustedPeer_EmptyBody(t *testing.T) {
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
|
|
url := "http://anything.is.fine"
|
|
request := httptest.NewRequest("POST", url, nil)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.AddTrustedPeer(writer, request)
|
|
e := &httputil.DefaultJsonError{}
|
|
require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
|
|
assert.Equal(t, http.StatusBadRequest, writer.Code)
|
|
assert.Equal(t, "Could not decode request body into peer address: unexpected end of JSON input", e.Message)
|
|
|
|
}
|
|
|
|
func TestAddTrustedPeer_BadAddress(t *testing.T) {
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
|
|
url := "http://anything.is.fine"
|
|
addr := &structs.AddrRequest{
|
|
Addr: "anything/but/not/an/address",
|
|
}
|
|
addrJson, err := json.Marshal(addr)
|
|
require.NoError(t, err)
|
|
var body bytes.Buffer
|
|
_, err = body.Write(addrJson)
|
|
require.NoError(t, err)
|
|
request := httptest.NewRequest("POST", url, &body)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.AddTrustedPeer(writer, request)
|
|
e := &httputil.DefaultJsonError{}
|
|
require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
|
|
assert.Equal(t, http.StatusBadRequest, writer.Code)
|
|
assert.StringContains(t, "Could not derive peer info from multiaddress", e.Message)
|
|
}
|
|
|
|
func TestRemoveTrustedPeer(t *testing.T) {
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
|
|
url := "http://anything.is.fine.but.last.is.important/16Uiu2HAm1n583t4huDMMqEUUBuQs6bLts21mxCfX3tiqu9JfHvRJ"
|
|
request := httptest.NewRequest("DELETE", url, nil)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.RemoveTrustedPeer(writer, request)
|
|
assert.Equal(t, http.StatusOK, writer.Code)
|
|
|
|
}
|
|
|
|
func TestRemoveTrustedPeer_EmptyParameter(t *testing.T) {
|
|
peerFetcher := &mockp2p.MockPeersProvider{}
|
|
peerFetcher.ClearPeers()
|
|
s := Server{PeersFetcher: peerFetcher}
|
|
|
|
url := "http://anything.is.fine"
|
|
request := httptest.NewRequest("DELETE", url, nil)
|
|
writer := httptest.NewRecorder()
|
|
writer.Body = &bytes.Buffer{}
|
|
s.RemoveTrustedPeer(writer, request)
|
|
e := &httputil.DefaultJsonError{}
|
|
require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
|
|
assert.Equal(t, http.StatusBadRequest, writer.Code)
|
|
assert.Equal(t, "Could not decode peer id: failed to parse peer ID: invalid cid: cid too short", e.Message)
|
|
}
|