Fix tests.

Still some tests failing but there is no compilation errors.

Signed-off-by: Antonio Navarro Perez <[email protected]>

client/client.go

@@ -178,25 +178,3 @@ func (c *client) provideSignedBitswapRecord(ctx context.Context, bswp delegatedr
 	}
 	return provideResult.ProvideResults[0].(*delegatedrouting.BitswapWriteProviderResponse).AdvisoryTTL, nil
 }
-
-func (c *client) Ready(ctx context.Context) (bool, error) {
-	url := c.baseURL + "/v1/ping"
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-	if err != nil {
-		return false, err
-	}
-
-	resp, err := c.httpClient.Do(req)
-	if err != nil {
-		return false, err
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode == http.StatusOK {
-		return true, nil
-	}
-	if resp.StatusCode == http.StatusServiceUnavailable {
-		return false, nil
-	}
-	return false, fmt.Errorf("unexpected HTTP status code '%d'", resp.StatusCode)
-}

client/client_test.go

@@ -3,6 +3,7 @@ package client
 import (
 	"context"
 	"crypto/rand"
+	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -48,12 +49,15 @@ type testDeps struct {
 }
 
 func makeTestDeps(t *testing.T) testDeps {
-	provider, identity := makeProviderAndIdentity(nil)
+	provider, identity := makeBitswapProviderAndIdentity("")
 	router := &mockContentRouter{}
 	server := httptest.NewServer(server.Handler(router))
 	t.Cleanup(server.Close)
 	serverAddr := "http://" + server.Listener.Addr().String()
-	c, err := New(serverAddr, WithProvider(provider), WithIdentity(identity))
+	c, err := New(serverAddr, WithProvider(Provider{
+		ID:    provider.ID,
+		Addrs: provider.Addrs,
+	}), WithIdentity(identity))
 	if err != nil {
 		panic(err)
 	}
@@ -79,72 +83,12 @@ func makeCID() cid.Cid {
 	return c
 }
 
-func TestClient_Ready(t *testing.T) {
-	cases := []struct {
-		name           string
-		manglePath     bool
-		stopServer     bool
-		routerReady    bool
-		expStatus      bool
-		expErrContains string
-	}{
-		{
-			name:        "happy case",
-			routerReady: true,
-			expStatus:   true,
-		},
-		{
-			name:        "503 returns false",
-			routerReady: false,
-			expStatus:   false,
-		},
-		{
-			name:           "non-503 error returns an error",
-			manglePath:     true,
-			expStatus:      false,
-			expErrContains: "unexpected HTTP status code '404'",
-		},
-		{
-			name:           "undialable returns an error",
-			stopServer:     true,
-			expStatus:      false,
-			expErrContains: "connect: connection refused",
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			deps := makeTestDeps(t)
-			client := deps.client
-			router := deps.router
-
-			if c.manglePath {
-				client.baseURL += "/foo"
-			}
-			if c.stopServer {
-				deps.server.Close()
-			}
-
-			router.On("Ready").Return(c.routerReady)
-
-			ready, err := client.Ready(context.Background())
-
-			if c.expErrContains != "" {
-				assert.ErrorContains(t, err, c.expErrContains)
-			} else {
-				assert.NoError(t, err)
-			}
-
-			assert.Equal(t, c.expStatus, ready)
-		})
-	}
-}
-
-func makeProvider(protocols []delegatedrouting.TransferProtocol) delegatedrouting.Provider {
-	prov, _ := makeProviderAndIdentity(protocols)
+func makeProvider(protocol multicodec.Code) delegatedrouting.Provider {
+	prov, _ := makeBitswapProviderAndIdentity(fmt.Sprintf("%d", protocol))
 	return prov
 }
 
-func makeProviderAndIdentity(protocols []delegatedrouting.TransferProtocol) (delegatedrouting.Provider, crypto.PrivKey) {
+func makeBitswapProviderAndIdentity(protocol string) (delegatedrouting.BitswapReadProvider, crypto.PrivKey) {
 	priv, _, err := crypto.GenerateEd25519Key(rand.Reader)
 	if err != nil {
 		panic(err)
@@ -163,31 +107,35 @@ func makeProviderAndIdentity(protocols []delegatedrouting.TransferProtocol) (del
 		panic(err)
 	}
 
-	return delegatedrouting.Provider{
-		PeerID:    peerID,
-		Addrs:     []multiaddr.Multiaddr{ma1, ma2},
-		Protocols: protocols,
+	return delegatedrouting.BitswapReadProvider{
+		Addrs:    []multiaddr.Multiaddr{ma1, ma2},
+		ID:       peerID,
+		Protocol: protocol,
 	}, priv
 }
 
 func provsToAIs(provs []delegatedrouting.Provider) (ais []peer.AddrInfo) {
 	for _, prov := range provs {
-		ais = append(ais, peer.AddrInfo{
-			ID:    prov.PeerID,
-			Addrs: prov.Addrs,
-		})
+		switch v := prov.(type) {
+		case delegatedrouting.BitswapReadProvider:
+			ais = append(ais, peer.AddrInfo{
+				ID:    v.ID,
+				Addrs: v.Addrs,
+			})
+		default:
+			panic(fmt.Sprint("unknown provider type", v))
+		}
+
 	}
 	return
 }
 
 func TestClient_FindProviders(t *testing.T) {
-	bitswapProtocol := []delegatedrouting.TransferProtocol{{Codec: multicodec.TransportBitswap, Payload: []byte(`{"a":1}`)}}
-	bitswapProvs := []delegatedrouting.Provider{makeProvider(bitswapProtocol), makeProvider(bitswapProtocol)}
+	bitswapProvs := []delegatedrouting.Provider{makeProvider(multicodec.TransportBitswap), makeProvider(multicodec.TransportBitswap)}
 
-	nonBitswapProtocol := []delegatedrouting.TransferProtocol{{Codec: multicodec.TransportGraphsyncFilecoinv1}}
 	mixedProvs := []delegatedrouting.Provider{
-		makeProvider(bitswapProtocol),
-		makeProvider(nonBitswapProtocol),
+		makeProvider(multicodec.TransportBitswap),
+		makeProvider(multicodec.TransportGraphsyncFilecoinv1),
 	}
 
 	cases := []struct {
@@ -303,13 +251,12 @@ func TestClient_Provide(t *testing.T) {
 			deps := makeTestDepsLibp2p(t)
 			client := deps.client
 			router := deps.router
-			prov := deps.provider
 
 			if c.noIdentity {
 				client.identity = nil
 			}
 			if c.noProvider {
-				client.provider = delegatedrouting.Provider{}
+				client.provider = Provider{}
 			}
 
 			clock := clock.NewMock()
@@ -332,13 +279,12 @@ func TestClient_Provide(t *testing.T) {
 				Keys:        c.cids,
 				Timestamp:   clock.Now(),
 				AdvisoryTTL: c.ttl,
-				Provider:    prov,
 			}
 
 			router.On("Provide", mock.Anything, expectedProvReq).
 				Return(c.routerAdvisoryTTL, c.routerErr)
 
-			advisoryTTL, err := client.Provide(ctx, c.cids, c.ttl)
+			advisoryTTL, err := client.ProvideBitswap(ctx, c.cids, c.ttl)
 
 			if c.expErrContains != "" {
 				require.ErrorContains(t, err, c.expErrContains)
@@ -352,7 +298,7 @@ func TestClient_Provide(t *testing.T) {
 }
 
 func makeTestDepsLibp2p(t *testing.T) testDeps {
-	provider, identity := makeProviderAndIdentity(nil)
+	provider, identity := makeBitswapProviderAndIdentity("")
 	router := &mockContentRouter{}
 	server := httptest.NewUnstartedServer(server.Handler(router))
 
@@ -362,6 +308,8 @@ func makeTestDepsLibp2p(t *testing.T) testDeps {
 	t.Cleanup(func() { h1.Close() })
 
 	listener, err := gostream.Listen(h1, p2phttp.DefaultP2PProtocol)
+	require.NoError(t, err)
+
 	t.Cleanup(func() { listener.Close() })
 	server.Listener = listener
 
@@ -376,7 +324,10 @@ func makeTestDepsLibp2p(t *testing.T) testDeps {
 	require.NoError(t, err)
 	t.Cleanup(func() { h2.Close() })
 
-	c, err := New(serverAddr, WithProvider(provider), WithIdentity(identity))
+	c, err := New(serverAddr, WithProvider(Provider{
+		ID:    provider.ID,
+		Addrs: provider.Addrs,
+	}), WithIdentity(identity))
 	if err != nil {
 		panic(err)
 	}

go.mod

@@ -109,7 +109,3 @@ require (
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	lukechampine.com/blake3 v1.1.7 // indirect
 )
-
-replace github.com/libp2p/go-libp2p-gostream v0.5.0 => ../go-libp2p-gostream
-
-replace github.com/libp2p/go-libp2p-http v0.4.0 => ../go-libp2p-http

go.sum

@@ -268,6 +268,10 @@ github.com/libp2p/go-libp2p v0.23.3 h1:/n3i0VtJF0iZ9YMUxl/teOY3h+M8NfgaCjOSYr9D+
 github.com/libp2p/go-libp2p v0.23.3/go.mod h1:s9DEa5NLR4g+LZS+md5uGU4emjMWFiqkZr6hBTY8UxI=
 github.com/libp2p/go-libp2p-asn-util v0.2.0 h1:rg3+Os8jbnO5DxkC7K/Utdi+DkY3q/d1/1q+8WeNAsw=
 github.com/libp2p/go-libp2p-asn-util v0.2.0/go.mod h1:WoaWxbHKBymSN41hWSq/lGKJEca7TNm58+gGJi2WsLI=
+github.com/libp2p/go-libp2p-gostream v0.5.0 h1:niNGTUrFoUDP/8jxMgu97zngMO+UGYBpVpbCKwIJBls=
+github.com/libp2p/go-libp2p-gostream v0.5.0/go.mod h1:rXrb0CqfcRRxa7m3RSKORQiKiWgk3IPeXWda66ZXKsA=
+github.com/libp2p/go-libp2p-http v0.4.0 h1:V+f9Rhe/8GkColmXoyJyA0NVsN9F3TCLZgW2hwjoX5w=
+github.com/libp2p/go-libp2p-http v0.4.0/go.mod h1:92tmLGrlBliQFDlZRpBXT3BJM7rGFONy0vsNrG/bMPg=
 github.com/libp2p/go-libp2p-record v0.2.0 h1:oiNUOCWno2BFuxt3my4i1frNrt7PerzB3queqa1NkQ0=
 github.com/libp2p/go-libp2p-record v0.2.0/go.mod h1:I+3zMkvvg5m2OcSdoL0KPljyJyvNDFGKX7QdlpYUcwk=
 github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA=

types.go

@@ -7,11 +7,9 @@ import (
 
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-delegated-routing/internal"
-	logging "github.com/ipfs/go-log/v2"
+	"github.com/multiformats/go-multicodec"
 )
 
-var logger = logging.Logger("service/delegatedrouting")
-
 type Time struct{ time.Time }
 
 func (t *Time) MarshalJSON() ([]byte, error) { return internal.MarshalJSONBytes(t.UnixMilli()) }
@@ -186,8 +184,8 @@ func (r *FindProvidersResponse) UnmarshalJSON(b []byte) error {
 		}
 
 		switch readProv.Protocol {
-		case "bitswap":
-			var prov BitswapReadProviderResponse
+		case fmt.Sprintf("%d", multicodec.TransportBitswap):
+			var prov BitswapReadProvider
 			err := json.Unmarshal(readProv.bytes, &prov)
 			if err != nil {
 				return err
@@ -206,12 +204,20 @@ func (r *FindProvidersResponse) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+// avoid stack overflow when unmarshalling
+type tmpUP UnknownProvider
+
 func (u *UnknownProvider) UnmarshalJSON(b []byte) error {
-	err := json.Unmarshal(b, u)
+	tmp := &tmpUP{}
+
+	err := json.Unmarshal(b, tmp)
 	if err != nil {
 		return err
 	}
+
+	u.Protocol = tmp.Protocol
 	u.Bytes = b
+
 	return nil
 }
 

types_bitswap.go

@@ -14,7 +14,7 @@ import (
 	"github.com/multiformats/go-multibase"
 )
 
-type BitswapReadProviderResponse struct {
+type BitswapReadProvider struct {
 	Protocol string
 	ID       peer.ID
 	Addrs    []multiaddr.Multiaddr

types_test.go

@@ -4,11 +4,17 @@ import (
 	"encoding/json"
 	"fmt"
 	"testing"
+
+	"github.com/libp2p/go-libp2p/core/peer"
 )
 
+// TODO: do something
 func TestThing(t *testing.T) {
-	r := BitswapReadProviderRecord{
-		TransferProtocol: TransferProtocol{Protocol: "proto"},
+
+	r := BitswapReadProvider{
+		Protocol: "proto",
+		ID:       peer.NewPeerRecord().PeerID,
+		Addrs:    peer.NewPeerRecord().Addrs,
 	}
 	b, err := json.Marshal(r)
 	if err != nil {