LocalStore

swarm/shed/example_store_test.go

@@ -84,7 +84,7 @@ func New(path string) (s *Store, err error) {
 			value = append(b, fields.Data...)
 			return value, nil
 		},
-		DecodeValue: func(value []byte) (e shed.IndexItem, err error) {
+		DecodeValue: func(keyItem shed.IndexItem, value []byte) (e shed.IndexItem, err error) {
 			e.StoreTimestamp = int64(binary.BigEndian.Uint64(value[:8]))
 			e.Data = value[8:]
 			return e, nil
@@ -108,7 +108,7 @@ func New(path string) (s *Store, err error) {
 			binary.BigEndian.PutUint64(b, uint64(fields.AccessTimestamp))
 			return b, nil
 		},
-		DecodeValue: func(value []byte) (e shed.IndexItem, err error) {
+		DecodeValue: func(keyItem shed.IndexItem, value []byte) (e shed.IndexItem, err error) {
 			e.AccessTimestamp = int64(binary.BigEndian.Uint64(value))
 			return e, nil
 		},
@@ -134,7 +134,7 @@ func New(path string) (s *Store, err error) {
 		EncodeValue: func(fields shed.IndexItem) (value []byte, err error) {
 			return nil, nil
 		},
-		DecodeValue: func(value []byte) (e shed.IndexItem, err error) {
+		DecodeValue: func(keyItem shed.IndexItem, value []byte) (e shed.IndexItem, err error) {
 			return e, nil
 		},
 	})

swarm/shed/index.go

@@ -77,7 +77,7 @@ type Index struct {
 	encodeKeyFunc   func(fields IndexItem) (key []byte, err error)
 	decodeKeyFunc   func(key []byte) (e IndexItem, err error)
 	encodeValueFunc func(fields IndexItem) (value []byte, err error)
-	decodeValueFunc func(value []byte) (e IndexItem, err error)
+	decodeValueFunc func(keyFields IndexItem, value []byte) (e IndexItem, err error)
 }
 
 // IndexFuncs structure defines functions for encoding and decoding
@@ -86,7 +86,7 @@ type IndexFuncs struct {
 	EncodeKey   func(fields IndexItem) (key []byte, err error)
 	DecodeKey   func(key []byte) (e IndexItem, err error)
 	EncodeValue func(fields IndexItem) (value []byte, err error)
-	DecodeValue func(value []byte) (e IndexItem, err error)
+	DecodeValue func(keyFields IndexItem, value []byte) (e IndexItem, err error)
 }
 
 // NewIndex returns a new Index instance with defined name and
@@ -135,7 +135,7 @@ func (f Index) Get(keyFields IndexItem) (out IndexItem, err error) {
 	if err != nil {
 		return out, err
 	}
-	out, err = f.decodeValueFunc(value)
+	out, err = f.decodeValueFunc(keyFields, value)
 	if err != nil {
 		return out, err
 	}
@@ -210,15 +210,15 @@ func (f Index) IterateAll(fn IndexIterFunc) (err error) {
 		if key[0] != f.prefix[0] {
 			break
 		}
-		keyIndexItem, err := f.decodeKeyFunc(key)
+		keyItem, err := f.decodeKeyFunc(key)
 		if err != nil {
 			return err
 		}
-		valueIndexItem, err := f.decodeValueFunc(it.Value())
+		valueItem, err := f.decodeValueFunc(keyItem, it.Value())
 		if err != nil {
 			return err
 		}
-		stop, err := fn(keyIndexItem.Merge(valueIndexItem))
+		stop, err := fn(keyItem.Merge(valueItem))
 		if err != nil {
 			return err
 		}
@@ -244,15 +244,15 @@ func (f Index) IterateFrom(start IndexItem, fn IndexIterFunc) (err error) {
 		if key[0] != f.prefix[0] {
 			break
 		}
-		keyIndexItem, err := f.decodeKeyFunc(key)
+		keyItem, err := f.decodeKeyFunc(key)
 		if err != nil {
 			return err
 		}
-		valueIndexItem, err := f.decodeValueFunc(it.Value())
+		valueItem, err := f.decodeValueFunc(keyItem, it.Value())
 		if err != nil {
 			return err
 		}
-		stop, err := fn(keyIndexItem.Merge(valueIndexItem))
+		stop, err := fn(keyItem.Merge(valueItem))
 		if err != nil {
 			return err
 		}

swarm/shed/index_test.go

@@ -42,7 +42,7 @@ var retrievalIndexFuncs = IndexFuncs{
 		value = append(b, fields.Data...)
 		return value, nil
 	},
-	DecodeValue: func(value []byte) (e IndexItem, err error) {
+	DecodeValue: func(keyItem IndexItem, value []byte) (e IndexItem, err error) {
 		e.StoreTimestamp = int64(binary.BigEndian.Uint64(value[:8]))
 		e.Data = value[8:]
 		return e, nil

swarm/storage/localstore/accessor.go

@@ -41,8 +41,8 @@ func (db *DB) Accessor(mode Mode) *Accessor {
 }
 
 // Put uses the underlying DB for the specific mode of update to store the chunk.
-func (u *Accessor) Put(ctx context.Context, ch storage.Chunk) error {
-	return u.db.update(ctx, u.mode, chunkToItem(ch))
+func (u *Accessor) Put(_ context.Context, ch storage.Chunk) error {
+	return u.db.update(u.mode, chunkToItem(ch))
 }
 
 // Get uses the underlying DB for the specific mode of access to get the chunk.

swarm/storage/localstore/accessor_test.go

@@ -19,30 +19,74 @@ package localstore
 import (
 	"bytes"
 	"context"
+	"io/ioutil"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/swarm/storage"
+	"github.com/ethereum/go-ethereum/swarm/storage/mock"
+	"github.com/ethereum/go-ethereum/swarm/storage/mock/mem"
 )
 
 // TestAccessors tests most basic Put and Get functionalities
 // for different accessors.
 func TestAccessors(t *testing.T) {
-	db, cleanupFunc := newTestDB(t)
+	db, cleanupFunc := newTestDB(t, nil)
 	defer cleanupFunc()
 
 	testAccessors(t, db)
 }
 
-// TestAccessors_withRetrievalCompositeIndex tests most basic
+// TestAccessors_useRetrievalCompositeIndex tests most basic
 // Put and Get functionalities for different accessors
 // by using retrieval composite index.
-func TestAccessors_withRetrievalCompositeIndex(t *testing.T) {
-	db, cleanupFunc := newTestDB(t, WithRetrievalCompositeIndex(true))
+func TestAccessors_useRetrievalCompositeIndex(t *testing.T) {
+	db, cleanupFunc := newTestDB(t, &Options{UseRetrievalCompositeIndex: true})
 	defer cleanupFunc()
 
 	testAccessors(t, db)
 }
 
+// TestAccessors_mockStore tests most basic Put and Get
+// functionalities for different accessors with the mock store
+// as the storage for chunk data.
+func TestAccessors_mockStore(t *testing.T) {
+	globalStore := mem.NewGlobalStore()
+
+	addr := common.BytesToAddress(make([]byte, 32))
+
+	db, cleanupFunc := newTestDB(t, &Options{
+		MockStore: globalStore.NewNodeStore(addr),
+	})
+	defer cleanupFunc()
+
+	testAccessors(t, db)
+
+	// testAccessors leaves 5 chunks in global store
+	checkGlobalStoreChunkCount(t, globalStore, 5)
+}
+
+// TestAccessors_mockStore_useRetrievalCompositeIndex tests
+// most basic Put and Get functionalities for different accessors
+// with the mock store as the storage for chunk data and by using
+// retrieval composite index.
+func TestAccessors_mockStore_useRetrievalCompositeIndex(t *testing.T) {
+	globalStore := mem.NewGlobalStore()
+
+	addr := common.BytesToAddress(make([]byte, 32))
+
+	db, cleanupFunc := newTestDB(t, &Options{
+		MockStore:                  globalStore.NewNodeStore(addr),
+		UseRetrievalCompositeIndex: true,
+	})
+	defer cleanupFunc()
+
+	testAccessors(t, db)
+
+	// testAccessors leaves 5 chunks in global store
+	checkGlobalStoreChunkCount(t, globalStore, 5)
+}
+
 // testAccessors tests most basic Put and Get functionalities
 // for different accessors. This test validates that the chunk
 // is retrievable from the database, not if all indexes are set
@@ -51,7 +95,6 @@ func testAccessors(t *testing.T, db *DB) {
 	for _, m := range []Mode{
 		ModeSyncing,
 		ModeUpload,
-		ModeRequest,
 	} {
 		t.Run(ModeName(m), func(t *testing.T) {
 			a := db.Accessor(m)
@@ -92,29 +135,34 @@ func testAccessors(t *testing.T, db *DB) {
 		}
 	})
 
-	// Access mode is a special as it does not store the chunk
-	// in the database.
-	t.Run(ModeName(modeAccess), func(t *testing.T) {
-		a := db.Accessor(ModeUpload)
+	// Request and access modes are special as they do not store
+	// chunks in the database.
+	for _, m := range []Mode{
+		ModeRequest,
+		modeAccess,
+	} {
+		t.Run(ModeName(m), func(t *testing.T) {
+			a := db.Accessor(ModeUpload)
 
-		want := generateRandomChunk()
+			want := generateRandomChunk()
 
-		// first put a random chunk to the database
-		err := a.Put(context.Background(), want)
-		if err != nil {
-			t.Fatal(err)
-		}
+			// first put a random chunk to the database
+			err := a.Put(context.Background(), want)
+			if err != nil {
+				t.Fatal(err)
+			}
 
-		a = db.Accessor(modeAccess)
+			a = db.Accessor(ModeRequest)
 
-		got, err := a.Get(context.Background(), want.Address())
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !bytes.Equal(got.Data(), want.Data()) {
-			t.Errorf("got chunk data %x, want %x", got.Data(), want.Data())
-		}
-	})
+			got, err := a.Get(context.Background(), want.Address())
+			if err != nil {
+				t.Fatal(err)
+			}
+			if !bytes.Equal(got.Data(), want.Data()) {
+				t.Errorf("got chunk data %x, want %x", got.Data(), want.Data())
+			}
+		})
+	}
 
 	// Removal mode is a special case as it removes the chunk
 	// from the database.
@@ -153,3 +201,17 @@ func testAccessors(t *testing.T, db *DB) {
 		}
 	})
 }
+
+// checkGlobalStoreChunkCount counts the number of chunks
+// in a global mock store to validate it against the expected value.
+func checkGlobalStoreChunkCount(t *testing.T, s mock.ImportExporter, want int) {
+	t.Helper()
+
+	n, err := s.Export(ioutil.Discard)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if n != want {
+		t.Errorf("got %v chunks, want %v", n, want)
+	}
+}