Debian Codegraph @

reindex_test.go

raw
1 // Copyright 2012-present Oliver Eilhard. All rights reserved.
2 // Use of this source code is governed by a MIT-license.
3 // See http://olivere.mit-license.org/license.txt for details.
4
5 package elastic
6
7 import (
8 "context"
9 "encoding/json"
10 "testing"
11 )
12
13 func TestReindexSourceWithBodyMap(t *testing.T) {
14 client := setupTestClient(t)
15 out, err := client.Reindex().Body(map[string]interface{}{
16 "source": map[string]interface{}{
17 "index": "twitter",
18 },
19 "dest": map[string]interface{}{
20 "index": "new_twitter",
21 },
22 }).getBody()
23 if err != nil {
24 t.Fatal(err)
25 }
26 b, err := json.Marshal(out)
27 if err != nil {
28 t.Fatal(err)
29 }
30 got := string(b)
31 want := `{"dest":{"index":"new_twitter"},"source":{"index":"twitter"}}`
32 if got != want {
33 t.Fatalf("\ngot %s\nwant %s", got, want)
34 }
35 }
36
37 func TestReindexSourceWithBodyString(t *testing.T) {
38 client := setupTestClient(t)
39 got, err := client.Reindex().Body(`{"source":{"index":"twitter"},"dest":{"index":"new_twitter"}}`).getBody()
40 if err != nil {
41 t.Fatal(err)
42 }
43 want := `{"source":{"index":"twitter"},"dest":{"index":"new_twitter"}}`
44 if got != want {
45 t.Fatalf("\ngot %s\nwant %s", got, want)
46 }
47 }
48
49 func TestReindexSourceWithSourceIndexAndDestinationIndex(t *testing.T) {
50 client := setupTestClient(t)
51 out, err := client.Reindex().SourceIndex("twitter").DestinationIndex("new_twitter").getBody()
52 if err != nil {
53 t.Fatal(err)
54 }
55 b, err := json.Marshal(out)
56 if err != nil {
57 t.Fatal(err)
58 }
59 got := string(b)
60 want := `{"dest":{"index":"new_twitter"},"source":{"index":"twitter"}}`
61 if got != want {
62 t.Fatalf("\ngot %s\nwant %s", got, want)
63 }
64 }
65
66 func TestReindexSourceWithSourceAndDestinationAndVersionType(t *testing.T) {
67 client := setupTestClient(t)
68 src := NewReindexSource().Index("twitter")
69 dst := NewReindexDestination().Index("new_twitter").VersionType("external")
70 out, err := client.Reindex().Source(src).Destination(dst).getBody()
71 if err != nil {
72 t.Fatal(err)
73 }
74 b, err := json.Marshal(out)
75 if err != nil {
76 t.Fatal(err)
77 }
78 got := string(b)
79 want := `{"dest":{"index":"new_twitter","version_type":"external"},"source":{"index":"twitter"}}`
80 if got != want {
81 t.Fatalf("\ngot %s\nwant %s", got, want)
82 }
83 }
84
85 func TestReindexSourceWithSourceAndRemoteAndDestination(t *testing.T) {
86 client := setupTestClient(t)
87 src := NewReindexSource().Index("twitter").RemoteInfo(
88 NewReindexRemoteInfo().Host("http://otherhost:9200").
89 Username("alice").
90 Password("secret").
91 ConnectTimeout("10s").
92 SocketTimeout("1m"),
93 )
94 dst := NewReindexDestination().Index("new_twitter")
95 out, err := client.Reindex().Source(src).Destination(dst).getBody()
96 if err != nil {
97 t.Fatal(err)
98 }
99 b, err := json.Marshal(out)
100 if err != nil {
101 t.Fatal(err)
102 }
103 got := string(b)
104 want := `{"dest":{"index":"new_twitter"},"source":{"index":"twitter","remote":{"connect_timeout":"10s","host":"http://otherhost:9200","password":"secret","socket_timeout":"1m","username":"alice"}}}`
105 if got != want {
106 t.Fatalf("\ngot %s\nwant %s", got, want)
107 }
108 }
109
110 func TestReindexSourceWithSourceAndDestinationAndOpType(t *testing.T) {
111 client := setupTestClient(t)
112 src := NewReindexSource().Index("twitter")
113 dst := NewReindexDestination().Index("new_twitter").OpType("create")
114 out, err := client.Reindex().Source(src).Destination(dst).getBody()
115 if err != nil {
116 t.Fatal(err)
117 }
118 b, err := json.Marshal(out)
119 if err != nil {
120 t.Fatal(err)
121 }
122 got := string(b)
123 want := `{"dest":{"index":"new_twitter","op_type":"create"},"source":{"index":"twitter"}}`
124 if got != want {
125 t.Fatalf("\ngot %s\nwant %s", got, want)
126 }
127 }
128
129 func TestReindexSourceWithConflictsProceed(t *testing.T) {
130 client := setupTestClient(t)
131 src := NewReindexSource().Index("twitter")
132 dst := NewReindexDestination().Index("new_twitter").OpType("create")
133 out, err := client.Reindex().Conflicts("proceed").Source(src).Destination(dst).getBody()
134 if err != nil {
135 t.Fatal(err)
136 }
137 b, err := json.Marshal(out)
138 if err != nil {
139 t.Fatal(err)
140 }
141 got := string(b)
142 want := `{"conflicts":"proceed","dest":{"index":"new_twitter","op_type":"create"},"source":{"index":"twitter"}}`
143 if got != want {
144 t.Fatalf("\ngot %s\nwant %s", got, want)
145 }
146 }
147
148 func TestReindexSourceWithProceedOnVersionConflict(t *testing.T) {
149 client := setupTestClient(t)
150 src := NewReindexSource().Index("twitter")
151 dst := NewReindexDestination().Index("new_twitter").OpType("create")
152 out, err := client.Reindex().ProceedOnVersionConflict().Source(src).Destination(dst).getBody()
153 if err != nil {
154 t.Fatal(err)
155 }
156 b, err := json.Marshal(out)
157 if err != nil {
158 t.Fatal(err)
159 }
160 got := string(b)
161 want := `{"conflicts":"proceed","dest":{"index":"new_twitter","op_type":"create"},"source":{"index":"twitter"}}`
162 if got != want {
163 t.Fatalf("\ngot %s\nwant %s", got, want)
164 }
165 }
166
167 func TestReindexSourceWithQuery(t *testing.T) {
168 client := setupTestClient(t)
169 src := NewReindexSource().Index("twitter").Type("tweet").Query(NewTermQuery("user", "olivere"))
170 dst := NewReindexDestination().Index("new_twitter")
171 out, err := client.Reindex().Source(src).Destination(dst).getBody()
172 if err != nil {
173 t.Fatal(err)
174 }
175 b, err := json.Marshal(out)
176 if err != nil {
177 t.Fatal(err)
178 }
179 got := string(b)
180 want := `{"dest":{"index":"new_twitter"},"source":{"index":"twitter","query":{"term":{"user":"olivere"}},"type":"tweet"}}`
181 if got != want {
182 t.Fatalf("\ngot %s\nwant %s", got, want)
183 }
184 }
185
186 func TestReindexSourceWithMultipleSourceIndicesAndTypes(t *testing.T) {
187 client := setupTestClient(t)
188 src := NewReindexSource().Index("twitter", "blog").Type("tweet", "post")
189 dst := NewReindexDestination().Index("all_together")
190 out, err := client.Reindex().Source(src).Destination(dst).getBody()
191 if err != nil {
192 t.Fatal(err)
193 }
194 b, err := json.Marshal(out)
195 if err != nil {
196 t.Fatal(err)
197 }
198 got := string(b)
199 want := `{"dest":{"index":"all_together"},"source":{"index":["twitter","blog"],"type":["tweet","post"]}}`
200 if got != want {
201 t.Fatalf("\ngot %s\nwant %s", got, want)
202 }
203 }
204
205 func TestReindexSourceWithSourceAndSize(t *testing.T) {
206 client := setupTestClient(t)
207 src := NewReindexSource().Index("twitter").Sort("date", false)
208 dst := NewReindexDestination().Index("new_twitter")
209 out, err := client.Reindex().Size(10000).Source(src).Destination(dst).getBody()
210 if err != nil {
211 t.Fatal(err)
212 }
213 b, err := json.Marshal(out)
214 if err != nil {
215 t.Fatal(err)
216 }
217 got := string(b)
218 want := `{"dest":{"index":"new_twitter"},"size":10000,"source":{"index":"twitter","sort":[{"date":{"order":"desc"}}]}}`
219 if got != want {
220 t.Fatalf("\ngot %s\nwant %s", got, want)
221 }
222 }
223
224 func TestReindexSourceWithScript(t *testing.T) {
225 client := setupTestClient(t)
226 src := NewReindexSource().Index("twitter")
227 dst := NewReindexDestination().Index("new_twitter").VersionType("external")
228 scr := NewScriptInline("if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}")
229 out, err := client.Reindex().Source(src).Destination(dst).Script(scr).getBody()
230 if err != nil {
231 t.Fatal(err)
232 }
233 b, err := json.Marshal(out)
234 if err != nil {
235 t.Fatal(err)
236 }
237 got := string(b)
238 want := `{"dest":{"index":"new_twitter","version_type":"external"},"script":{"inline":"if (ctx._source.foo == 'bar') {ctx._version++; ctx._source.remove('foo')}"},"source":{"index":"twitter"}}`
239 if got != want {
240 t.Fatalf("\ngot %s\nwant %s", got, want)
241 }
242 }
243
244 func TestReindexSourceWithRouting(t *testing.T) {
245 client := setupTestClient(t)
246 src := NewReindexSource().Index("source").Query(NewMatchQuery("company", "cat"))
247 dst := NewReindexDestination().Index("dest").Routing("=cat")
248 out, err := client.Reindex().Source(src).Destination(dst).getBody()
249 if err != nil {
250 t.Fatal(err)
251 }
252 b, err := json.Marshal(out)
253 if err != nil {
254 t.Fatal(err)
255 }
256 got := string(b)
257 want := `{"dest":{"index":"dest","routing":"=cat"},"source":{"index":"source","query":{"match":{"company":{"query":"cat"}}}}}`
258 if got != want {
259 t.Fatalf("\ngot %s\nwant %s", got, want)
260 }
261 }
262
263 func TestReindex(t *testing.T) {
264 client := setupTestClientAndCreateIndexAndAddDocs(t) // , SetTraceLog(log.New(os.Stdout, "", 0)))
265 esversion, err := client.ElasticsearchVersion(DefaultURL)
266 if err != nil {
267 t.Fatal(err)
268 }
269 if esversion < "2.3.0" {
270 t.Skipf("Elasticsearch %v does not support Reindex API yet", esversion)
271 }
272
273 sourceCount, err := client.Count(testIndexName).Do(context.TODO())
274 if err != nil {
275 t.Fatal(err)
276 }
277 if sourceCount <= 0 {
278 t.Fatalf("expected more than %d documents; got: %d", 0, sourceCount)
279 }
280
281 targetCount, err := client.Count(testIndexName2).Do(context.TODO())
282 if err != nil {
283 t.Fatal(err)
284 }
285 if targetCount != 0 {
286 t.Fatalf("expected %d documents; got: %d", 0, targetCount)
287 }
288
289 // Simple copying
290 src := NewReindexSource().Index(testIndexName)
291 dst := NewReindexDestination().Index(testIndexName2)
292 res, err := client.Reindex().Source(src).Destination(dst).Refresh("true").Do(context.TODO())
293 if err != nil {
294 t.Fatal(err)
295 }
296 if res == nil {
297 t.Fatal("expected result != nil")
298 }
299 if res.Total != sourceCount {
300 t.Errorf("expected %d, got %d", sourceCount, res.Total)
301 }
302 if res.Updated != 0 {
303 t.Errorf("expected %d, got %d", 0, res.Updated)
304 }
305 if res.Created != sourceCount {
306 t.Errorf("expected %d, got %d", sourceCount, res.Created)
307 }
308
309 targetCount, err = client.Count(testIndexName2).Do(context.TODO())
310 if err != nil {
311 t.Fatal(err)
312 }
313 if targetCount != sourceCount {
314 t.Fatalf("expected %d documents; got: %d", sourceCount, targetCount)
315 }
316 }
317
318 func TestReindexAsync(t *testing.T) {
319 client := setupTestClientAndCreateIndexAndAddDocs(t) //, SetTraceLog(log.New(os.Stdout, "", 0)))
320 esversion, err := client.ElasticsearchVersion(DefaultURL)
321 if err != nil {
322 t.Fatal(err)
323 }
324 if esversion < "2.3.0" {
325 t.Skipf("Elasticsearch %v does not support Reindex API yet", esversion)
326 }
327
328 sourceCount, err := client.Count(testIndexName).Do(context.TODO())
329 if err != nil {
330 t.Fatal(err)
331 }
332 if sourceCount <= 0 {
333 t.Fatalf("expected more than %d documents; got: %d", 0, sourceCount)
334 }
335
336 targetCount, err := client.Count(testIndexName2).Do(context.TODO())
337 if err != nil {
338 t.Fatal(err)
339 }
340 if targetCount != 0 {
341 t.Fatalf("expected %d documents; got: %d", 0, targetCount)
342 }
343
344 // Simple copying
345 src := NewReindexSource().Index(testIndexName)
346 dst := NewReindexDestination().Index(testIndexName2)
347 res, err := client.Reindex().Source(src).Destination(dst).DoAsync(context.TODO())
348 if err != nil {
349 t.Fatal(err)
350 }
351 if res == nil {
352 t.Fatal("expected result != nil")
353 }
354 if res.TaskId == "" {
355 t.Errorf("expected a task id, got %+v", res)
356 }
357
358 tasksGetTask := client.TasksGetTask()
359 taskStatus, err := tasksGetTask.TaskId(res.TaskId).Do(context.TODO())
360 if err != nil {
361 t.Fatal(err)
362 }
363 if taskStatus == nil {
364 t.Fatal("expected task status result != nil")
365 }
366 }
367
368 func TestReindexWithWaitForCompletionTrueCannotBeStarted(t *testing.T) {
369 client := setupTestClientAndCreateIndexAndAddDocs(t)
370 esversion, err := client.ElasticsearchVersion(DefaultURL)
371 if err != nil {
372 t.Fatal(err)
373 }
374 if esversion < "2.3.0" {
375 t.Skipf("Elasticsearch %v does not support Reindex API yet", esversion)
376 }
377
378 sourceCount, err := client.Count(testIndexName).Do(context.TODO())
379 if err != nil {
380 t.Fatal(err)
381 }
382 if sourceCount <= 0 {
383 t.Fatalf("expected more than %d documents; got: %d", 0, sourceCount)
384 }
385
386 targetCount, err := client.Count(testIndexName2).Do(context.TODO())
387 if err != nil {
388 t.Fatal(err)
389 }
390 if targetCount != 0 {
391 t.Fatalf("expected %d documents; got: %d", 0, targetCount)
392 }
393
394 // DoAsync should fail when WaitForCompletion is true
395 src := NewReindexSource().Index(testIndexName)
396 dst := NewReindexDestination().Index(testIndexName2)
397 _, err = client.Reindex().Source(src).Destination(dst).WaitForCompletion(true).DoAsync(context.TODO())
398 if err == nil {
399 t.Fatal("error should have been returned")
400 }
401 }