seaweedfs/weed/filer/leveldb2/leveldb2_store_test.go

package leveldb

import (
	"context"
	"math"
	"strings"
	"testing"

	"github.com/seaweedfs/seaweedfs/weed/filer"
	"github.com/seaweedfs/seaweedfs/weed/pb"
	"github.com/seaweedfs/seaweedfs/weed/util"
)

func TestCreateAndFind(t *testing.T) {
	testFiler := filer.NewFiler(pb.ServerDiscovery{}, nil, "", "", "", "", "", 255, nil)
	dir := t.TempDir()
	store := &LevelDB2Store{}
	store.initialize(dir, 2)
	testFiler.SetStore(store)

	fullpath := util.FullPath("/home/chris/this/is/one/file1.jpg")

	ctx := context.Background()

	entry1 := &filer.Entry{
		FullPath: fullpath,
		Attr: filer.Attr{
			Mode: 0440,
			Uid:  1234,
			Gid:  5678,
		},
	}

	if err := testFiler.CreateEntry(ctx, entry1, nil, false, false, nil, false, testFiler.MaxFilenameLength); err != nil {
		t.Errorf("create entry %v: %v", entry1.FullPath, err)
		return
	}

	entry, err := testFiler.FindEntry(ctx, fullpath)

	if err != nil {
		t.Errorf("find entry: %v", err)
		return
	}

	if entry.FullPath != entry1.FullPath {
		t.Errorf("find wrong entry: %v", entry.FullPath)
		return
	}

	// checking one upper directory
	entries, _, _ := testFiler.ListDirectoryEntries(ctx, util.FullPath("/home/chris/this/is/one"), "", false, 100, "", "", "")
	if len(entries) != 1 {
		t.Errorf("list entries count: %v", len(entries))
		return
	}

	// checking one upper directory
	entries, _, _ = testFiler.ListDirectoryEntries(ctx, util.FullPath("/"), "", false, 100, "", "", "")
	if len(entries) != 1 {
		t.Errorf("list entries count: %v", len(entries))
		return
	}

}

type fakeConfiguration map[string]interface{}

func (c fakeConfiguration) GetString(key string) string {
	value, _ := c[key].(string)
	return value
}

func (c fakeConfiguration) GetBool(key string) bool {
	value, _ := c[key].(bool)
	return value
}

func (c fakeConfiguration) GetInt(key string) int {
	value, _ := c[key].(int)
	return value
}

func (c fakeConfiguration) GetStringSlice(key string) []string {
	value, _ := c[key].([]string)
	return value
}

func (c fakeConfiguration) SetDefault(key string, value interface{}) {
	if _, found := c[key]; !found {
		c[key] = value
	}
}

func TestInitializeOptions(t *testing.T) {
	store := &LevelDB2Store{}
	if err := store.Initialize(fakeConfiguration{
		"leveldb2.dir":                      t.TempDir(),
		"leveldb2.block_cache_size_mb":      64,
		"leveldb2.write_buffer_size_mb":     32,
		"leveldb2.block_size_kb":            16,
		"leveldb2.compaction_table_size_mb": 8,
	}, "leveldb2."); err != nil {
		t.Fatalf("initialize: %v", err)
	}
	defer store.Shutdown()

	opts := store.buildOptions()
	if opts.BlockCacheCapacity != 64*1024*1024 {
		t.Errorf("block cache %d, want 64MiB", opts.BlockCacheCapacity)
	}
	if opts.WriteBuffer != 32*1024*1024 {
		t.Errorf("write buffer %d, want 32MiB", opts.WriteBuffer)
	}
	if opts.BlockSize != 16*1024 {
		t.Errorf("block size %d, want 16KiB", opts.BlockSize)
	}
	if opts.CompactionTableSize != 8*1024*1024 {
		t.Errorf("compaction table size %d, want 8MiB", opts.CompactionTableSize)
	}
}

func TestInitializeDefaultOptions(t *testing.T) {
	store := &LevelDB2Store{}
	if err := store.Initialize(fakeConfiguration{
		"leveldb2.dir":                  t.TempDir(),
		"leveldb2.block_cache_size_mb":  -1,
		"leveldb2.write_buffer_size_mb": 0,
	}, "leveldb2."); err != nil {
		t.Fatalf("initialize: %v", err)
	}
	defer store.Shutdown()

	opts := store.buildOptions()
	if opts.BlockCacheCapacity != 32*1024*1024 {
		t.Errorf("block cache %d, want the 32MiB default", opts.BlockCacheCapacity)
	}
	if opts.WriteBuffer != 16*1024*1024 {
		t.Errorf("write buffer %d, want the 16MiB default", opts.WriteBuffer)
	}
}

func TestInitializeRejectsOversizedOption(t *testing.T) {
	store := &LevelDB2Store{}
	err := store.Initialize(fakeConfiguration{
		"leveldb2.dir":                  t.TempDir(),
		"leveldb2.write_buffer_size_mb": math.MaxInt/(1<<20) + 1,
	}, "leveldb2.")
	if err == nil || !strings.Contains(err.Error(), "write_buffer_size_mb") {
		t.Fatalf("expected overflow rejection, got %v", err)
	}
}

func TestEmptyRoot(t *testing.T) {
	testFiler := filer.NewFiler(pb.ServerDiscovery{}, nil, "", "", "", "", "", 255, nil)
	dir := t.TempDir()
	store := &LevelDB2Store{}
	store.initialize(dir, 2)
	testFiler.SetStore(store)

	ctx := context.Background()

	// checking one upper directory
	entries, _, err := testFiler.ListDirectoryEntries(ctx, util.FullPath("/"), "", false, 100, "", "", "")
	if err != nil {
		t.Errorf("list entries: %v", err)
		return
	}
	if len(entries) != 0 {
		t.Errorf("list entries count: %v", len(entries))
		return
	}

}