func (suite *EsTester) SetUpIndex() elasticsearch.IIndex { t := suite.T() assert := assert.New(t) var esi *elasticsearch.Index var err error var ok bool { esi, err = elasticsearch.NewIndex2(suite.url, "estest$"+uniq(), "") assert.NoError(err) err = esi.Delete() //assert.NoError(err) ok, err = esi.IndexExists() assert.NoError(err) assert.False(ok) // make the index err = esi.Create("") assert.NoError(err) ok, err = esi.IndexExists() assert.NoError(err) assert.True(ok) err = esi.SetMapping(objType, objMapping) assert.NoError(err) } // populate the index for _, o := range objs { indexResult, err := esi.PostData(objType, o.ID, o) assert.NoError(err) assert.NotNil(indexResult) } // allow the database time to settle pollingFn := elasticsearch.GetData(func() (bool, error) { getResult, err := esi.FilterByMatchAll(objType, nil) if err != nil { return false, err } if getResult != nil && len(*getResult.GetHits()) == len(objs) { return true, nil } return false, nil }) { _, err := elasticsearch.PollFunction(pollingFn) assert.NoError(err) } return esi }
func (suite *EsTester) Test01Client() { t := suite.T() assert := assert.New(t) esi, err := elasticsearch.NewIndex2(suite.url, "estest01$", "") assert.NoError(err) version := esi.GetVersion() assert.NoError(err) assert.True(strings.HasPrefix(version, "2.2") || strings.HasPrefix(version, "2.3") || strings.HasPrefix(version, "2.4")) }
func (suite *EsTester) Test10GetAll() { t := suite.T() assert := assert.New(t) esi, err := elasticsearch.NewIndex2(suite.url, "getall$", "") assert.NoError(err) defer closer(t, esi) // make the index err = esi.Create("") assert.NoError(err) type T1 struct { Data1 string `json:"data1" binding:"required"` Extra1 string `json:"extra1" binding:"required"` } type T2 struct { Data2 int `json:"data2" binding:"required"` Extra2 string `json:"extra2" binding:"required"` } schema1 := `{ "schema1":{ "properties":{ "data1":{ "type":"string", "store":true }, "extra1":{ "type":"string", "store":true } } } }` schema2 := `{ "schema2":{ "properties":{ "data2":{ "type":"integer", "store":true }, "extra2":{ "type":"string", "store":true } } } }` err = esi.SetMapping("schema1", piazza.JsonString(schema1)) assert.NoError(err) err = esi.SetMapping("schema2", piazza.JsonString(schema2)) assert.NoError(err) obj1 := T1{Data1: "obj", Extra1: "extra1"} obj2 := T2{Data2: 123, Extra2: "extra2"} indexResult, err := esi.PostData("schema1", "id1", obj1) assert.NoError(err) assert.NotNil(indexResult) indexResult, err = esi.PostData("schema2", "id2", obj2) assert.NoError(err) assert.NotNil(indexResult) { // GET a specific one getResult, err := esi.GetByID("schema1", "id1") assert.NoError(err) assert.NotNil(getResult) src := getResult.Source assert.NotNil(src) var tmp T1 err = json.Unmarshal(*src, &tmp) assert.NoError(err) assert.EqualValues("obj", tmp.Data1) } { // GET a specific one getResult, err := esi.GetByID("schema2", "id2") assert.NoError(err) assert.NotNil(getResult) src := getResult.Source assert.NotNil(src) var tmp T2 err = json.Unmarshal(*src, &tmp) assert.NoError(err) assert.Equal(123, tmp.Data2) } { // GET the types strs, err := esi.GetTypes() assert.NoError(err) assert.Len(strs, 2) if strs[0] == "schema1" { assert.EqualValues("schema2", strs[1]) } else if strs[0] == "schema2" { assert.EqualValues("schema1", strs[1]) } else { assert.True(false) } } { pollingFn := elasticsearch.GetData(func() (bool, error) { getResult, err := esi.FilterByMatchAll("", nil) if err != nil { return false, err } if getResult != nil && len(*getResult.GetHits()) == 2 { return true, nil } return false, nil }) _, err := elasticsearch.PollFunction(pollingFn) getResult, err := esi.FilterByMatchAll("", nil) assert.NoError(err) assert.NotNil(getResult) assert.Len(*getResult.GetHits(), 2) src1 := getResult.GetHit(0).Source assert.NotNil(src1) src2 := getResult.GetHit(1).Source assert.NotNil(src2) var tmp1 T1 var tmp2 T2 err1 := json.Unmarshal(*src1, &tmp1) err2 := json.Unmarshal(*src2, &tmp2) assert.True((err1 == nil && err2 == nil) || (err1 != nil && err2 != nil)) if err1 != nil { err = json.Unmarshal(*src1, &tmp1) assert.NoError(err) err = json.Unmarshal(*src2, &tmp2) assert.NoError(err) } else { err = json.Unmarshal(*src1, &tmp2) assert.NoError(err) err = json.Unmarshal(*src2, &tmp1) assert.NoError(err) } assert.Equal(tmp1.Data1, "obj") assert.Equal(tmp1.Extra1, "extra1") assert.Equal(tmp2.Data2, 123) assert.Equal(tmp2.Extra2, "extra2") } }
func (suite *EsTester) Test09FullPercolation() { t := suite.T() assert := assert.New(t) var esi elasticsearch.IIndex // create index { var err error esi, err = elasticsearch.NewIndex2(suite.url, "estest09$"+uniq(), "") assert.NoError(err) defer closer(t, esi) // make the index err = esi.Create("") assert.NoError(err) ok, err := esi.IndexExists() assert.NoError(err) assert.True(ok) } //----------------------------------------------------------------------- addMappings := func(maps map[string](map[string]elasticsearch.MappingElementTypeName)) { for k, v := range maps { jsn, err := elasticsearch.ConstructMappingSchema(k, v) assert.NoError(err) assert.NotEmpty(jsn) err = esi.SetMapping(k, jsn) assert.NoError(err) } } addQueries := func(queries map[string]piazza.JsonString) { for k, v := range queries { _, err := esi.AddPercolationQuery(k, v) assert.NoError(err) } } type TestCase struct { typeName string event interface{} expected []string } addEvents := func(tests []TestCase) { for i, t := range tests { percolateResponse, err := esi.AddPercolationDocument(t.typeName, t.event) assert.NoError(err) assert.EqualValues(len(t.expected), percolateResponse.Total, fmt.Sprintf("for test #%d", i)) matches := sortMatches(percolateResponse.Matches) for i, expected := range t.expected { assert.Equal(esi.IndexName(), matches[i].Index) assert.Equal(expected, matches[i].Id) } } } //----------------------------------------------------------------------- type EventType1 struct { ID string `json:"id" binding:"required"` Str string `json:"str" binding:"required"` Num int `json:"num" binding:"required"` } type EventType2 struct { ID string `json:"id" binding:"required"` Boo bool `json:"boo" binding:"required"` Num int `json:"num" binding:"required"` } maps := map[string](map[string]elasticsearch.MappingElementTypeName){ "EventType1": map[string]elasticsearch.MappingElementTypeName{ "id": elasticsearch.MappingElementTypeString, "str": elasticsearch.MappingElementTypeString, "num": elasticsearch.MappingElementTypeInteger, }, "EventType2": map[string]elasticsearch.MappingElementTypeName{ "id": elasticsearch.MappingElementTypeString, "boo": elasticsearch.MappingElementTypeBool, "num": elasticsearch.MappingElementTypeInteger, }, } addMappings(maps) //----------------------------------------------------------------------- q1 := `{ "query": { "match": { "str": { "query": "kitten" } } } }` q2 := `{ "query" : { "match" : { "boo" : true } } }` q3 := `{ "query" : { "match" : { "num" : 17 } } }` q4 := `{ "query" : { "range" : { "num" : { "lt": 10.0 } } } }` q5 := `{ "query" : { "filtered": { "query": { "match": { "num": 17 } }, "filter": { "term": { "_type": "EventType2" } } } } }` q6 := `{ "query" : { "bool": { "must": [ { "match" : { "num" : 17 } }, { "match" : { "_type" : "EventType1" } } ] } } }` queries := map[string]piazza.JsonString{ "Q1": piazza.JsonString(q1), "Q2": piazza.JsonString(q2), "Q3": piazza.JsonString(q3), "Q4": piazza.JsonString(q4), "Q5": piazza.JsonString(q5), "Q6": piazza.JsonString(q6), } addQueries(queries) //----------------------------------------------------------------------- tests := []TestCase{ TestCase{ typeName: "EventType1", event: EventType1{ID: "E1", Str: "kitten", Num: 17}, expected: []string{"Q1", "Q3", "Q6"}, }, TestCase{ typeName: "EventType2", event: EventType2{ID: "E2", Boo: true, Num: 17}, expected: []string{"Q2", "Q3", "Q5"}, }, TestCase{ typeName: "EventType1", event: EventType1{ID: "E3", Str: "lemur", Num: -31}, expected: []string{"Q4"}, }, } addEvents(tests) }