blocks_test.go 2.6 KB
Newer Older
1 2 3 4 5
package blockservice

import (
	"bytes"
	"testing"
Jeromy's avatar
Jeromy committed
6 7
	"time"

Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
8
	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
9
	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
10
	dssync "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
11
	blocks "github.com/jbenet/go-ipfs/blocks"
12
	blockstore "github.com/jbenet/go-ipfs/blocks/blockstore"
13
	bitswap "github.com/jbenet/go-ipfs/exchange/bitswap"
14
	tn "github.com/jbenet/go-ipfs/exchange/bitswap/testnet"
15
	offline "github.com/jbenet/go-ipfs/exchange/offline"
16
	"github.com/jbenet/go-ipfs/routing/mock"
17 18 19 20 21
	u "github.com/jbenet/go-ipfs/util"
)

func TestBlocks(t *testing.T) {
	d := ds.NewMapDatastore()
22 23
	tsds := dssync.MutexWrap(d)
	bs, err := New(blockstore.NewBlockstore(tsds), offline.Exchange())
24 25 26 27 28
	if err != nil {
		t.Error("failed to construct block service", err)
		return
	}

Jeromy's avatar
Jeromy committed
29
	b := blocks.NewBlock([]byte("beep boop"))
Juan Batiz-Benet's avatar
Juan Batiz-Benet committed
30
	h := u.Hash([]byte("beep boop"))
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
	if !bytes.Equal(b.Multihash, h) {
		t.Error("Block Multihash and data multihash not equal")
	}

	if b.Key() != u.Key(h) {
		t.Error("Block key and data multihash key not equal")
	}

	k, err := bs.AddBlock(b)
	if err != nil {
		t.Error("failed to add block to BlockService", err)
		return
	}

	if k != b.Key() {
		t.Error("returned key is not equal to block key", err)
	}

Jeromy's avatar
Jeromy committed
49 50
	ctx, _ := context.WithTimeout(context.TODO(), time.Second*5)
	b2, err := bs.GetBlock(ctx, b.Key())
51 52 53 54 55 56 57 58 59 60 61 62 63
	if err != nil {
		t.Error("failed to retrieve block from BlockService", err)
		return
	}

	if b.Key() != b2.Key() {
		t.Error("Block keys not equal.")
	}

	if !bytes.Equal(b.Data, b2.Data) {
		t.Error("Block data is not equal.")
	}
}
64 65

func TestGetBlocks(t *testing.T) {
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
	net := tn.VirtualNetwork()
	rs := mock.VirtualRoutingServer()
	sg := bitswap.NewSessionGenerator(net, rs)
	bg := bitswap.NewBlockGenerator()

	instances := sg.Instances(4)
	blks := bg.Blocks(50)
	// TODO: verify no duplicates

	var servs []*BlockService
	for _, i := range instances {
		bserv, err := New(i.Blockstore, i.Exchange)
		if err != nil {
			t.Fatal(err)
		}
		servs = append(servs, bserv)
	}

	var keys []u.Key
	for _, blk := range blks {
		keys = append(keys, blk.Key())
		servs[0].AddBlock(blk)
	}

	for i := 1; i < 4; i++ {
		ctx, _ := context.WithTimeout(context.TODO(), time.Second*5)
		out := servs[i].GetBlocks(ctx, keys)
		gotten := make(map[u.Key]*blocks.Block)
		for blk := range out {
			if _, ok := gotten[blk.Key()]; ok {
				t.Fatal("Got duplicate block!")
			}
			gotten[blk.Key()] = blk
		}
		if len(gotten) != len(blks) {
			t.Fatalf("Didnt get enough blocks back: %d/%d", len(gotten), len(blks))
		}
	}
104
}