From d5c1f4a9aba3f12d08f52dd1fae13b329390b8ab Mon Sep 17 00:00:00 2001 From: Marty Schoch Date: Tue, 25 Nov 2014 21:52:23 -0500 Subject: [PATCH] refactored store tests --- index/store/boltdb/store_test.go | 187 +++++++++++++++++++++++++++- index/store/inmem/store_test.go | 185 +++++++++++++++++++++++++++- index/store/leveldb/store_test.go | 187 +++++++++++++++++++++++++++- index/store/test/common.go | 197 ------------------------------ 4 files changed, 551 insertions(+), 205 deletions(-) delete mode 100644 index/store/test/common.go diff --git a/index/store/boltdb/store_test.go b/index/store/boltdb/store_test.go index 502ea77a..ae7d9c1a 100644 --- a/index/store/boltdb/store_test.go +++ b/index/store/boltdb/store_test.go @@ -11,9 +11,10 @@ package boltdb import ( "os" + "reflect" "testing" - "github.com/blevesearch/bleve/index/store/test" + "github.com/blevesearch/bleve/index/store" ) func TestStore(t *testing.T) { @@ -23,7 +24,7 @@ func TestStore(t *testing.T) { } defer os.RemoveAll("test") - store_test.CommonTestKVStore(t, s) + CommonTestKVStore(t, s) } func TestReaderIsolation(t *testing.T) { @@ -33,5 +34,185 @@ func TestReaderIsolation(t *testing.T) { } defer os.RemoveAll("test") - store_test.CommonTestReaderIsolation(t, s) + CommonTestReaderIsolation(t, s) +} + +func CommonTestKVStore(t *testing.T, s store.KVStore) { + + writer, err := s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("a"), []byte("val-a")) + if err != nil { + t.Fatal(err) + } + err = writer.Set([]byte("z"), []byte("val-z")) + if err != nil { + t.Fatal(err) + } + err = writer.Delete([]byte("z")) + if err != nil { + t.Fatal(err) + } + + batch := writer.NewBatch() + batch.Set([]byte("b"), []byte("val-b")) + batch.Set([]byte("c"), []byte("val-c")) + batch.Set([]byte("d"), []byte("val-d")) + batch.Set([]byte("e"), []byte("val-e")) + batch.Set([]byte("f"), []byte("val-f")) + batch.Set([]byte("g"), []byte("val-g")) + batch.Set([]byte("h"), []byte("val-h")) + batch.Set([]byte("i"), []byte("val-i")) + batch.Set([]byte("j"), []byte("val-j")) + + err = batch.Execute() + if err != nil { + t.Fatal(err) + } + writer.Close() + + reader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer reader.Close() + it := reader.Iterator([]byte("b")) + key, val, valid := it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "b" { + t.Fatalf("exepcted key b, got %s", key) + } + if string(val) != "val-b" { + t.Fatalf("expected value val-b, got %s", val) + } + + it.Next() + key, val, valid = it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "c" { + t.Fatalf("exepcted key c, got %s", key) + } + if string(val) != "val-c" { + t.Fatalf("expected value val-c, got %s", val) + } + + it.Seek([]byte("i")) + key, val, valid = it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "i" { + t.Fatalf("exepcted key i, got %s", key) + } + if string(val) != "val-i" { + t.Fatalf("expected value val-i, got %s", val) + } + + it.Close() +} + +func CommonTestReaderIsolation(t *testing.T, s store.KVStore) { + // insert a kv pair + writer, err := s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("a"), []byte("val-a")) + if err != nil { + t.Fatal(err) + } + writer.Close() + + // create an isoalted reader + reader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer reader.Close() + + // verify we see the value already inserted + val, err := reader.Get([]byte("a")) + if err != nil { + t.Error(err) + } + if !reflect.DeepEqual(val, []byte("val-a")) { + t.Errorf("expected val-a, got nil") + } + + // verify that an iterator sees it + count := 0 + it := reader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 1 { + t.Errorf("expected iterator to see 1, saw %d", count) + } + + // add something after the reader was created + writer, err = s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("b"), []byte("val-b")) + if err != nil { + t.Fatal(err) + } + writer.Close() + + // ensure that a newer reader sees it + newReader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer newReader.Close() + val, err = newReader.Get([]byte("b")) + if err != nil { + t.Error(err) + } + if !reflect.DeepEqual(val, []byte("val-b")) { + t.Errorf("expected val-b, got nil") + } + + // ensure director iterator sees it + count = 0 + it = newReader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 2 { + t.Errorf("expected iterator to see 2, saw %d", count) + } + + // but that the isolated reader does not + val, err = reader.Get([]byte("b")) + if err != nil { + t.Error(err) + } + if val != nil { + t.Errorf("expected nil, got %v", val) + } + + // and ensure that the iterator on the isolated reader also does not + count = 0 + it = reader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 1 { + t.Errorf("expected iterator to see 1, saw %d", count) + } + } diff --git a/index/store/inmem/store_test.go b/index/store/inmem/store_test.go index 9a766a31..7f7a350a 100644 --- a/index/store/inmem/store_test.go +++ b/index/store/inmem/store_test.go @@ -10,9 +10,10 @@ package inmem import ( + "reflect" "testing" - "github.com/blevesearch/bleve/index/store/test" + "github.com/blevesearch/bleve/index/store" ) func TestStore(t *testing.T) { @@ -22,5 +23,185 @@ func TestStore(t *testing.T) { } defer s.Close() - store_test.CommonTestKVStore(t, s) + CommonTestKVStore(t, s) +} + +func CommonTestKVStore(t *testing.T, s store.KVStore) { + + writer, err := s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("a"), []byte("val-a")) + if err != nil { + t.Fatal(err) + } + err = writer.Set([]byte("z"), []byte("val-z")) + if err != nil { + t.Fatal(err) + } + err = writer.Delete([]byte("z")) + if err != nil { + t.Fatal(err) + } + + batch := writer.NewBatch() + batch.Set([]byte("b"), []byte("val-b")) + batch.Set([]byte("c"), []byte("val-c")) + batch.Set([]byte("d"), []byte("val-d")) + batch.Set([]byte("e"), []byte("val-e")) + batch.Set([]byte("f"), []byte("val-f")) + batch.Set([]byte("g"), []byte("val-g")) + batch.Set([]byte("h"), []byte("val-h")) + batch.Set([]byte("i"), []byte("val-i")) + batch.Set([]byte("j"), []byte("val-j")) + + err = batch.Execute() + if err != nil { + t.Fatal(err) + } + writer.Close() + + reader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer reader.Close() + it := reader.Iterator([]byte("b")) + key, val, valid := it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "b" { + t.Fatalf("exepcted key b, got %s", key) + } + if string(val) != "val-b" { + t.Fatalf("expected value val-b, got %s", val) + } + + it.Next() + key, val, valid = it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "c" { + t.Fatalf("exepcted key c, got %s", key) + } + if string(val) != "val-c" { + t.Fatalf("expected value val-c, got %s", val) + } + + it.Seek([]byte("i")) + key, val, valid = it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "i" { + t.Fatalf("exepcted key i, got %s", key) + } + if string(val) != "val-i" { + t.Fatalf("expected value val-i, got %s", val) + } + + it.Close() +} + +func CommonTestReaderIsolation(t *testing.T, s store.KVStore) { + // insert a kv pair + writer, err := s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("a"), []byte("val-a")) + if err != nil { + t.Fatal(err) + } + writer.Close() + + // create an isoalted reader + reader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer reader.Close() + + // verify we see the value already inserted + val, err := reader.Get([]byte("a")) + if err != nil { + t.Error(err) + } + if !reflect.DeepEqual(val, []byte("val-a")) { + t.Errorf("expected val-a, got nil") + } + + // verify that an iterator sees it + count := 0 + it := reader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 1 { + t.Errorf("expected iterator to see 1, saw %d", count) + } + + // add something after the reader was created + writer, err = s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("b"), []byte("val-b")) + if err != nil { + t.Fatal(err) + } + writer.Close() + + // ensure that a newer reader sees it + newReader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer newReader.Close() + val, err = newReader.Get([]byte("b")) + if err != nil { + t.Error(err) + } + if !reflect.DeepEqual(val, []byte("val-b")) { + t.Errorf("expected val-b, got nil") + } + + // ensure director iterator sees it + count = 0 + it = newReader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 2 { + t.Errorf("expected iterator to see 2, saw %d", count) + } + + // but that the isolated reader does not + val, err = reader.Get([]byte("b")) + if err != nil { + t.Error(err) + } + if val != nil { + t.Errorf("expected nil, got %v", val) + } + + // and ensure that the iterator on the isolated reader also does not + count = 0 + it = reader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 1 { + t.Errorf("expected iterator to see 1, saw %d", count) + } + } diff --git a/index/store/leveldb/store_test.go b/index/store/leveldb/store_test.go index c3a0e15e..cb76a63f 100644 --- a/index/store/leveldb/store_test.go +++ b/index/store/leveldb/store_test.go @@ -13,9 +13,10 @@ package leveldb import ( "os" + "reflect" "testing" - "github.com/blevesearch/bleve/index/store/test" + "github.com/blevesearch/bleve/index/store" ) func TestLevelDBStore(t *testing.T) { @@ -27,7 +28,7 @@ func TestLevelDBStore(t *testing.T) { } defer s.Close() - store_test.CommonTestKVStore(t, s) + CommonTestKVStore(t, s) } func TestReaderIsolation(t *testing.T) { @@ -39,5 +40,185 @@ func TestReaderIsolation(t *testing.T) { } defer s.Close() - store_test.CommonTestReaderIsolation(t, s) + CommonTestReaderIsolation(t, s) +} + +func CommonTestKVStore(t *testing.T, s store.KVStore) { + + writer, err := s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("a"), []byte("val-a")) + if err != nil { + t.Fatal(err) + } + err = writer.Set([]byte("z"), []byte("val-z")) + if err != nil { + t.Fatal(err) + } + err = writer.Delete([]byte("z")) + if err != nil { + t.Fatal(err) + } + + batch := writer.NewBatch() + batch.Set([]byte("b"), []byte("val-b")) + batch.Set([]byte("c"), []byte("val-c")) + batch.Set([]byte("d"), []byte("val-d")) + batch.Set([]byte("e"), []byte("val-e")) + batch.Set([]byte("f"), []byte("val-f")) + batch.Set([]byte("g"), []byte("val-g")) + batch.Set([]byte("h"), []byte("val-h")) + batch.Set([]byte("i"), []byte("val-i")) + batch.Set([]byte("j"), []byte("val-j")) + + err = batch.Execute() + if err != nil { + t.Fatal(err) + } + writer.Close() + + reader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer reader.Close() + it := reader.Iterator([]byte("b")) + key, val, valid := it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "b" { + t.Fatalf("exepcted key b, got %s", key) + } + if string(val) != "val-b" { + t.Fatalf("expected value val-b, got %s", val) + } + + it.Next() + key, val, valid = it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "c" { + t.Fatalf("exepcted key c, got %s", key) + } + if string(val) != "val-c" { + t.Fatalf("expected value val-c, got %s", val) + } + + it.Seek([]byte("i")) + key, val, valid = it.Current() + if !valid { + t.Fatalf("valid false, expected true") + } + if string(key) != "i" { + t.Fatalf("exepcted key i, got %s", key) + } + if string(val) != "val-i" { + t.Fatalf("expected value val-i, got %s", val) + } + + it.Close() +} + +func CommonTestReaderIsolation(t *testing.T, s store.KVStore) { + // insert a kv pair + writer, err := s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("a"), []byte("val-a")) + if err != nil { + t.Fatal(err) + } + writer.Close() + + // create an isoalted reader + reader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer reader.Close() + + // verify we see the value already inserted + val, err := reader.Get([]byte("a")) + if err != nil { + t.Error(err) + } + if !reflect.DeepEqual(val, []byte("val-a")) { + t.Errorf("expected val-a, got nil") + } + + // verify that an iterator sees it + count := 0 + it := reader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 1 { + t.Errorf("expected iterator to see 1, saw %d", count) + } + + // add something after the reader was created + writer, err = s.Writer() + if err != nil { + t.Error(err) + } + err = writer.Set([]byte("b"), []byte("val-b")) + if err != nil { + t.Fatal(err) + } + writer.Close() + + // ensure that a newer reader sees it + newReader, err := s.Reader() + if err != nil { + t.Error(err) + } + defer newReader.Close() + val, err = newReader.Get([]byte("b")) + if err != nil { + t.Error(err) + } + if !reflect.DeepEqual(val, []byte("val-b")) { + t.Errorf("expected val-b, got nil") + } + + // ensure director iterator sees it + count = 0 + it = newReader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 2 { + t.Errorf("expected iterator to see 2, saw %d", count) + } + + // but that the isolated reader does not + val, err = reader.Get([]byte("b")) + if err != nil { + t.Error(err) + } + if val != nil { + t.Errorf("expected nil, got %v", val) + } + + // and ensure that the iterator on the isolated reader also does not + count = 0 + it = reader.Iterator([]byte{0}) + defer it.Close() + for it.Valid() { + it.Next() + count++ + } + if count != 1 { + t.Errorf("expected iterator to see 1, saw %d", count) + } + } diff --git a/index/store/test/common.go b/index/store/test/common.go deleted file mode 100644 index 372daec5..00000000 --- a/index/store/test/common.go +++ /dev/null @@ -1,197 +0,0 @@ -// Copyright (c) 2014 Couchbase, Inc. -// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file -// except in compliance with the License. You may obtain a copy of the License at -// http://www.apache.org/licenses/LICENSE-2.0 -// Unless required by applicable law or agreed to in writing, software distributed under the -// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, -// either express or implied. See the License for the specific language governing permissions -// and limitations under the License. - -package store_test - -import ( - "reflect" - "testing" - - "github.com/blevesearch/bleve/index/store" -) - -func CommonTestKVStore(t *testing.T, s store.KVStore) { - - writer, err := s.Writer() - if err != nil { - t.Error(err) - } - err = writer.Set([]byte("a"), []byte("val-a")) - if err != nil { - t.Fatal(err) - } - err = writer.Set([]byte("z"), []byte("val-z")) - if err != nil { - t.Fatal(err) - } - err = writer.Delete([]byte("z")) - if err != nil { - t.Fatal(err) - } - - batch := writer.NewBatch() - batch.Set([]byte("b"), []byte("val-b")) - batch.Set([]byte("c"), []byte("val-c")) - batch.Set([]byte("d"), []byte("val-d")) - batch.Set([]byte("e"), []byte("val-e")) - batch.Set([]byte("f"), []byte("val-f")) - batch.Set([]byte("g"), []byte("val-g")) - batch.Set([]byte("h"), []byte("val-h")) - batch.Set([]byte("i"), []byte("val-i")) - batch.Set([]byte("j"), []byte("val-j")) - - err = batch.Execute() - if err != nil { - t.Fatal(err) - } - writer.Close() - - reader, err := s.Reader() - if err != nil { - t.Error(err) - } - defer reader.Close() - it := reader.Iterator([]byte("b")) - key, val, valid := it.Current() - if !valid { - t.Fatalf("valid false, expected true") - } - if string(key) != "b" { - t.Fatalf("exepcted key b, got %s", key) - } - if string(val) != "val-b" { - t.Fatalf("expected value val-b, got %s", val) - } - - it.Next() - key, val, valid = it.Current() - if !valid { - t.Fatalf("valid false, expected true") - } - if string(key) != "c" { - t.Fatalf("exepcted key c, got %s", key) - } - if string(val) != "val-c" { - t.Fatalf("expected value val-c, got %s", val) - } - - it.Seek([]byte("i")) - key, val, valid = it.Current() - if !valid { - t.Fatalf("valid false, expected true") - } - if string(key) != "i" { - t.Fatalf("exepcted key i, got %s", key) - } - if string(val) != "val-i" { - t.Fatalf("expected value val-i, got %s", val) - } - - it.Close() -} - -func CommonTestReaderIsolation(t *testing.T, s store.KVStore) { - // insert a kv pair - writer, err := s.Writer() - if err != nil { - t.Error(err) - } - err = writer.Set([]byte("a"), []byte("val-a")) - if err != nil { - t.Fatal(err) - } - writer.Close() - - // create an isoalted reader - reader, err := s.Reader() - if err != nil { - t.Error(err) - } - defer reader.Close() - - // verify we see the value already inserted - val, err := reader.Get([]byte("a")) - if err != nil { - t.Error(err) - } - if !reflect.DeepEqual(val, []byte("val-a")) { - t.Errorf("expected val-a, got nil") - } - - // verify that an iterator sees it - count := 0 - it := reader.Iterator([]byte{0}) - defer it.Close() - for it.Valid() { - it.Next() - count++ - } - if count != 1 { - t.Errorf("expected iterator to see 1, saw %d", count) - } - - // add something after the reader was created - writer, err = s.Writer() - if err != nil { - t.Error(err) - } - err = writer.Set([]byte("b"), []byte("val-b")) - if err != nil { - t.Fatal(err) - } - writer.Close() - - // ensure that a newer reader sees it - newReader, err := s.Reader() - if err != nil { - t.Error(err) - } - defer newReader.Close() - val, err = newReader.Get([]byte("b")) - if err != nil { - t.Error(err) - } - if !reflect.DeepEqual(val, []byte("val-b")) { - t.Errorf("expected val-b, got nil") - } - - // ensure director iterator sees it - count = 0 - it = newReader.Iterator([]byte{0}) - defer it.Close() - for it.Valid() { - it.Next() - count++ - } - if count != 2 { - t.Errorf("expected iterator to see 2, saw %d", count) - } - - // but that the isolated reader does not - val, err = reader.Get([]byte("b")) - if err != nil { - t.Error(err) - } - if val != nil { - t.Errorf("expected nil, got %v", val) - } - - // and ensure that the iterator on the isolated reader also does not - count = 0 - it = reader.Iterator([]byte{0}) - defer it.Close() - for it.Valid() { - it.Next() - count++ - } - if count != 1 { - t.Errorf("expected iterator to see 1, saw %d", count) - } - -}