fix ipfs cat

Author: cryptix

flake.lock

@@ -11,14 +11,15 @@ import (
 	"io"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"strings"
 	"testing"
 
 	tassert "github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestParseMultiAddr(t *testing.T) {
+func TestIPFSParseMultiAddr(t *testing.T) {
 	tassert := tassert.New(t)
 
 	tests := []struct {
@@ -75,6 +76,9 @@ func TestParseMultiAddr(t *testing.T) {
 
 // Mock IPFS HTTP API server for testing
 func setupMockIPFSServer() *httptest.Server {
+	// Content store to maintain uploaded files
+	contentStore := make(map[string][]byte)
+
 	mux := http.NewServeMux()
 
 	// Mock /api/v0/add endpoint
@@ -111,6 +115,9 @@ func setupMockIPFSServer() *httptest.Server {
 			mockCID = mockCID[:46]
 		}
 
+		// Store content for later retrieval
+		contentStore[mockCID] = content
+
 		// Return IPFS add response format
 		w.Header().Set("Content-Type", "application/json")
 		fmt.Fprintf(w, `{"Name":"","Hash":"%s","Size":"%d"}`, mockCID, len(content))
@@ -129,13 +136,13 @@ func setupMockIPFSServer() *httptest.Server {
 			return
 		}
 
-		// Return mock content based on CID
-		if strings.HasPrefix(cid, "Qm") {
-			// Extract original content from mock CID (simplified)
+		// Return stored content based on CID
+		if content, exists := contentStore[cid]; exists {
 			w.Header().Set("Content-Type", "application/octet-stream")
-			fmt.Fprintf(w, "mock-content-for-%s", cid)
+			w.Header().Set("Content-Length", strconv.Itoa(len(content)))
+			w.Write(content)
 		} else {
-			http.Error(w, "Invalid CID", http.StatusBadRequest)
+			http.Error(w, "Content not found", http.StatusNotFound)
 		}
 	})
 
@@ -153,7 +160,7 @@ func setupMockIPFSServer() *httptest.Server {
 	return httptest.NewServer(mux)
 }
 
-func TestIPFSClientCompatibility(t *testing.T) {
+func TestIPFSHTTPClientCompatibility(t *testing.T) {
 	// Setup mock IPFS server
 	server := setupMockIPFSServer()
 	defer server.Close()
@@ -178,15 +185,21 @@ func TestIPFSClientCompatibility(t *testing.T) {
 	})
 
 	t.Run("Cat operation retrieves content", func(t *testing.T) {
-		testCID := "QmTestCID12345"
+		// First upload content to get a valid CID
+		testData := []byte("test data for cat operation")
+		reader := bytes.NewReader(testData)
+
+		uploadedCID, err := client.Add(ctx, reader)
+		require.NoError(t, err)
 
-		reader, err := client.Cat(ctx, testCID)
+		// Now retrieve it with Cat
+		catReader, err := client.Cat(ctx, uploadedCID)
 		require.NoError(t, err)
-		defer reader.Close()
+		defer catReader.Close()
 
-		content, err := io.ReadAll(reader)
+		content, err := io.ReadAll(catReader)
 		require.NoError(t, err)
-		tassert.Contains(t, string(content), testCID)
+		tassert.Equal(t, testData, content, "Cat should return original content")
 	})
 
 	t.Run("SwarmPeers returns peer list", func(t *testing.T) {
@@ -198,7 +211,7 @@ func TestIPFSClientCompatibility(t *testing.T) {
 	})
 }
 
-func TestLightweightClientCompatibility(t *testing.T) {
+func TestIPFSLightweightClientCompatibility(t *testing.T) {
 	// Setup mock IPFS server
 	server := setupMockIPFSServer()
 	defer server.Close()
@@ -223,18 +236,21 @@ func TestLightweightClientCompatibility(t *testing.T) {
 	})
 
 	t.Run("Get with IPFSPath returns IPFSNode", func(t *testing.T) {
-		testCID := "QmTestCID67890"
-		path, err := NewIPFSPath(testCID)
+		// First upload content to get a valid CID
+		testData := []byte("test data for get operation")
+		uploadFile := NewIPFSFileFromBytes(testData)
+		uploadedPath, err := client.Unixfs().Add(ctx, uploadFile)
 		require.NoError(t, err)
 
-		node, err := client.Unixfs().Get(ctx, path)
+		// Now retrieve it
+		node, err := client.Unixfs().Get(ctx, uploadedPath)
 		require.NoError(t, err)
 		defer node.Close()
 
 		var buf bytes.Buffer
 		_, err = buf.ReadFrom(node)
 		require.NoError(t, err)
-		tassert.Contains(t, buf.String(), testCID)
+		tassert.Equal(t, testData, buf.Bytes(), "Retrieved content should match uploaded content")
 	})
 
 	t.Run("Swarm peers returns string slice", func(t *testing.T) {
@@ -245,7 +261,7 @@ func TestLightweightClientCompatibility(t *testing.T) {
 	})
 }
 
-func TestBlobUploadResponseFormat(t *testing.T) {
+func TestIPFSBlobUploadResponseFormat(t *testing.T) {
 	// This test verifies the blob upload response format matches expectations
 	// Based on the test failure: expected '/ipfs/CID' but got 'CID'
 
@@ -329,7 +345,7 @@ func TestIPFSFileOperations(t *testing.T) {
 }
 
 // Benchmark tests to ensure performance is acceptable
-func BenchmarkIPFSClientAdd(b *testing.B) {
+func BenchmarkIPFSHTTPClientAdd(b *testing.B) {
 	server := setupMockIPFSServer()
 	defer server.Close()
 
@@ -348,7 +364,7 @@ func BenchmarkIPFSClientAdd(b *testing.B) {
 	}
 }
 
-func BenchmarkLightweightClientAdd(b *testing.B) {
+func BenchmarkIPFSLightweightClientAdd(b *testing.B) {
 	server := setupMockIPFSServer()
 	defer server.Close()
 

ipfs_compatibility_test.go

@@ -13,6 +13,7 @@ import (
 	"io"
 	"mime/multipart"
 	"net/http"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -159,6 +160,42 @@ func (c *IPFSHTTPClient) Cat(ctx context.Context, cid string) (io.ReadCloser, er
 	return resp.Body, nil
 }
 
+// CatWithSize retrieves data from IPFS by CID and attempts to get size from Content-Length header
+func (c *IPFSHTTPClient) CatWithSize(ctx context.Context, cid string) (io.ReadCloser, int64, error) {
+	// Create request
+	req, err := http.NewRequestWithContext(ctx, "POST", c.baseURL+"/api/v0/cat", nil)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Add CID as query parameter
+	q := req.URL.Query()
+	q.Add("arg", cid)
+	req.URL.RawQuery = q.Encode()
+
+	// Execute request
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to execute request: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		return nil, 0, fmt.Errorf("IPFS cat failed with status %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Try to get size from Content-Length header
+	var size int64 = -1 // -1 indicates unknown size
+	if contentLength := resp.Header.Get("Content-Length"); contentLength != "" {
+		if parsedSize, err := strconv.ParseInt(contentLength, 10, 64); err == nil {
+			size = parsedSize
+		}
+	}
+
+	return resp.Body, size, nil
+}
+
 // SwarmPeersResponse represents a peer in the swarm
 type SwarmPeersResponse struct {
 	Peers []struct {
@@ -308,11 +345,11 @@ func (n *IPFSNode) Close() error {
 
 // Get retrieves a file from IPFS
 func (u *UnixfsAPI) Get(ctx context.Context, path *IPFSPath) (*IPFSNode, error) {
-	reader, err := u.client.Cat(ctx, path.cid)
+	reader, size, err := u.client.CatWithSize(ctx, path.cid)
 	if err != nil {
 		return nil, err
 	}
-	return &IPFSNode{reader: reader}, nil
+	return &IPFSNode{reader: reader, size: size}, nil
 }
 
 // SwarmAPI provides swarm operations

ipfs_http_client.go

@@ -152,14 +152,9 @@ func uploadBlobHandleFunc(_ uint, r *Relay) func(http.ResponseWriter, *http.Requ
 	}
 }
 
-func ipfsCatHandleFunc() func(http.ResponseWriter, *http.Request) {
+func ipfsCatHandlerWithClient(client *LightweightIPFSClient) func(http.ResponseWriter, *http.Request) {
 	return func(w http.ResponseWriter, req *http.Request) {
 		ctx := req.Context()
-		client, err := getIpfsClient(ctx, 0, nil)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
 
 		ipfsPath, err := NewIPFSPath(req.URL.Path)
 		if err != nil {
@@ -184,14 +179,31 @@ func ipfsCatHandleFunc() func(http.ResponseWriter, *http.Request) {
 		}
 
 		headers := w.Header()
-		headers.Set("Content-Length", strconv.Itoa(int(sz)))
+		// Only set Content-Length if size is known (>= 0)
+		if sz >= 0 {
+			headers.Set("Content-Length", strconv.Itoa(int(sz)))
+		}
 		// ipfs blobs never change
 		headers.Set("Cache-Control", "public, max-age=29030400, immutable")
 		w.WriteHeader(http.StatusOK)
 		_, _ = io.Copy(w, node)
 	}
 }
 
+func ipfsCatHandleFunc() func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		ctx := req.Context()
+		client, err := getIpfsClient(ctx, 0, nil)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		handler := ipfsCatHandlerWithClient(client)
+		handler(w, req)
+	}
+}
+
 type savedItem struct {
 	cid      combinedID
 	cborHash [32]byte