Switch from Godep to go vendoring

vendor/github.com/blevesearch/bleve/index_alias_impl_test.go

@@ -0,0 +1,790 @@
+package bleve
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+	"time"
+
+	"github.com/blevesearch/bleve/document"
+	"github.com/blevesearch/bleve/index"
+	"github.com/blevesearch/bleve/index/store"
+	"github.com/blevesearch/bleve/search"
+)
+
+func TestIndexAliasSingle(t *testing.T) {
+	expectedError := fmt.Errorf("expected")
+	ei1 := &stubIndex{
+		err: expectedError,
+	}
+
+	alias := NewIndexAlias(ei1)
+
+	err := alias.Index("a", "a")
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	err = alias.Delete("a")
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	batch := alias.NewBatch()
+	err = alias.Batch(batch)
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	_, err = alias.Document("a")
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	_, err = alias.Fields()
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	_, err = alias.GetInternal([]byte("a"))
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	err = alias.SetInternal([]byte("a"), []byte("a"))
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	err = alias.DeleteInternal([]byte("a"))
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	res := alias.DumpAll()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpDoc("a")
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpFields()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	mapping := alias.Mapping()
+	if mapping != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	indexStat := alias.Stats()
+	if indexStat != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	// now a few things that should work
+	sr := NewSearchRequest(NewTermQuery("test"))
+	_, err = alias.Search(sr)
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	_, err = alias.DocCount()
+	if err != expectedError {
+		t.Errorf("expected %v, got %v", expectedError, err)
+	}
+
+	// now change the def using add/remove
+	expectedError2 := fmt.Errorf("expected2")
+	ei2 := &stubIndex{
+		err: expectedError2,
+	}
+
+	alias.Add(ei2)
+	alias.Remove(ei1)
+
+	err = alias.Index("a", "a")
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	err = alias.Delete("a")
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	err = alias.Batch(batch)
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	_, err = alias.Document("a")
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	_, err = alias.Fields()
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	_, err = alias.GetInternal([]byte("a"))
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	err = alias.SetInternal([]byte("a"), []byte("a"))
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	err = alias.DeleteInternal([]byte("a"))
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	res = alias.DumpAll()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpDoc("a")
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpFields()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	mapping = alias.Mapping()
+	if mapping != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	indexStat = alias.Stats()
+	if indexStat != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	// now a few things that should work
+	_, err = alias.Search(sr)
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	_, err = alias.DocCount()
+	if err != expectedError2 {
+		t.Errorf("expected %v, got %v", expectedError2, err)
+	}
+
+	// now change the def using swap
+	expectedError3 := fmt.Errorf("expected3")
+	ei3 := &stubIndex{
+		err: expectedError3,
+	}
+
+	alias.Swap([]Index{ei3}, []Index{ei2})
+
+	err = alias.Index("a", "a")
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	err = alias.Delete("a")
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	err = alias.Batch(batch)
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	_, err = alias.Document("a")
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	_, err = alias.Fields()
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	_, err = alias.GetInternal([]byte("a"))
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	err = alias.SetInternal([]byte("a"), []byte("a"))
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	err = alias.DeleteInternal([]byte("a"))
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	res = alias.DumpAll()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpDoc("a")
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpFields()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	mapping = alias.Mapping()
+	if mapping != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	indexStat = alias.Stats()
+	if indexStat != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	// now a few things that should work
+	_, err = alias.Search(sr)
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+
+	_, err = alias.DocCount()
+	if err != expectedError3 {
+		t.Errorf("expected %v, got %v", expectedError3, err)
+	}
+}
+
+func TestIndexAliasClosed(t *testing.T) {
+	alias := NewIndexAlias()
+	err := alias.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = alias.Index("a", "a")
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	err = alias.Delete("a")
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	batch := alias.NewBatch()
+	err = alias.Batch(batch)
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	_, err = alias.Document("a")
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	_, err = alias.Fields()
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	_, err = alias.GetInternal([]byte("a"))
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	err = alias.SetInternal([]byte("a"), []byte("a"))
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	err = alias.DeleteInternal([]byte("a"))
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	res := alias.DumpAll()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpDoc("a")
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpFields()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	mapping := alias.Mapping()
+	if mapping != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	indexStat := alias.Stats()
+	if indexStat != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	// now a few things that should work
+	sr := NewSearchRequest(NewTermQuery("test"))
+	_, err = alias.Search(sr)
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+
+	_, err = alias.DocCount()
+	if err != ErrorIndexClosed {
+		t.Errorf("expected %v, got %v", ErrorIndexClosed, err)
+	}
+}
+
+func TestIndexAliasEmpty(t *testing.T) {
+	alias := NewIndexAlias()
+
+	err := alias.Index("a", "a")
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	err = alias.Delete("a")
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	batch := alias.NewBatch()
+	err = alias.Batch(batch)
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	_, err = alias.Document("a")
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	_, err = alias.Fields()
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	_, err = alias.GetInternal([]byte("a"))
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	err = alias.SetInternal([]byte("a"), []byte("a"))
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	err = alias.DeleteInternal([]byte("a"))
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	res := alias.DumpAll()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpDoc("a")
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpFields()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	mapping := alias.Mapping()
+	if mapping != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	indexStat := alias.Stats()
+	if indexStat != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	// now a few things that should work
+	sr := NewSearchRequest(NewTermQuery("test"))
+	_, err = alias.Search(sr)
+	if err != ErrorAliasEmpty {
+		t.Errorf("expected %v, got %v", ErrorAliasEmpty, err)
+	}
+
+	count, err := alias.DocCount()
+	if count != 0 {
+		t.Errorf("expected %d, got %d", 0, count)
+	}
+}
+
+func TestIndexAliasMulti(t *testing.T) {
+	ei1Count := uint64(7)
+	ei1 := &stubIndex{
+		err:            nil,
+		docCountResult: &ei1Count,
+		searchResult: &SearchResult{
+			Total: 1,
+			Hits: search.DocumentMatchCollection{
+				&search.DocumentMatch{
+					ID:    "a",
+					Score: 1.0,
+				},
+			},
+			MaxScore: 1.0,
+		}}
+	ei2Count := uint64(8)
+	ei2 := &stubIndex{
+		err:            nil,
+		docCountResult: &ei2Count,
+		searchResult: &SearchResult{
+			Total: 1,
+			Hits: search.DocumentMatchCollection{
+				&search.DocumentMatch{
+					ID:    "b",
+					Score: 2.0,
+				},
+			},
+			MaxScore: 2.0,
+		}}
+
+	alias := NewIndexAlias(ei1, ei2)
+
+	err := alias.Index("a", "a")
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	err = alias.Delete("a")
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	batch := alias.NewBatch()
+	err = alias.Batch(batch)
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	_, err = alias.Document("a")
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	_, err = alias.Fields()
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	_, err = alias.GetInternal([]byte("a"))
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	err = alias.SetInternal([]byte("a"), []byte("a"))
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	err = alias.DeleteInternal([]byte("a"))
+	if err != ErrorAliasMulti {
+		t.Errorf("expected %v, got %v", ErrorAliasMulti, err)
+	}
+
+	res := alias.DumpAll()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpDoc("a")
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	res = alias.DumpFields()
+	if res != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	mapping := alias.Mapping()
+	if mapping != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	indexStat := alias.Stats()
+	if indexStat != nil {
+		t.Errorf("expected nil, got %v", res)
+	}
+
+	// now a few things that should work
+	sr := NewSearchRequest(NewTermQuery("test"))
+	expected := &SearchResult{
+		Request: sr,
+		Total:   2,
+		Hits: search.DocumentMatchCollection{
+			&search.DocumentMatch{
+				ID:    "b",
+				Score: 2.0,
+			},
+			&search.DocumentMatch{
+				ID:    "a",
+				Score: 1.0,
+			},
+		},
+		MaxScore: 2.0,
+	}
+	results, err := alias.Search(sr)
+	if err != nil {
+		t.Error(err)
+	}
+	// cheat and ensure that Took field matches since it invovles time
+	expected.Took = results.Took
+	if !reflect.DeepEqual(results, expected) {
+		t.Errorf("expected %#v, got %#v", expected, results)
+	}
+
+	count, err := alias.DocCount()
+	if count != (*ei1.docCountResult + *ei2.docCountResult) {
+		t.Errorf("expected %d, got %d", (*ei1.docCountResult + *ei2.docCountResult), count)
+	}
+}
+
+// TestMultiSearchNoError
+func TestMultiSearchNoError(t *testing.T) {
+	ei1 := &stubIndex{err: nil, searchResult: &SearchResult{
+		Total: 1,
+		Hits: search.DocumentMatchCollection{
+			&search.DocumentMatch{
+				ID:    "a",
+				Score: 1.0,
+			},
+		},
+		MaxScore: 1.0,
+	}}
+	ei2 := &stubIndex{err: nil, searchResult: &SearchResult{
+		Total: 1,
+		Hits: search.DocumentMatchCollection{
+			&search.DocumentMatch{
+				ID:    "b",
+				Score: 2.0,
+			},
+		},
+		MaxScore: 2.0,
+	}}
+
+	sr := NewSearchRequest(NewTermQuery("test"))
+	expected := &SearchResult{
+		Request: sr,
+		Total:   2,
+		Hits: search.DocumentMatchCollection{
+			&search.DocumentMatch{
+				ID:    "b",
+				Score: 2.0,
+			},
+			&search.DocumentMatch{
+				ID:    "a",
+				Score: 1.0,
+			},
+		},
+		MaxScore: 2.0,
+	}
+
+	results, err := MultiSearch(sr, ei1, ei2)
+	if err != nil {
+		t.Error(err)
+	}
+	// cheat and ensure that Took field matches since it invovles time
+	expected.Took = results.Took
+	if !reflect.DeepEqual(results, expected) {
+		t.Errorf("expected %#v, got %#v", expected, results)
+	}
+}
+
+// TestMultiSearchSomeError
+func TestMultiSearchSomeError(t *testing.T) {
+	ei1 := &stubIndex{err: nil, searchResult: &SearchResult{
+		Total: 1,
+		Hits: search.DocumentMatchCollection{
+			&search.DocumentMatch{
+				ID:    "a",
+				Score: 1.0,
+			},
+		},
+		Took:     1 * time.Second,
+		MaxScore: 1.0,
+	}}
+	ei2 := &stubIndex{err: fmt.Errorf("deliberate error")}
+	sr := NewSearchRequest(NewTermQuery("test"))
+	_, err := MultiSearch(sr, ei1, ei2)
+	if err == nil {
+		t.Errorf("expected error, got %v", err)
+	}
+}
+
+// TestMultiSearchAllError
+// reproduces https://github.com/blevesearch/bleve/issues/126
+func TestMultiSearchAllError(t *testing.T) {
+	ei1 := &stubIndex{err: fmt.Errorf("deliberate error")}
+	ei2 := &stubIndex{err: fmt.Errorf("deliberate error")}
+	sr := NewSearchRequest(NewTermQuery("test"))
+	_, err := MultiSearch(sr, ei1, ei2)
+	if err == nil {
+		t.Errorf("expected error, got %v", err)
+	}
+}
+
+func TestMultiSearchSecondPage(t *testing.T) {
+	checkRequest := func(sr *SearchRequest) error {
+		if sr.From != 0 {
+			return fmt.Errorf("child request from should be 0")
+		}
+		if sr.Size != 20 {
+			return fmt.Errorf("child request size should be 20")
+		}
+		return nil
+	}
+
+	ei1 := &stubIndex{
+		searchResult: &SearchResult{},
+		checkRequest: checkRequest,
+	}
+	ei2 := &stubIndex{
+		searchResult: &SearchResult{},
+		checkRequest: checkRequest,
+	}
+	sr := NewSearchRequestOptions(NewTermQuery("test"), 10, 10, false)
+	_, err := MultiSearch(sr, ei1, ei2)
+	if err != nil {
+		t.Errorf("unexpected error %v", err)
+	}
+
+}
+
+// stubIndex is an Index impl for which all operations
+// return the configured error value, unless the
+// corresponding operation result value has been
+// set, in which case that is returned instead
+type stubIndex struct {
+	err            error
+	searchResult   *SearchResult
+	documentResult *document.Document
+	docCountResult *uint64
+	checkRequest   func(*SearchRequest) error
+}
+
+func (i *stubIndex) Index(id string, data interface{}) error {
+	return i.err
+}
+
+func (i *stubIndex) Delete(id string) error {
+	return i.err
+}
+
+func (i *stubIndex) Batch(b *Batch) error {
+	return i.err
+}
+
+func (i *stubIndex) Document(id string) (*document.Document, error) {
+	if i.documentResult != nil {
+		return i.documentResult, nil
+	}
+	return nil, i.err
+}
+
+func (i *stubIndex) DocCount() (uint64, error) {
+	if i.docCountResult != nil {
+		return *i.docCountResult, nil
+	}
+	return 0, i.err
+}
+
+func (i *stubIndex) Search(req *SearchRequest) (*SearchResult, error) {
+	if i.checkRequest != nil {
+		err := i.checkRequest(req)
+		if err != nil {
+			return nil, err
+		}
+	}
+	if i.searchResult != nil {
+		return i.searchResult, nil
+	}
+	return nil, i.err
+}
+
+func (i *stubIndex) Fields() ([]string, error) {
+	return nil, i.err
+}
+
+func (i *stubIndex) FieldDict(field string) (index.FieldDict, error) {
+	return nil, i.err
+}
+
+func (i *stubIndex) FieldDictRange(field string, startTerm []byte, endTerm []byte) (index.FieldDict, error) {
+	return nil, i.err
+}
+
+func (i *stubIndex) FieldDictPrefix(field string, termPrefix []byte) (index.FieldDict, error) {
+	return nil, i.err
+}
+
+func (i *stubIndex) DumpAll() chan interface{} {
+	return nil
+}
+
+func (i *stubIndex) DumpDoc(id string) chan interface{} {
+	return nil
+}
+
+func (i *stubIndex) DumpFields() chan interface{} {
+	return nil
+}
+
+func (i *stubIndex) Close() error {
+	return i.err
+}
+
+func (i *stubIndex) Mapping() *IndexMapping {
+	return nil
+}
+
+func (i *stubIndex) Stats() *IndexStat {
+	return nil
+}
+
+func (i *stubIndex) GetInternal(key []byte) ([]byte, error) {
+	return nil, i.err
+}
+
+func (i *stubIndex) SetInternal(key, val []byte) error {
+	return i.err
+}
+
+func (i *stubIndex) DeleteInternal(key []byte) error {
+	return i.err
+}
+
+func (i *stubIndex) Advanced() (index.Index, store.KVStore, error) {
+	return nil, nil, nil
+}
+
+func (i *stubIndex) NewBatch() *Batch {
+	return &Batch{}
+}