test(retriever): add direct candidate source test

filecoin-project · Jan 25, 2024 · 471422a · 471422a
1 parent 55ec482
commit 471422a
Show file tree

Hide file tree

Showing 5 changed files with 118 additions and 11 deletions.
diff --git a/pkg/internal/itest/direct_fetch_test.go b/pkg/internal/itest/direct_fetch_test.go
@@ -22,7 +22,6 @@ import (
 	"github.com/ipld/go-ipld-prime/codec/dagcbor"
 	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
 	trustlessutils "github.com/ipld/go-trustless-utils"
-	"github.com/ipni/go-libipni/metadata"
 	host "github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -39,11 +38,9 @@ const (
 
 func TestDirectFetch(t *testing.T) {
 	testCases := []struct {
-		name           string
-		directPeer     int
-		fixedProtocols []metadata.Protocol
+		name       string
+		directPeer int
 	}{
-		{},
 		{
 			name:       "direct bitswap peer",
 			directPeer: bitswapDirect,

diff --git a/pkg/internal/testutil/gen.go b/pkg/internal/testutil/gen.go
@@ -112,13 +112,13 @@ func GenerateRetrievalCandidatesForCID(t *testing.T, n int, c cid.Cid, protocols
 		protocols = []metadata.Protocol{&metadata.Bitswap{}}
 	}
 	for i := 0; i < n; i++ {
-		addrs := []multiaddr.Multiaddr{GenerateMultiaddr()}
+		addrs := []multiaddr.Multiaddr{GenerateHTTPMultiAddr()}
 		candidates = append(candidates, types.NewRetrievalCandidate(peers[i], addrs, c, protocols...))
 	}
 	return candidates
 }
 
-func GenerateMultiaddr() multiaddr.Multiaddr {
+func GenerateMultiAddr() multiaddr.Multiaddr {
 	// generate a random ipv4 address
 	addr := &net.TCPAddr{IP: net.IPv4(byte(rand.Intn(255)), byte(rand.Intn(255)), byte(rand.Intn(255)), byte(rand.Intn(255))), Port: rand.Intn(65535)}
 	maddr, err := manet.FromIP(addr.IP)
@@ -129,7 +129,11 @@ func GenerateMultiaddr() multiaddr.Multiaddr {
 	if err != nil {
 		panic(err)
 	}
-	maddr = multiaddr.Join(maddr, port)
+	return multiaddr.Join(maddr, port)
+}
+
+func GenerateHTTPMultiAddr() multiaddr.Multiaddr {
+	maddr := GenerateMultiAddr()
 	scheme, err := multiaddr.NewComponent("http", "")
 	if err != nil {
 		panic(err)

diff --git a/pkg/retriever/directcandidatesource_test.go b/pkg/retriever/directcandidatesource_test.go
@@ -0,0 +1,91 @@
+package retriever_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/lassie/pkg/internal/testutil"
+	"github.com/filecoin-project/lassie/pkg/retriever"
+	"github.com/filecoin-project/lassie/pkg/types"
+	"github.com/ipni/go-libipni/metadata"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/multiformats/go-multiaddr"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDirectCandidateSourceNoLibp2p(t *testing.T) {
+	rootCid := testutil.GenerateCid()
+	p := testutil.GeneratePeers(t, 1)[0]
+	rawMultiaddr := testutil.GenerateMultiAddr()
+	httpMultiaddr := testutil.GenerateHTTPMultiAddr()
+	ctx := context.Background()
+	testCases := []struct {
+		name              string
+		provider          types.Provider
+		expectedCandidate types.RetrievalCandidate
+	}{
+		{
+			name: "peer with protocols",
+			provider: types.Provider{
+				Peer: peer.AddrInfo{
+					ID:    p,
+					Addrs: []multiaddr.Multiaddr{rawMultiaddr},
+				},
+				Protocols: []metadata.Protocol{metadata.IpfsGatewayHttp{}, metadata.Bitswap{}},
+			},
+			expectedCandidate: types.RetrievalCandidate{
+				MinerPeer: peer.AddrInfo{
+					ID:    p,
+					Addrs: []multiaddr.Multiaddr{rawMultiaddr},
+				},
+				RootCid:  rootCid,
+				Metadata: metadata.Default.New(metadata.IpfsGatewayHttp{}, metadata.Bitswap{}),
+			},
+		},
+		{
+			name: "peer with no protocols and standard multiaddr",
+			provider: types.Provider{
+				Peer: peer.AddrInfo{
+					ID:    p,
+					Addrs: []multiaddr.Multiaddr{rawMultiaddr},
+				},
+			},
+			expectedCandidate: types.RetrievalCandidate{
+				MinerPeer: peer.AddrInfo{
+					ID:    p,
+					Addrs: []multiaddr.Multiaddr{rawMultiaddr},
+				},
+				RootCid:  rootCid,
+				Metadata: metadata.Default.New(metadata.IpfsGatewayHttp{}, metadata.Bitswap{}, &metadata.GraphsyncFilecoinV1{}),
+			},
+		},
+		{
+			name: "peer with no protocols and http multiaddr",
+			provider: types.Provider{
+				Peer: peer.AddrInfo{
+					ID:    p,
+					Addrs: []multiaddr.Multiaddr{httpMultiaddr},
+				},
+			},
+			expectedCandidate: types.RetrievalCandidate{
+				MinerPeer: peer.AddrInfo{
+					ID:    p,
+					Addrs: []multiaddr.Multiaddr{httpMultiaddr},
+				},
+				RootCid:  rootCid,
+				Metadata: metadata.Default.New(metadata.IpfsGatewayHttp{}),
+			},
+		},
+	}
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
+			defer cancel()
+			d := retriever.NewDirectCandidateSource([]types.Provider{testCase.provider})
+			d.FindCandidates(ctx, rootCid, func(candidate types.RetrievalCandidate) {
+				require.Equal(t, testCase.expectedCandidate, candidate)
+			})
+		})
+	}
+}
diff --git a/pkg/types/request.go b/pkg/types/request.go
@@ -258,19 +258,18 @@ func ParseProviderStrings(v string) ([]Provider, error) {
 			if err != nil {
 				return nil, err
 			}
-			protocols = append(protocols, &metadata.IpfsGatewayHttp{})
 		} else {
 			parts := strings.Split(v, "+")
 			addrString := parts[0]
 			if len(parts) > 1 {
 				for _, part := range parts[1:] {
 					switch part {
 					case "bitswap":
-						protocols = append(protocols, &metadata.Bitswap{})
+						protocols = append(protocols, metadata.Bitswap{})
 					case "graphsync":
 						protocols = append(protocols, &metadata.GraphsyncFilecoinV1{})
 					case "http":
-						protocols = append(protocols, &metadata.IpfsGatewayHttp{})
+						protocols = append(protocols, metadata.IpfsGatewayHttp{})
 					default:
 						return nil, fmt.Errorf("unrecognized protocol: %s", v)
 					}

diff --git a/pkg/types/request_test.go b/pkg/types/request_test.go
@@ -5,6 +5,7 @@ import (
 
 	"github.com/ipfs/go-cid"
 	trustlessutils "github.com/ipld/go-trustless-utils"
+	"github.com/ipni/go-libipni/metadata"
 	"github.com/multiformats/go-multicodec"
 	"github.com/stretchr/testify/require"
 )
@@ -200,6 +201,21 @@ func TestRequestStringRepresentations(t *testing.T) {
 		_, err := ParseProviderStrings("http://127.0.0.1:5000/nope")
 		require.ErrorContains(t, err, "paths not supported")
 	})
+
+	t.Run("fixed peer, protocol included", func(t *testing.T) {
+		pps, err := ParseProviderStrings("/ip4/127.0.0.1/tcp/5000/p2p/12D3KooWBSTEYMLSu5FnQjshEVah9LFGEZoQt26eacCEVYfedWA4+bitswap")
+		require.NoError(t, err)
+		require.Equal(t, pps[0].Protocols, []metadata.Protocol{metadata.Bitswap{}})
+		request := RetrievalRequest{
+			Request:   trustlessutils.Request{Root: testCidV1},
+			Providers: pps,
+		}
+		ds, err := request.GetDescriptorString()
+		require.NoError(t, err)
+		expectedStart := "/ipfs/bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi?dag-scope=all&dups=n&providers=/ip4/127.0.0.1/tcp/5000/p2p/12D3KooWBSTEYMLSu5FnQjshEVah9LFGEZoQt26eacCEVYfedWA4+bitswap"
+		require.Equal(t, expectedStart, ds[0:len(expectedStart)])
+	})
+
 }
 
 func TestProviderStrings(t *testing.T) {