func TestIndexMetadataRaceBug198(t *testing.T) { defer func() { err := os.RemoveAll("testidx") if err != nil { t.Fatal(err) } }() index, err := New("testidx", NewIndexMapping()) if err != nil { t.Fatal(err) } defer func() { err := index.Close() if err != nil { t.Fatal(err) } }() done := make(chan struct{}) go func() { for { select { case <-done: return default: _, err := index.DocCount() if err != nil { t.Fatal(err) } } } }() for i := 0; i < 100; i++ { batch := index.NewBatch() err = batch.Index("a", []byte("{}")) if err != nil { t.Fatal(err) } err = index.Batch(batch) if err != nil { t.Fatal(err) } } close(done) }
func TestClosedIndex(t *testing.T) { index, err := New("", NewIndexMapping()) if err != nil { t.Fatal(err) } err = index.Close() if err != nil { t.Fatal(err) } err = index.Index("test", "test") if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } err = index.Delete("test") if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } b := index.NewBatch() err = index.Batch(b) if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } _, err = index.Document("test") if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } _, err = index.DocCount() if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } _, err = index.Search(NewSearchRequest(NewTermQuery("test"))) if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } _, err = index.Fields() if err != ErrorIndexClosed { t.Errorf("expected error index closed, got %v", err) } }
func (i *indexAliasImpl) DocCount() (uint64, error) { i.mutex.RLock() defer i.mutex.RUnlock() rv := uint64(0) if !i.open { return 0, ErrorIndexClosed } for _, index := range i.indexes { otherCount, err := index.DocCount() if err != nil { return 0, err } rv += otherCount } return rv, nil }
func (i *indexAliasImpl) DocCount() (uint64, error) { i.mutex.RLock() defer i.mutex.RUnlock() rv := uint64(0) if !i.open { return 0, ErrorIndexClosed } for _, index := range i.indexes { otherCount, err := index.DocCount() if err == nil { rv += otherCount } // tolerate errors to produce partial counts } return rv, nil }
func TestIndexCountMatchSearch(t *testing.T) { defer func() { err := os.RemoveAll("testidx") if err != nil { t.Fatal(err) } }() index, err := New("testidx", NewIndexMapping()) if err != nil { t.Fatal(err) } var wg sync.WaitGroup for i := 0; i < 10; i++ { wg.Add(1) go func(i int) { b := index.NewBatch() for j := 0; j < 200; j++ { id := fmt.Sprintf("%d", (i*200)+j) doc := struct { Body string }{ Body: "match", } err := b.Index(id, doc) if err != nil { t.Fatal(err) } } err := index.Batch(b) if err != nil { t.Fatal(err) } wg.Done() }(i) } wg.Wait() // search for something that should match all documents sr, err := index.Search(NewSearchRequest(NewMatchQuery("match"))) if err != nil { t.Fatal(err) } // get the index document count dc, err := index.DocCount() if err != nil { t.Fatal(err) } // make sure test is working correctly, doc count should 2000 if dc != 2000 { t.Errorf("expected doc count 2000, got %d", dc) } // make sure our search found all the documents if dc != sr.Total { t.Errorf("expected search result total %d to match doc count %d", sr.Total, dc) } err = index.Close() if err != nil { t.Fatal(err) } }
func TestCrud(t *testing.T) { defer func() { err := os.RemoveAll("testidx") if err != nil { t.Fatal(err) } }() index, err := New("testidx", NewIndexMapping()) if err != nil { t.Fatal(err) } doca := map[string]interface{}{ "name": "marty", "desc": "gophercon india", } err = index.Index("a", doca) if err != nil { t.Error(err) } docy := map[string]interface{}{ "name": "jasper", "desc": "clojure", } err = index.Index("y", docy) if err != nil { t.Error(err) } err = index.Delete("y") if err != nil { t.Error(err) } docx := map[string]interface{}{ "name": "rose", "desc": "googler", } err = index.Index("x", docx) if err != nil { t.Error(err) } err = index.SetInternal([]byte("status"), []byte("pending")) if err != nil { t.Error(err) } docb := map[string]interface{}{ "name": "steve", "desc": "cbft master", } batch := index.NewBatch() err = batch.Index("b", docb) if err != nil { t.Error(err) } batch.Delete("x") batch.SetInternal([]byte("batchi"), []byte("batchv")) batch.DeleteInternal([]byte("status")) err = index.Batch(batch) if err != nil { t.Error(err) } val, err := index.GetInternal([]byte("batchi")) if err != nil { t.Error(err) } if string(val) != "batchv" { t.Errorf("expected 'batchv', got '%s'", val) } val, err = index.GetInternal([]byte("status")) if err != nil { t.Error(err) } if val != nil { t.Errorf("expected nil, got '%s'", val) } err = index.SetInternal([]byte("seqno"), []byte("7")) if err != nil { t.Error(err) } err = index.SetInternal([]byte("status"), []byte("ready")) if err != nil { t.Error(err) } err = index.DeleteInternal([]byte("status")) if err != nil { t.Error(err) } val, err = index.GetInternal([]byte("status")) if err != nil { t.Error(err) } if val != nil { t.Errorf("expected nil, got '%s'", val) } val, err = index.GetInternal([]byte("seqno")) if err != nil { t.Error(err) } if string(val) != "7" { t.Errorf("expected '7', got '%s'", val) } // close the index, open it again, and try some more things err = index.Close() if err != nil { t.Fatal(err) } index, err = Open("testidx") if err != nil { t.Fatal(err) } defer func() { err := index.Close() if err != nil { t.Fatal(err) } }() count, err := index.DocCount() if err != nil { t.Fatal(err) } if count != 2 { t.Errorf("expected doc count 2, got %d", count) } doc, err := index.Document("a") if err != nil { t.Fatal(err) } if doc == nil { t.Errorf("expected doc not nil, got nil") } foundNameField := false for _, field := range doc.Fields { if field.Name() == "name" && string(field.Value()) == "marty" { foundNameField = true } } if !foundNameField { t.Errorf("expected to find field named 'name' with value 'marty'") } fields, err := index.Fields() if err != nil { t.Fatal(err) } expectedFields := map[string]bool{ "_all": false, "name": false, "desc": false, } if len(fields) != len(expectedFields) { t.Fatalf("expected %d fields got %d", len(expectedFields), len(fields)) } for _, f := range fields { expectedFields[f] = true } for ef, efp := range expectedFields { if !efp { t.Errorf("field %s is missing", ef) } } }
// TestBug408 tests for VERY large values of size, even though actual result // set may be reasonable size func TestBug408(t *testing.T) { type TestStruct struct { ID string `json:"id"` UserID *string `json:"user_id"` } docMapping := NewDocumentMapping() docMapping.AddFieldMappingsAt("id", NewTextFieldMapping()) docMapping.AddFieldMappingsAt("user_id", NewTextFieldMapping()) indexMapping := NewIndexMapping() indexMapping.DefaultMapping = docMapping index, err := NewMemOnly(indexMapping) if err != nil { t.Fatal(err) } numToTest := 10 matchUserID := "match" noMatchUserID := "no_match" matchingDocIds := make(map[string]struct{}) for i := 0; i < numToTest; i++ { ds := &TestStruct{"id_" + strconv.Itoa(i), nil} if i%2 == 0 { ds.UserID = &noMatchUserID } else { ds.UserID = &matchUserID matchingDocIds[ds.ID] = struct{}{} } err = index.Index(ds.ID, ds) if err != nil { t.Fatal(err) } } cnt, err := index.DocCount() if err != nil { t.Fatal(err) } if int(cnt) != numToTest { t.Fatalf("expected %d documents in index, got %d", numToTest, cnt) } q := NewTermQuery(matchUserID) q.SetField("user_id") searchReq := NewSearchRequestOptions(q, math.MaxInt32, 0, false) results, err := index.Search(searchReq) if err != nil { t.Fatal(err) } if int(results.Total) != numToTest/2 { t.Fatalf("expected %d search hits, got %d", numToTest/2, results.Total) } for _, result := range results.Hits { if _, found := matchingDocIds[result.ID]; !found { t.Fatalf("document with ID %s not in results as expected", result.ID) } } }