mirror of
https://github.com/FairwindsOps/polaris.git
synced 2026-05-17 14:47:21 +00:00
431 lines
8.3 KiB
Go
431 lines
8.3 KiB
Go
package diskv
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"math/rand"
|
|
"regexp"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func cmpBytes(a, b []byte) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := 0; i < len(a); i++ {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (d *Diskv) isCached(key string) bool {
|
|
d.mu.RLock()
|
|
defer d.mu.RUnlock()
|
|
_, ok := d.cache[key]
|
|
return ok
|
|
}
|
|
|
|
func TestWriteReadErase(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1024,
|
|
})
|
|
defer d.EraseAll()
|
|
k, v := "a", []byte{'b'}
|
|
if err := d.Write(k, v); err != nil {
|
|
t.Fatalf("write: %s", err)
|
|
}
|
|
if readVal, err := d.Read(k); err != nil {
|
|
t.Fatalf("read: %s", err)
|
|
} else if bytes.Compare(v, readVal) != 0 {
|
|
t.Fatalf("read: expected %s, got %s", v, readVal)
|
|
}
|
|
if err := d.Erase(k); err != nil {
|
|
t.Fatalf("erase: %s", err)
|
|
}
|
|
}
|
|
|
|
func TestWRECache(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1024,
|
|
})
|
|
defer d.EraseAll()
|
|
k, v := "xxx", []byte{' ', ' ', ' '}
|
|
if d.isCached(k) {
|
|
t.Fatalf("key cached before Write and Read")
|
|
}
|
|
if err := d.Write(k, v); err != nil {
|
|
t.Fatalf("write: %s", err)
|
|
}
|
|
if d.isCached(k) {
|
|
t.Fatalf("key cached before Read")
|
|
}
|
|
if readVal, err := d.Read(k); err != nil {
|
|
t.Fatalf("read: %s", err)
|
|
} else if bytes.Compare(v, readVal) != 0 {
|
|
t.Fatalf("read: expected %s, got %s", v, readVal)
|
|
}
|
|
for i := 0; i < 10 && !d.isCached(k); i++ {
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
if !d.isCached(k) {
|
|
t.Fatalf("key not cached after Read")
|
|
}
|
|
if err := d.Erase(k); err != nil {
|
|
t.Fatalf("erase: %s", err)
|
|
}
|
|
if d.isCached(k) {
|
|
t.Fatalf("key cached after Erase")
|
|
}
|
|
}
|
|
|
|
func TestStrings(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1024,
|
|
})
|
|
defer d.EraseAll()
|
|
|
|
keys := map[string]bool{"a": false, "b": false, "c": false, "d": false}
|
|
v := []byte{'1'}
|
|
for k := range keys {
|
|
if err := d.Write(k, v); err != nil {
|
|
t.Fatalf("write: %s: %s", k, err)
|
|
}
|
|
}
|
|
|
|
for k := range d.Keys(nil) {
|
|
if _, present := keys[k]; present {
|
|
t.Logf("got: %s", k)
|
|
keys[k] = true
|
|
} else {
|
|
t.Fatalf("strings() returns unknown key: %s", k)
|
|
}
|
|
}
|
|
|
|
for k, found := range keys {
|
|
if !found {
|
|
t.Errorf("never got %s", k)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestZeroByteCache(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 0,
|
|
})
|
|
defer d.EraseAll()
|
|
|
|
k, v := "a", []byte{'1', '2', '3'}
|
|
if err := d.Write(k, v); err != nil {
|
|
t.Fatalf("Write: %s", err)
|
|
}
|
|
|
|
if d.isCached(k) {
|
|
t.Fatalf("key cached, expected not-cached")
|
|
}
|
|
|
|
if _, err := d.Read(k); err != nil {
|
|
t.Fatalf("Read: %s", err)
|
|
}
|
|
|
|
if d.isCached(k) {
|
|
t.Fatalf("key cached, expected not-cached")
|
|
}
|
|
}
|
|
|
|
func TestOneByteCache(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1,
|
|
})
|
|
defer d.EraseAll()
|
|
|
|
k1, k2, v1, v2 := "a", "b", []byte{'1'}, []byte{'1', '2'}
|
|
if err := d.Write(k1, v1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if v, err := d.Read(k1); err != nil {
|
|
t.Fatal(err)
|
|
} else if !cmpBytes(v, v1) {
|
|
t.Fatalf("Read: expected %s, got %s", string(v1), string(v))
|
|
}
|
|
|
|
for i := 0; i < 10 && !d.isCached(k1); i++ {
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
if !d.isCached(k1) {
|
|
t.Fatalf("expected 1-byte value to be cached, but it wasn't")
|
|
}
|
|
|
|
if err := d.Write(k2, v2); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := d.Read(k2); err != nil {
|
|
t.Fatalf("--> %s", err)
|
|
}
|
|
|
|
for i := 0; i < 10 && (!d.isCached(k1) || d.isCached(k2)); i++ {
|
|
time.Sleep(10 * time.Millisecond) // just wait for lazy-cache
|
|
}
|
|
if !d.isCached(k1) {
|
|
t.Fatalf("1-byte value was uncached for no reason")
|
|
}
|
|
|
|
if d.isCached(k2) {
|
|
t.Fatalf("2-byte value was cached, but cache max size is 1")
|
|
}
|
|
}
|
|
|
|
func TestStaleCache(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1,
|
|
})
|
|
defer d.EraseAll()
|
|
|
|
k, first, second := "a", "first", "second"
|
|
if err := d.Write(k, []byte(first)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v, err := d.Read(k)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(v) != first {
|
|
t.Errorf("expected '%s', got '%s'", first, v)
|
|
}
|
|
|
|
if err := d.Write(k, []byte(second)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v, err = d.Read(k)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if string(v) != second {
|
|
t.Errorf("expected '%s', got '%s'", second, v)
|
|
}
|
|
}
|
|
|
|
func TestHas(t *testing.T) {
|
|
d := New(Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1024,
|
|
})
|
|
defer d.EraseAll()
|
|
|
|
for k, v := range map[string]string{
|
|
"a": "1",
|
|
"foo": "2",
|
|
"012345": "3",
|
|
} {
|
|
d.Write(k, []byte(v))
|
|
}
|
|
|
|
d.Read("foo") // cache one of them
|
|
if !d.isCached("foo") {
|
|
t.Errorf("'foo' didn't get cached")
|
|
}
|
|
|
|
for _, tuple := range []struct {
|
|
key string
|
|
expected bool
|
|
}{
|
|
{"a", true},
|
|
{"b", false},
|
|
{"foo", true},
|
|
{"bar", false},
|
|
{"01234", false},
|
|
{"012345", true},
|
|
{"0123456", false},
|
|
} {
|
|
if expected, got := tuple.expected, d.Has(tuple.key); expected != got {
|
|
t.Errorf("Has(%s): expected %v, got %v", tuple.key, expected, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
type BrokenReader struct{}
|
|
|
|
func (BrokenReader) Read(p []byte) (n int, err error) {
|
|
return 0, errors.New("failed to read")
|
|
}
|
|
|
|
func TestRemovesIncompleteFiles(t *testing.T) {
|
|
opts := Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1024,
|
|
}
|
|
d := New(opts)
|
|
defer d.EraseAll()
|
|
|
|
key, stream, sync := "key", BrokenReader{}, false
|
|
|
|
if err := d.WriteStream(key, stream, sync); err == nil {
|
|
t.Fatalf("Expected i/o copy error, none received.")
|
|
}
|
|
|
|
if _, err := d.Read(key); err == nil {
|
|
t.Fatal("Could read the key, but it shouldn't exist")
|
|
}
|
|
}
|
|
|
|
func TestTempDir(t *testing.T) {
|
|
opts := Options{
|
|
BasePath: "test-data",
|
|
TempDir: "test-data-temp",
|
|
CacheSizeMax: 1024,
|
|
}
|
|
d := New(opts)
|
|
defer d.EraseAll()
|
|
|
|
k, v := "a", []byte{'b'}
|
|
if err := d.Write(k, v); err != nil {
|
|
t.Fatalf("write: %s", err)
|
|
}
|
|
if readVal, err := d.Read(k); err != nil {
|
|
t.Fatalf("read: %s", err)
|
|
} else if bytes.Compare(v, readVal) != 0 {
|
|
t.Fatalf("read: expected %s, got %s", v, readVal)
|
|
}
|
|
if err := d.Erase(k); err != nil {
|
|
t.Fatalf("erase: %s", err)
|
|
}
|
|
}
|
|
|
|
type CrashingReader struct{}
|
|
|
|
func (CrashingReader) Read(p []byte) (n int, err error) {
|
|
panic("System has crashed while reading the stream")
|
|
}
|
|
|
|
func TestAtomicWrite(t *testing.T) {
|
|
opts := Options{
|
|
BasePath: "test-data",
|
|
// Test would fail if TempDir is not set here.
|
|
TempDir: "test-data-temp",
|
|
CacheSizeMax: 1024,
|
|
}
|
|
d := New(opts)
|
|
defer d.EraseAll()
|
|
|
|
key := "key"
|
|
func() {
|
|
defer func() {
|
|
recover() // Ignore panicking error
|
|
}()
|
|
|
|
stream := CrashingReader{}
|
|
d.WriteStream(key, stream, false)
|
|
}()
|
|
|
|
if d.Has(key) {
|
|
t.Fatal("Has key, but it shouldn't exist")
|
|
}
|
|
if _, ok := <-d.Keys(nil); ok {
|
|
t.Fatal("Store isn't empty")
|
|
}
|
|
}
|
|
|
|
const letterBytes = "abcdef0123456789"
|
|
|
|
func randStringBytes(n int) string {
|
|
b := make([]byte, n)
|
|
for i := range b {
|
|
b[i] = letterBytes[rand.Intn(len(letterBytes))]
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func TestHybridStore(t *testing.T) {
|
|
regex := regexp.MustCompile("[0-9a-fA-F]{64}")
|
|
|
|
transformFunc := func(s string) *PathKey {
|
|
|
|
if regex.MatchString(s) {
|
|
return &PathKey{Path: []string{"objects", s[0:2]},
|
|
FileName: s,
|
|
}
|
|
}
|
|
|
|
folders := strings.Split(s, "/")
|
|
lfolders := len(folders)
|
|
if lfolders > 1 {
|
|
return &PathKey{Path: folders[:lfolders-1],
|
|
FileName: folders[lfolders-1],
|
|
}
|
|
}
|
|
|
|
return &PathKey{Path: []string{},
|
|
FileName: s,
|
|
}
|
|
}
|
|
|
|
inverseTransformFunc := func(pathKey *PathKey) string {
|
|
|
|
if regex.MatchString(pathKey.FileName) {
|
|
return pathKey.FileName
|
|
|
|
}
|
|
|
|
if len(pathKey.Path) == 0 {
|
|
return pathKey.FileName
|
|
}
|
|
|
|
return strings.Join(pathKey.Path, "/") + "/" + pathKey.FileName
|
|
|
|
}
|
|
opts := Options{
|
|
BasePath: "test-data",
|
|
CacheSizeMax: 1024,
|
|
AdvancedTransform: transformFunc,
|
|
InverseTransform: inverseTransformFunc,
|
|
}
|
|
d := New(opts)
|
|
defer d.EraseAll()
|
|
|
|
testData := map[string]string{}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
testData[randStringBytes(64)] = randStringBytes(100)
|
|
}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
testData[randStringBytes(20)] = randStringBytes(100)
|
|
}
|
|
|
|
for i := 0; i < 100; i++ {
|
|
numsep := rand.Intn(10) + 1
|
|
key := ""
|
|
for j := 0; j < numsep; j++ {
|
|
key += randStringBytes(10) + "/"
|
|
}
|
|
key += randStringBytes(40)
|
|
testData[key] = randStringBytes(100)
|
|
}
|
|
|
|
for k, v := range testData {
|
|
d.WriteString(k, v)
|
|
}
|
|
|
|
for k, v := range testData {
|
|
readVal := d.ReadString(k)
|
|
|
|
if v != readVal {
|
|
t.Fatalf("read: expected %s, got %s", v, readVal)
|
|
}
|
|
}
|
|
|
|
}
|