func TestSuggest(t *testing.T) { c := NewTestConn() mappingOpts := MappingOptions{Properties: hash{ "completion": hash{ "type": "completion", }, }} err := c.PutMapping("github", "SuggestTest", SuggestTest{}, mappingOpts) ok(t, err) _, err = c.UpdateWithPartialDoc("github", "SuggestTest", "1", nil, SuggestTest{"foobar"}, true) ok(t, err) query := hash{"completion_completion": hash{ "text": "foo", "completion": hash{ "size": 10, "field": "completion", }, }} _, err = c.Refresh("github") ok(t, err) res, err := c.Suggest("github", nil, query) ok(t, err) opts, err := res.Result("completion_completion") ok(t, err) first := opts[0] assert.T(t, len(first.Options) > 0, "Length of first.Options was 0.") text := first.Options[0].Text assert.T(t, text == "foobar", fmt.Sprintf("Expected foobar, got: %s", text)) }
func TestSearchRequestQueryString(t *testing.T) { c := NewTestConn() out, err := c.SearchUri("github", "", map[string]interface{}{"q": "actor:a*"}) expectedHits := 621 assert.T(t, &out != nil && err == nil, "Should get docs") assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v hits but was %v", expectedHits, out.Hits.Total)) }
// currently broken in drone.io func XXXTestBulkUpdate(t *testing.T) { var ( buffers = make([]*bytes.Buffer, 0) totalBytesSent int messageSets int ) InitTests(true) c := NewTestConn() c.Port = "9200" indexer := c.NewBulkIndexer(3) indexer.Sender = func(buf *bytes.Buffer) error { messageSets += 1 totalBytesSent += buf.Len() buffers = append(buffers, buf) return indexer.Send(buf) } indexer.Start() date := time.Unix(1257894000, 0) user := map[string]interface{}{ "name": "smurfs", "age": 22, "date": date, "count": 1, } // Lets make sure the data is in the index ... _, err := c.Index("users", "user", "5", nil, user) // script and params data := map[string]interface{}{ "script": "ctx._source.count += 2", } err = indexer.Update("users", "user", "5", "", &date, data, true) // So here's the deal. Flushing does seem to work, you just have to give the // channel a moment to recieve the message ... // <- time.After(time.Millisecond * 20) // indexer.Flush() waitFor(func() bool { return len(buffers) > 0 }, 5) indexer.Stop() assert.T(t, indexer.NumErrors() == 0 && err == nil, fmt.Sprintf("Should not have any errors, bulkErrorCt:%v, err:%v", indexer.NumErrors(), err)) response, err := c.Get("users", "user", "5", nil) assert.T(t, err == nil, fmt.Sprintf("Should not have any errors %v", err)) m := make(map[string]interface{}) json.Unmarshal([]byte(*response.Source), &m) newCount := m["count"] assert.T(t, newCount.(float64) == 3, fmt.Sprintf("Should have update count: %#v ... %#v", m["count"], response)) }
func TestSearchRange(t *testing.T) { c := NewTestConn() // now lets filter by a subset of the total time out, _ := Search("github").Size("25").Query( Query().Range( Range().Field("created_at").From("2012-12-10T15:00:00-08:00").To("2012-12-10T15:10:00-08:00"), ).Search("add"), ).Result(c) assert.T(t, out != nil && &out.Hits != nil, "Must not have nil results, or hits") assert.T(t, out.Hits.Len() == 25, fmt.Sprintf("Should have 25 docs %v", out.Hits.Len())) assert.T(t, out.Hits.Total == 92, fmt.Sprintf("Should have total=92 but was %v", out.Hits.Total)) }
func TestSearchFields(t *testing.T) { c := NewTestConn() // same as terms, search using fields: // how many different docs have jasmine in repository.name? qry := Search("github").Query( Query().Fields("repository.name", "jasmine", "", ""), ) out, _ := qry.Result(c) expectedDocs := 4 expectedHits := 4 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total= %v", expectedHits, out.Hits.Total)) }
func TestSearchTerm(t *testing.T) { c := NewTestConn() // ok, now lets try searching with term query (specific field/term) qry := Search("github").Query( Query().Term("repository.name", "jasmine"), ) out, _ := qry.Result(c) // how many different docs have jasmine in repository.name? expectedDocs := 4 expectedHits := 4 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total= %v", expectedHits, out.Hits.Total)) }
func XXXTestBulkErrors(t *testing.T) { // lets set a bad port, and hope we get a conn refused error? c := NewTestConn() c.Port = "27845" defer func() { c.Port = "9200" }() indexer := c.NewBulkIndexerErrors(10, 1) indexer.Start() errorCt := 0 go func() { for i := 0; i < 20; i++ { date := time.Unix(1257894000, 0) data := map[string]interface{}{"name": "smurfs", "age": 22, "date": date} indexer.Index("users", "user", strconv.Itoa(i), "", &date, data, true) } }() var errBuf *ErrorBuffer for errBuf = range indexer.ErrorChannel { errorCt++ break } if errBuf.Buf.Len() > 0 { gou.Debug(errBuf.Err) } assert.T(t, errorCt > 0, fmt.Sprintf("ErrorCt should be > 0 %d", errorCt)) indexer.Stop() }
func TestBulkDelete(t *testing.T) { InitTests(true) c := NewTestConn() indexer := c.NewBulkIndexer(1) sentBytes := []byte{} indexer.Sender = func(buf *bytes.Buffer) error { sentBytes = append(sentBytes, buf.Bytes()...) return nil } indexer.Start() indexer.Delete("fake", "fake_type", "1", true) indexer.Flush() indexer.Stop() sent := string(sentBytes) expected := `{"delete":{"_index":"fake","_type":"fake_type","_id":"1","refresh":true}} ` asExpected := sent == expected assert.T(t, asExpected, fmt.Sprintf("Should have sent '%s' but actually sent '%s'", expected, sent)) }
func TestBulkSmallBatch(t *testing.T) { var ( messageSets int ) InitTests(true) c := NewTestConn() date := time.Unix(1257894000, 0) data := map[string]interface{}{"name": "smurfs", "age": 22, "date": date} // Now tests small batches indexer := c.NewBulkIndexer(1) indexer.BufferDelayMax = 100 * time.Millisecond indexer.BulkMaxDocs = 2 messageSets = 0 indexer.Sender = func(buf *bytes.Buffer) error { messageSets += 1 return indexer.Send(buf) } indexer.Start() <-time.After(time.Millisecond * 20) indexer.Index("users", "user", "2", "", &date, data, true) indexer.Index("users", "user", "3", "", &date, data, true) indexer.Index("users", "user", "4", "", &date, data, true) <-time.After(time.Millisecond * 200) // indexer.Flush() indexer.Stop() assert.T(t, messageSets == 2, fmt.Sprintf("Should have sent 2 message sets %d", messageSets)) }
func TestSearchRequest(t *testing.T) { c := NewTestConn() qry := map[string]interface{}{ "query": map[string]interface{}{ "wildcard": map[string]string{"actor": "a*"}, }, } out, err := c.Search("github", "", nil, qry) //log.Println(out) assert.T(t, &out != nil && err == nil, t, "Should get docs") expectedDocs := 10 expectedHits := 621 assert.T(t, out.Hits.Len() == expectedDocs, t, fmt.Sprintf("Should have %v docs but was %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, t, fmt.Sprintf("Should have %v hits but was %v", expectedHits, out.Hits.Total)) }
func TestFilterRange(t *testing.T) { c := NewTestConn() // now lets filter range for repositories with more than 100 forks out, _ := Search("github").Size("25").Filter( Range().Field("repository.forks").From("100"), ).Result(c) if out == nil || &out.Hits == nil { t.Fail() return } expectedDocs := 25 expectedHits := 725 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have total %v got %v", expectedHits, out.Hits.Total)) }
func TestSearchFilterQuery(t *testing.T) { c := NewTestConn() // compound query + filter with query being wildcard out, _ := Search("github").Size("25").Query( Query().Fields("repository.name", "jas*", "", ""), ).Filter( Filter().Terms("repository.has_wiki", true), ).Result(c) if out == nil || &out.Hits == nil { t.Fail() return } expectedDocs := 7 expectedTotal := 7 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedTotal, fmt.Sprintf("Should have %v total= %v", expectedTotal, out.Hits.Total)) }
func TestSearchSimple(t *testing.T) { c := NewTestConn() // searching without faceting qry := Search("github").Pretty().Query( Query().Search("add"), ) out, _ := qry.Result(c) // how many different docs used the word "add" expectedDocs := 10 expectedHits := 494 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total= %v", expectedHits, out.Hits.Total)) // now the same result from a "Simple" search out, _ = Search("github").Search("add").Result(c) assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total= %v", expectedHits, out.Hits.Total)) }
func TestBulkIndexerBasic(t *testing.T) { testIndex := "users" var ( buffers = make([]*bytes.Buffer, 0) totalBytesSent int messageSets int ) InitTests(true) c := NewTestConn() c.DeleteIndex(testIndex) indexer := c.NewBulkIndexer(3) indexer.Sender = func(buf *bytes.Buffer) error { messageSets += 1 totalBytesSent += buf.Len() buffers = append(buffers, buf) // log.Printf("buffer:%s", string(buf.Bytes())) return indexer.Send(buf) } indexer.Start() date := time.Unix(1257894000, 0) data := map[string]interface{}{ "name": "smurfs", "age": 22, "date": "yesterday", } err := indexer.Index(testIndex, "user", "1", "", &date, data, true) waitFor(func() bool { return len(buffers) > 0 }, 5) // part of request is url, so lets factor that in //totalBytesSent = totalBytesSent - len(*eshost) assert.T(t, len(buffers) == 1, fmt.Sprintf("Should have sent one operation but was %d", len(buffers))) assert.T(t, indexer.NumErrors() == 0 && err == nil, fmt.Sprintf("Should not have any errors. NumErrors: %v, err: %v", indexer.NumErrors(), err)) expectedBytes := 144 assert.T(t, totalBytesSent == expectedBytes, fmt.Sprintf("Should have sent %v bytes but was %v", expectedBytes, totalBytesSent)) err = indexer.Index(testIndex, "user", "2", "", nil, data, true) <-time.After(time.Millisecond * 10) // we need to wait for doc to hit send channel // this will test to ensure that Flush actually catches a doc indexer.Flush() totalBytesSent = totalBytesSent - len(*eshost) assert.T(t, err == nil, fmt.Sprintf("Should have nil error =%v", err)) assert.T(t, len(buffers) == 2, fmt.Sprintf("Should have another buffer ct=%d", len(buffers))) assert.T(t, indexer.NumErrors() == 0, fmt.Sprintf("Should not have any errors %d", indexer.NumErrors())) expectedBytes = 250 // with refresh assert.T(t, closeInt(totalBytesSent, expectedBytes), fmt.Sprintf("Should have sent %v bytes but was %v", expectedBytes, totalBytesSent)) indexer.Stop() }
func TestSearchMissingExists(t *testing.T) { c := NewTestConn() // search for docs that are missing repository.name qry := Search("github").Filter( Filter().Exists("repository.name"), ) out, _ := qry.Result(c) expectedDocs := 10 expectedTotal := 7695 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedTotal, fmt.Sprintf("Should have %v total= %v", expectedTotal, out.Hits.Total)) qry = Search("github").Filter( Filter().Missing("repository.name"), ) out, _ = qry.Result(c) expectedDocs = 10 expectedTotal = 390 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedTotal, fmt.Sprintf("Should have %v total= %v", expectedTotal, out.Hits.Total)) }
func TestSearchFacetRange(t *testing.T) { c := NewTestConn() // ok, now lets try facet but on actor field with a range qry := Search("github").Pretty().Facet( Facet().Fields("actor").Size("500"), ).Query( Query().Search("add"), ) out, err := qry.Result(c) assert.T(t, out != nil && err == nil, t, "Should have output") if out == nil { t.Fail() return } //log.Println(string(out.Facets)) h := gou.NewJsonHelper(out.Facets) expectedActorTotal := 521 // how many different docs used the word "add", during entire time range assert.T(t, h.Int("actor.total") == expectedActorTotal, fmt.Sprintf("Should have %v results %v", expectedActorTotal, h.Int("actor.total"))) // make sure size worked expectedTerms := 366 assert.T(t, len(h.List("actor.terms")) == expectedTerms, fmt.Sprintf("Should have %v unique userids, %v", expectedTerms, len(h.List("actor.terms")))) // ok, repeat but with a range showing different results qry = Search("github").Pretty().Facet( Facet().Fields("actor").Size("500"), ).Query( Query().Range( Range().Field("created_at").From("2012-12-10T15:00:00-08:00").To("2012-12-10T15:10:00-08:00"), ).Search("add"), ) out, err = qry.Result(c) assert.T(t, out != nil && err == nil, t, "Should have output") if out == nil { t.Fail() return } //log.Println(string(out.Facets)) h = gou.NewJsonHelper(out.Facets) // how many different events used the word "add", during time range? expectedActorTotal = 97 expectedTerms = 71 assert.T(t, h.Int("actor.total") == expectedActorTotal, fmt.Sprintf("Should have %v results %v", expectedActorTotal, h.Int("actor.total"))) // make sure size worked assert.T(t, len(h.List("actor.terms")) == expectedTerms, fmt.Sprintf("Should have %v event types, %v", expectedTerms, len(h.List("actor.terms")))) }
func TestFacetRegex(t *testing.T) { c := NewTestConn() // This is a possible solution for auto-complete out, _ := Search("github").Size("0").Facet( Facet().Regex("repository.name", "no.*").Size("8"), ).Result(c) if out == nil || &out.Hits == nil { t.Fail() return } //Debug(string(out.Facets)) fh := gou.NewJsonHelper([]byte(out.Facets)) facets := fh.Helpers("/repository.name/terms") assert.T(t, len(facets) == 8, fmt.Sprintf("Should have 8? but was %v", len(facets))) // for _, f := range facets { // Debug(f) // } }
func TestQueryString(t *testing.T) { // Test nil argument s, err := Escape(nil) assert.T(t, s == "" && err == nil, fmt.Sprintf("Nil should not fail and yield empty string")) // Test single string argument s, err = Escape(map[string]interface{}{"foo": "bar"}) exp := "foo=bar" assert.T(t, s == exp && err == nil, fmt.Sprintf("Expected %s, got: %s", exp, s)) // Test single int argument s, err = Escape(map[string]interface{}{"foo": 1}) exp = "foo=1" assert.T(t, s == exp && err == nil, fmt.Sprintf("Expected %s, got: %s", exp, s)) // Test single float argument s, err = Escape(map[string]interface{}{"foo": 3.141592}) exp = "foo=3.141592" assert.T(t, s == exp && err == nil, fmt.Sprintf("Expected %s, got: %s", exp, s)) // Test single []string argument s, err = Escape(map[string]interface{}{"foo": []string{"bar", "baz"}}) exp = "foo=bar%2Cbaz" assert.T(t, s == exp && err == nil, fmt.Sprintf("Expected %s, got: %s", exp, s)) // Test combination of all arguments s, err = Escape(map[string]interface{}{ "foo": "bar", "bar": 1, "baz": 3.141592, "test": []string{"a", "b"}, }) // url.Values also orders arguments alphabetically. exp = "bar=1&baz=3.141592&foo=bar&test=a%2Cb" assert.T(t, s == exp && err == nil, fmt.Sprintf("Expected %s, got: %s", exp, s)) // Test invalid datatype s, err = Escape(map[string]interface{}{"foo": []int{}}) assert.T(t, err != nil, fmt.Sprintf("Expected err to not be nil")) }
func TestFilters(t *testing.T) { c := NewTestConn() // search for docs that are missing repository.name qry := Search("github").Filter( Filter().Exists("repository.name"), ) out, err := qry.Result(c) assert.T(t, err == nil, t, "should not have error") expectedDocs := 10 expectedHits := 7695 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total got %v", expectedHits, out.Hits.Total)) qry = Search("github").Filter( Filter().Missing("repository.name"), ) expectedHits = 390 out, _ = qry.Result(c) assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total got %v", expectedHits, out.Hits.Total)) //actor_attributes: {type: "User", qry = Search("github").Filter( Filter().Terms("actor_attributes.location", "portland"), ) out, _ = qry.Result(c) expectedDocs = 10 expectedHits = 71 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total got %v", expectedHits, out.Hits.Total)) /* Should this be an AND by default? */ qry = Search("github").Filter( Filter().Terms("actor_attributes.location", "portland"), Filter().Terms("repository.has_wiki", true), ) out, err = qry.Result(c) expectedDocs = 10 expectedHits = 44 assert.T(t, err == nil, t, "should not have error") assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total got %v", expectedHits, out.Hits.Total)) // NOW, lets try with two query calls instead of one qry = Search("github").Filter( Filter().Terms("actor_attributes.location", "portland"), ) qry.Filter( Filter().Terms("repository.has_wiki", true), ) out, err = qry.Result(c) //gou.Debug(out) assert.T(t, err == nil, t, "should not have error") assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total got %v", expectedHits, out.Hits.Total)) qry = Search("github").Filter( "or", Filter().Terms("actor_attributes.location", "portland"), Filter().Terms("repository.has_wiki", true), ) out, err = qry.Result(c) expectedHits = 6676 assert.T(t, err == nil, t, "should not have error") assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs got %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedHits, fmt.Sprintf("Should have %v total got %v", expectedHits, out.Hits.Total)) }
func TestSearchFacetOne(t *testing.T) { /* A faceted search for what "type" of events there are - since we are not specifying an elasticsearch type it searches all () { "terms" : { "_type" : "terms", "missing" : 0, "total" : 7561, "other" : 0, "terms" : [ { "term" : "pushevent", "count" : 4185 }, { "term" : "createevent", "count" : 786 }.....] } } */ c := NewTestConn() qry := Search("github").Pretty().Facet( Facet().Fields("type").Size("25"), ).Query( Query().All(), ).Size("1") out, err := qry.Result(c) //log.Println(string(out.Facets)) //gou.Debug(out) assert.T(t, out != nil && err == nil, "Should have output") if out == nil { t.Fail() return } h := gou.NewJsonHelper(out.Facets) expectedTotal := 8084 expectedTerms := 16 assert.T(t, h.Int("type.total") == expectedTotal, fmt.Sprintf("Should have %v results %v", expectedTotal, h.Int("type.total"))) assert.T(t, len(h.List("type.terms")) == expectedTerms, fmt.Sprintf("Should have %v event types, %v", expectedTerms, len(h.List("type.terms")))) // Now, lets try changing size to 10 qry.FacetVal.Size("10") out, err = qry.Result(c) h = gou.NewJsonHelper(out.Facets) // still same doc count assert.T(t, h.Int("type.total") == expectedTotal, fmt.Sprintf("Should have %v results %v", expectedTotal, h.Int("type.total"))) // make sure size worked expectedTerms = 10 assert.T(t, len(h.List("type.terms")) == expectedTerms, fmt.Sprintf("Should have %v event types, got %v", expectedTerms, len(h.List("type.terms")))) // now, lets add a type (out of the 16) out, _ = Search("github").Type("IssueCommentEvent").Pretty().Facet( Facet().Fields("type").Size("25"), ).Query( Query().All(), ).Result(c) h = gou.NewJsonHelper(out.Facets) //log.Println(string(out.Facets)) // still same doc count expectedTotal = 685 assert.T(t, h.Int("type.total") == expectedTotal, fmt.Sprintf("Should have %v results %v", expectedTotal, h.Int("type.total"))) // we should only have one facettype because we limited to one type assert.T(t, len(h.List("type.terms")) == 1, fmt.Sprintf("Should have 1 event types, %v", len(h.List("type.terms")))) // now, add a second type (chained) out, _ = Search("github").Type("IssueCommentEvent").Type("PushEvent").Pretty().Facet( Facet().Fields("type").Size("25"), ).Query( Query().All(), ).Result(c) h = gou.NewJsonHelper(out.Facets) // still same doc count expectedTotal = 4941 expectedTerms = 2 assert.T(t, h.Int("type.total") == expectedTotal, fmt.Sprintf("Should have %v results %v", expectedTotal, h.Int("type.total"))) // make sure we now have 2 types assert.T(t, len(h.List("type.terms")) == expectedTerms, fmt.Sprintf("Should have %v event types, %v", expectedTerms, len(h.List("type.terms")))) //and instead of faceting on type, facet on userid // now, add a second type (chained) out, _ = Search("github").Type("IssueCommentEvent,PushEvent").Pretty().Facet( Facet().Fields("actor").Size("500"), ).Query( Query().All(), ).Result(c) h = gou.NewJsonHelper(out.Facets) // still same doc count expectedTotal = 5168 expectedTerms = 500 assert.T(t, h.Int("actor.total") == expectedTotal, t, fmt.Sprintf("Should have %v results %v", expectedTotal, h.Int("actor.total"))) // make sure size worked assert.T(t, len(h.List("actor.terms")) == expectedTerms, t, fmt.Sprintf("Should have %v users, %v", expectedTerms, len(h.List("actor.terms")))) }
func TestGetAll(t *testing.T) { InitTests(true) c := NewTestConn() nodesInfo, err := c.AllNodesInfo() assert.T(t, err == nil, fmt.Sprintf("should not have gotten error, received: %v", err)) assert.T(t, nodesInfo.ClusterName != "", fmt.Sprintf("clustername should have been not empty. received: %q", nodesInfo.ClusterName)) for _, node := range nodesInfo.Nodes { assert.T(t, node.Settings != nil, fmt.Sprintf("Settings should not have been null")) assert.T(t, node.OS != nil, fmt.Sprintf("OS should not have been null")) assert.T(t, node.Process != nil, fmt.Sprintf("Process should not have been null")) assert.T(t, node.JVM != nil, fmt.Sprintf("JVM should not have been null")) assert.T(t, node.ThreadPool != nil, fmt.Sprintf("ThreadPool should not have been null")) assert.T(t, node.Network != nil, fmt.Sprintf("Network should not have been null")) assert.T(t, node.Transport != nil, fmt.Sprintf("Transport should not have been null")) assert.T(t, node.Http != nil, fmt.Sprintf("Http should not have been null")) assert.T(t, node.Plugins != nil, fmt.Sprintf("Plugins should not have been null")) } }
func TestSearchSortOrder(t *testing.T) { c := NewTestConn() // ok, now lets try sorting by repository watchers descending qry := Search("github").Pretty().Query( Query().All(), ).Sort( Sort("repository.watchers").Desc(), ) out, _ := qry.Result(c) // how many different docs used the word "add", during entire time range expectedDocs := 10 expectedTotal := 8085 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedTotal, fmt.Sprintf("Should have %v total= %v", expectedTotal, out.Hits.Total)) b, err := out.Hits.Hits[0].Source.MarshalJSON() assert.T(t, err == nil, fmt.Sprintf("Should not have returned an error: %v", err)) h1 := gou.NewJsonHelper(b) assert.T(t, h1.Int("repository.watchers") == 41377, fmt.Sprintf("Should have 41377 watchers= %v", h1.Int("repository.watchers"))) // ascending out, _ = Search("github").Pretty().Query( Query().All(), ).Sort( Sort("repository.watchers"), ).Result(c) // how many different docs used the word "add", during entire time range assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedTotal, fmt.Sprintf("Should have %v total got %v", expectedTotal, out.Hits.Total)) b, err = out.Hits.Hits[0].Source.MarshalJSON() assert.T(t, err == nil, fmt.Sprintf("Should not have returned an error: %v", err)) h2 := gou.NewJsonHelper(b) assert.T(t, h2.Int("repository.watchers") == 0, fmt.Sprintf("Should have 0 watchers= %v", h2.Int("repository.watchers"))) // sort descending with search out, _ = Search("github").Pretty().Size("5").Query( Query().Search("python"), ).Sort( Sort("repository.watchers").Desc(), ).Result(c) // how many different docs used the word "add", during entire time range expectedDocs = 5 expectedTotal = 734 assert.T(t, out.Hits.Len() == expectedDocs, fmt.Sprintf("Should have %v docs %v", expectedDocs, out.Hits.Len())) assert.T(t, out.Hits.Total == expectedTotal, fmt.Sprintf("Should have %v total got %v", expectedTotal, out.Hits.Total)) b, err = out.Hits.Hits[0].Source.MarshalJSON() assert.T(t, err == nil, fmt.Sprintf("Should not have returned an error: %v", err)) h3 := gou.NewJsonHelper(b) watchers := 8659 assert.T(t, h3.Int("repository.watchers") == watchers, fmt.Sprintf("Should have %v watchers, got %v", watchers, h3.Int("repository.watchers"))) }