Add tests that PosInfo() is getting set.

License: MIT
Signed-off-by: Kevin Atkinson <k@kevina.org>

core/coreunix/add_test.go

@@ -2,20 +2,26 @@ package coreunix
 
 import (
 	"bytes"
+	"context"
 	"io"
 	"io/ioutil"
+	"math/rand"
+	"os"
 	"testing"
 	"time"
 
+	"github.com/ipfs/go-ipfs/blocks"
+	"github.com/ipfs/go-ipfs/blocks/blockstore"
+	"github.com/ipfs/go-ipfs/blockservice"
 	"github.com/ipfs/go-ipfs/commands/files"
 	"github.com/ipfs/go-ipfs/core"
 	dag "github.com/ipfs/go-ipfs/merkledag"
 	"github.com/ipfs/go-ipfs/pin/gc"
 	"github.com/ipfs/go-ipfs/repo"
 	"github.com/ipfs/go-ipfs/repo/config"
+	pi "github.com/ipfs/go-ipfs/thirdparty/posinfo"
 	"github.com/ipfs/go-ipfs/thirdparty/testutil"
 
-	"context"
 	cid "gx/ipfs/QmXUuRadqDq5BuFWzVU6VuKaSjTcNm1gNCtLvvP1TJCW4z/go-cid"
 )
 
@@ -162,3 +168,111 @@ func TestAddGCLive(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func testAddWPosInfo(t *testing.T, rawLeaves bool) {
+	r := &repo.Mock{
+		C: config.Config{
+			Identity: config.Identity{
+				PeerID: "Qmfoo", // required by offline node
+			},
+		},
+		D: testutil.ThreadSafeCloserMapDatastore(),
+	}
+	node, err := core.NewNode(context.Background(), &core.BuildCfg{Repo: r})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	bs := &testBlockstore{GCBlockstore: node.Blockstore, expectedPath: "/tmp/foo.txt", t: t}
+	bserv := blockservice.New(bs, node.Exchange)
+	dserv := dag.NewDAGService(bserv)
+	adder, err := NewAdder(context.Background(), node.Pinning, bs, dserv)
+	if err != nil {
+		t.Fatal(err)
+	}
+	adder.Out = make(chan interface{})
+	adder.Progress = true
+	adder.RawLeaves = rawLeaves
+
+	data := make([]byte, 5*1024*1024)
+	rand.New(rand.NewSource(2)).Read(data) // Rand.Read never returns an error
+	fileData := ioutil.NopCloser(bytes.NewBuffer(data))
+	fileInfo := dummyFileInfo{"foo.txt", int64(len(data)), time.Now()}
+	file := files.NewReaderFile("foo.txt", "/tmp/foo.txt", fileData, &fileInfo)
+
+	go func() {
+		defer close(adder.Out)
+		err = adder.AddFile(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}()
+	for _ = range adder.Out {
+	}
+
+	if bs.countAtOffsetZero != 2 {
+		t.Fatal("expected 2 blocks with an offset at zero (one root and one leafh), got", bs.countAtOffsetZero)
+	}
+	if bs.countAtOffsetNonZero != 19 {
+		// note: the exact number will depend on the size and the sharding algo. used
+		t.Fatal("expected 19 blocks with an offset > 0, got", bs.countAtOffsetNonZero)
+	}
+}
+
+func TestAddWPosInfo(t *testing.T) {
+	testAddWPosInfo(t, false)
+}
+
+func TestAddWPosInfoAndRawLeafs(t *testing.T) {
+	testAddWPosInfo(t, true)
+}
+
+
+type testBlockstore struct {
+	blockstore.GCBlockstore
+	expectedPath         string
+	t                    *testing.T
+	countAtOffsetZero    int
+	countAtOffsetNonZero int
+}
+
+func (bs *testBlockstore) Put(block blocks.Block) error {
+	bs.CheckForPosInfo(block)
+	return bs.GCBlockstore.Put(block)
+}
+
+func (bs *testBlockstore) PutMany(blocks []blocks.Block) error {
+	for _, blk := range blocks {
+		bs.CheckForPosInfo(blk)
+	}
+	return bs.GCBlockstore.PutMany(blocks)
+}
+
+func (bs *testBlockstore) CheckForPosInfo(block blocks.Block) error {
+	fsn, ok := block.(*pi.FilestoreNode)
+	if ok {
+		posInfo := fsn.PosInfo
+		if posInfo.FullPath != bs.expectedPath {
+			bs.t.Fatal("PosInfo does not have the expected path")
+		}
+		if posInfo.Offset == 0 {
+			bs.countAtOffsetZero += 1
+		} else {
+			bs.countAtOffsetNonZero += 1
+		}
+	}
+	return nil
+}
+
+type dummyFileInfo struct {
+	name    string
+	size    int64
+	modTime time.Time
+}
+
+func (fi *dummyFileInfo) Name() string       { return fi.name }
+func (fi *dummyFileInfo) Size() int64        { return fi.size }
+func (fi *dummyFileInfo) Mode() os.FileMode  { return 0 }
+func (fi *dummyFileInfo) ModTime() time.Time { return fi.modTime }
+func (fi *dummyFileInfo) IsDir() bool        { return false }
+func (fi *dummyFileInfo) Sys() interface{}   { return nil }