completed test coverage, expect for simplequery

network/endpoint/fakeendpoint/fakeendpoint.go

@@ -113,15 +113,10 @@ func (e *FakeEndpoint) SendRequestHandleResponse(ctx context.Context,
 		return nil
 	}
 
-	// send request
-	addr, ok := e.peerstore[id.String()]
-	if !ok {
-		span.RecordError(endpoint.ErrUnknownPeer)
-		e.sched.EnqueueAction(ctx, ba.BasicAction(func(ctx context.Context) {
-			handleResp(ctx, nil, endpoint.ErrUnknownPeer)
-		}))
-		return nil
-	}
+	// send request. id.String() is guaranteed to be in peerstore, because
+	// DialPeer checks it, and an error is returned if it's not there.
+	addr := e.peerstore[id.String()]
+
 	sid, err := e.router.SendMessage(ctx, e.self, addr.NodeID(), protoID, 0, req)
 	if err != nil {
 		span.RecordError(err)

network/endpoint/fakeendpoint/fakeendpoint_test.go

@@ -7,10 +7,12 @@ import (
 
 	"github.com/benbjohnson/clock"
 	"github.com/libp2p/go-libp2p/core/network"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/plprobelab/go-kademlia/events/scheduler"
 	"github.com/plprobelab/go-kademlia/events/scheduler/simplescheduler"
 	"github.com/plprobelab/go-kademlia/network/address"
 	"github.com/plprobelab/go-kademlia/network/address/kadid"
+	"github.com/plprobelab/go-kademlia/network/address/peerid"
 	si "github.com/plprobelab/go-kademlia/network/address/stringid"
 	"github.com/plprobelab/go-kademlia/network/endpoint"
 	"github.com/plprobelab/go-kademlia/network/message"
@@ -50,6 +52,12 @@ func TestFakeEndpoint(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, na, node0)
 
+	parsed, err := peer.Decode("1EooooPEER")
+	require.NoError(t, err)
+	pid := peerid.NewPeerID(parsed)
+	_, err = fakeEndpoint.NetworkAddress(pid)
+	require.Equal(t, endpoint.ErrUnknownPeer, err)
+
 	req := simmessage.NewSimRequest(selfID.Key())
 	resp := &simmessage.SimMessage{}
 

server/basicserver/basicserver.go

@@ -92,13 +92,6 @@ func (s *BasicServer) HandleFindNodeRequest(ctx context.Context,
 		attribute.Stringer("Target", target)))
 	defer span.End()
 
-	rPeerAddr, err := s.endpoint.NetworkAddress(rpeer)
-	if err != nil {
-		span.RecordError(err)
-		return nil, err
-	}
-	s.endpoint.MaybeAddToPeerstore(ctx, rPeerAddr, s.peerstoreTTL)
-
 	peers, err := s.rt.NearestPeers(ctx, target, s.numberOfCloserPeersToSend)
 	if err != nil {
 		span.RecordError(err)
@@ -114,14 +107,17 @@ func (s *BasicServer) HandleFindNodeRequest(ctx context.Context,
 	switch msg.(type) {
 	case *simmessage.SimMessage:
 		peerAddrs := make([]address.NodeAddr, len(peers))
-		for i, p := range peers {
-			peerAddrs[i], err = s.endpoint.NetworkAddress(p)
+		var index int
+		for _, p := range peers {
+			na, err := s.endpoint.NetworkAddress(p)
 			if err != nil {
 				span.RecordError(err)
 				continue
 			}
+			peerAddrs[index] = na
+			index++
 		}
-		resp = simmessage.NewSimResponse(peerAddrs)
+		resp = simmessage.NewSimResponse(peerAddrs[:index])
 	case *ipfsv1.Message:
 		nEndpoint, ok := s.endpoint.(endpoint.NetworkedEndpoint)
 		if !ok {

server/basicserver/basicserver_test.go

@@ -161,6 +161,54 @@ func TestInvalidSimRequests(t *testing.T) {
 	s.HandleFindNodeRequest(ctx, requester, req2)
 }
 
+func TestSimRequestNoNetworkAddress(t *testing.T) {
+	ctx := context.Background()
+	keylen := 32
+	// invalid option
+	s := NewBasicServer(nil, nil, func(*Config) error {
+		return errors.New("invalid option")
+	})
+	require.Nil(t, s)
+
+	clk := clock.New()
+	router := fakeendpoint.NewFakeRouter()
+
+	var self = kadid.KadID{KadKey: make([]byte, keylen)} // 0000 0000
+
+	// create a valid server
+	sched := simplescheduler.NewSimpleScheduler(clk)
+	fakeEndpoint := fakeendpoint.NewFakeEndpoint(self, sched, router)
+	rt := simplert.NewSimpleRT(self.Key(), 2)
+
+	parsed, err := peer.Decode("1EooooPEER")
+	require.NoError(t, err)
+	addrInfo := addrinfo.NewAddrInfo(peer.AddrInfo{
+		ID:    parsed,
+		Addrs: nil,
+	})
+
+	// add peer to routing table, but NOT to peerstore
+	success, err := rt.AddPeer(ctx, addrInfo.NodeID())
+	require.NoError(t, err)
+	require.True(t, success)
+
+	s = NewBasicServer(rt, fakeEndpoint)
+	require.NotNil(t, s)
+
+	require.NotNil(t, s)
+
+	requester := kadid.KadID{KadKey: append([]byte{0x80}, make([]byte, keylen-1)...)}
+
+	// sim request message (for any key)
+	req := simmessage.NewSimRequest(requester.Key())
+	msg, err := s.HandleFindNodeRequest(ctx, requester, req)
+	require.NoError(t, err)
+	resp, ok := msg.(message.MinKadResponseMessage)
+	require.True(t, ok)
+	fmt.Println(resp.CloserNodes())
+	require.Len(t, resp.CloserNodes(), 0)
+}
+
 func TestIPFSv1Handling(t *testing.T) {
 	ctx := context.Background()
 	clk := clock.NewMock()
@@ -198,7 +246,7 @@ func TestIPFSv1Handling(t *testing.T) {
 			// it is among the numberOfCloserPeersToSend closer peers
 			addrInfo = addrinfo.NewAddrInfo(peer.AddrInfo{
 				ID:    p,
-				Addrs: []multiaddr.Multiaddr{},
+				Addrs: nil,
 			})
 		}
 		// add peers to routing table and peerstore