abstract out testStore + randomChunks into common_test

bzz/common_test.go

@@ -0,0 +1,97 @@
+package bzz
+
+import (
+	"crypto/rand"
+	"testing"
+)
+
+func randomChunks(l int64, branches int64, chunkC chan *Chunk) (key Key, errC chan error) {
+	chunker := &TreeChunker{
+		Branches: branches,
+	}
+	chunker.Init()
+	key = make([]byte, 32)
+	b := make([]byte, l)
+	_, err := rand.Read(b)
+	if err != nil {
+		panic("no rand")
+	}
+	errC = chunker.Split(key, NewChunkReaderFromBytes(b), chunkC)
+	return
+}
+
+func testStore(m ChunkStore, l int64, branches int64, t *testing.T) {
+
+	chunkC := make(chan *Chunk)
+	key, errC := randomChunks(l, branches, chunkC)
+
+SPLIT:
+	for {
+		select {
+		case chunk := <-chunkC:
+			chunk.Data = make([]byte, chunk.Reader.Size())
+			chunk.Reader.ReadAt(chunk.Data, 0)
+			m.Put(chunk)
+
+		case err, ok := <-errC:
+			if err != nil {
+				t.Errorf("Chunker error: %v", err)
+				return
+			}
+			if !ok {
+				t.Logf("quitting SPLIT loop\n")
+				break SPLIT
+			}
+		}
+	}
+
+	chunker := &TreeChunker{
+		Branches: branches,
+	}
+	chunker.Init()
+	chunkC = make(chan *Chunk)
+	var r LazySectionReader
+	r, errC = chunker.Join(key, chunkC)
+
+	quit := make(chan bool)
+
+	go func() {
+	JOIN:
+		for {
+			select {
+			case chunk := <-chunkC:
+				go func() {
+					storedChunk, err := m.Get(chunk.Key)
+					if err == notFound {
+						t.Errorf("Chunk not found: %v", err)
+						return
+					}
+					if err != nil {
+						t.Errorf("GET error: %v", err)
+						return
+					}
+					chunk.Reader = NewChunkReaderFromBytes(storedChunk.Data)
+					chunk.Size = storedChunk.Size
+					close(chunk.C)
+				}()
+			case err, ok := <-errC:
+				if err != nil {
+					t.Errorf("Chunker error: %v", err)
+					return
+				}
+				if !ok {
+					break JOIN
+				}
+			case <-quit:
+				break JOIN
+			}
+		}
+	}()
+
+	b := make([]byte, l)
+	n, err := r.ReadAt(b, 0)
+	if err != nil {
+		t.Errorf("read error (%v/%v) %v", n, l, err)
+		close(quit)
+	}
+}

bzz/dbstore_test.go

@@ -15,78 +15,7 @@ func testDbStore(l int64, branches int64, t *testing.T) {
 		panic("no dbStore")
 	}
 	defer m.close()
-	chunkC := make(chan *Chunk)
+	testStore(m, l, branches, t)
-	key, errC := randomChunks(l, branches, chunkC)
-
-SPLIT:
-	for {
-		select {
-		case chunk := <-chunkC:
-			chunk.Data = make([]byte, chunk.Reader.Size())
-			chunk.Reader.ReadAt(chunk.Data, 0)
-			m.Put(chunk)
-
-		case err, ok := <-errC:
-			if err != nil {
-				t.Errorf("Chunker error: %v", err)
-				return
-			}
-			if !ok {
-				t.Logf("quitting SPLIT loop\n")
-				break SPLIT
-			}
-		}
-	}
-
-	chunker := &TreeChunker{
-		Branches: branches,
-	}
-	chunker.Init()
-	chunkC = make(chan *Chunk)
-	var r LazySectionReader
-	r, errC = chunker.Join(key, chunkC)
-
-	quit := make(chan bool)
-
-	go func() {
-	JOIN:
-		for {
-			select {
-			case chunk := <-chunkC:
-				go func() {
-					storedChunk, err := m.Get(chunk.Key)
-					if err == notFound {
-						t.Errorf("Chunk not found: %v", err)
-						return
-					}
-					if err != nil {
-						t.Errorf("GET error: %v", err)
-						return
-					}
-					chunk.Reader = NewChunkReaderFromBytes(storedChunk.Data)
-					chunk.Size = storedChunk.Size
-					close(chunk.C)
-				}()
-			case err, ok := <-errC:
-				if err != nil {
-					t.Errorf("Chunker error: %v", err)
-					return
-				}
-				if !ok {
-					break JOIN
-				}
-			case <-quit:
-				break JOIN
-			}
-		}
-	}()
-
-	b := make([]byte, l)
-	n, err := r.ReadAt(b, 0)
-	if err != nil {
-		t.Errorf("read error (%v/%v) %v", n, l, err)
-		close(quit)
-	}
 }
 
 func TestDbStore128_10000(t *testing.T) {

bzz/dpa.go

@@ -56,7 +56,7 @@ type Chunk struct {
 
 type ChunkStore interface {
 	Put(*Chunk) // effectively there is no error even if there is no error
-	Get() (*Chunk, error)
+	Get(Key) (*Chunk, error)
 }
 
 func (self *DPA) Retrieve(key Key) (data LazySectionReader, err error) {
@@ -151,7 +151,7 @@ func (self *DPA) retrieveLoop() {
 		for chunk := range self.retrieveC {
 			go func() {
 				for _, store := range self.Stores {
-					if _, err := store.Get(); err != nil { // no waiting/blocking here
+					if _, err := store.Get(chunk.Key); err != nil { // no waiting/blocking here
 						dpaLogger.DebugDetailf("%v retrieving chunk %x: %v", store, chunk.Key, err)
 					}
 				}

bzz/memstore_test.go

@@ -1,101 +1,14 @@
 package bzz
 
 import (
-	"crypto/rand"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/bzz/test"
 )
 
-func randomChunks(l int64, branches int64, chunkC chan *Chunk) (key Key, errC chan error) {
-	chunker := &TreeChunker{
-		Branches: branches,
-	}
-	chunker.Init()
-	key = make([]byte, 32)
-	b := make([]byte, l)
-	_, err := rand.Read(b)
-	if err != nil {
-		panic("no rand")
-	}
-	errC = chunker.Split(key, NewChunkReaderFromBytes(b), chunkC)
-	return
-}
-
 func testMemStore(l int64, branches int64, t *testing.T) {
 	m := newMemStore(nil)
-	chunkC := make(chan *Chunk)
+	testStore(m, l, branches, t)
-	key, errC := randomChunks(l, branches, chunkC)
-
-SPLIT:
-	for {
-		select {
-		case chunk := <-chunkC:
-			chunk.Data = make([]byte, chunk.Reader.Size())
-			chunk.Reader.ReadAt(chunk.Data, 0)
-			m.Put(chunk)
-
-		case err, ok := <-errC:
-			if err != nil {
-				t.Errorf("Chunker error: %v", err)
-				return
-			}
-			if !ok {
-				t.Logf("quitting SPLIT loop\n")
-				break SPLIT
-			}
-		}
-	}
-
-	chunker := &TreeChunker{
-		Branches: branches,
-	}
-	chunker.Init()
-	chunkC = make(chan *Chunk)
-	var r LazySectionReader
-	r, errC = chunker.Join(key, chunkC)
-
-	quit := make(chan bool)
-
-	go func() {
-	JOIN:
-		for {
-			select {
-			case chunk := <-chunkC:
-				go func() {
-					storedChunk, err := m.Get(chunk.Key)
-					if err == notFound {
-						t.Errorf("Chunk not found: %v", err)
-						return
-					}
-					if err != nil {
-						t.Errorf("GET error: %v", err)
-						return
-					}
-					chunk.Reader = NewChunkReaderFromBytes(storedChunk.Data)
-					chunk.Size = storedChunk.Size
-					close(chunk.C)
-				}()
-			case err, ok := <-errC:
-				if err != nil {
-					t.Errorf("Chunker error: %v", err)
-					return
-				}
-				if !ok {
-					break JOIN
-				}
-			case <-quit:
-				break JOIN
-			}
-		}
-	}()
-
-	b := make([]byte, l)
-	n, err := r.ReadAt(b, 0)
-	if err != nil {
-		t.Errorf("read error (%v/%v) %v", n, l, err)
-		close(quit)
-	}
 }
 
 func TestMemStore128_10000(t *testing.T) {