Dragonfly2

1
/*
2
 *     Copyright 2022 The Dragonfly Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *      http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package config
18

19
import (
20
	"errors"
21
	"net"
22
	"os"
23
	"path/filepath"
24
	"testing"
25
	"time"
26

27
	"github.com/stretchr/testify/assert"
28
	"go.uber.org/mock/gomock"
29
	"google.golang.org/grpc"
30
	"google.golang.org/grpc/codes"
31
	"google.golang.org/grpc/health"
32
	healthpb "google.golang.org/grpc/health/grpc_health_v1"
33
	"google.golang.org/grpc/resolver"
34
	"google.golang.org/grpc/status"
35

36
	managerv1 "d7y.io/api/v2/pkg/apis/manager/v1"
37

38
	"d7y.io/dragonfly/v2/pkg/rpc/manager/client/mocks"
39
)
40

41
func TestDynconfigManager_GetResolveSchedulerAddrs(t *testing.T) {
42
	grpcServer := grpc.NewServer()
43
	healthpb.RegisterHealthServer(grpcServer, health.NewServer())
44
	l, err := net.Listen("tcp", ":3000")
45
	if err != nil {
46
		t.Fatal(err)
47
	}
48
	defer l.Close()
49

50
	go func() {
51
		if err := grpcServer.Serve(l); err != nil {
52
			panic(err)
53
		}
54
	}()
55
	defer grpcServer.Stop()
56

57
	mockCacheDir := t.TempDir()
58
	mockCachePath := filepath.Join(mockCacheDir, cacheFileName)
59
	tests := []struct {
60
		name           string
61
		config         *DaemonOption
62
		data           *DynconfigData
63
		sleep          func()
64
		cleanFileCache func(t *testing.T)
65
		mock           func(m *mocks.MockV1MockRecorder, data *DynconfigData)
66
		expect         func(t *testing.T, dynconfig Dynconfig, data *DynconfigData)
67
	}{
68
		{
69
			name: "get cache scheduler ip addrs",
70
			config: &DaemonOption{
71
				Scheduler: SchedulerOption{
72
					Manager: ManagerOption{
73
						RefreshInterval: 10 * time.Second,
74
					},
75
				},
76
				Host: HostOption{
77
					Hostname: "foo",
78
				},
79
				ObjectStorage: ObjectStorageOption{
80
					Enable: true,
81
				},
82
			},
83
			data: &DynconfigData{
84
				Schedulers: []*managerv1.Scheduler{
85
					{
86
						Ip:   "127.0.0.1",
87
						Port: 3000,
88
					},
89
				},
90
			},
91
			sleep: func() {},
92
			cleanFileCache: func(t *testing.T) {
93
				if err := os.Remove(mockCachePath); err != nil {
94
					t.Fatal(err)
95
				}
96
			},
97
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
98
				gomock.InOrder(
99
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
100
						Schedulers: []*managerv1.Scheduler{
101
							{
102
								Ip:   data.Schedulers[0].Ip,
103
								Port: data.Schedulers[0].Port,
104
							},
105
						},
106
					}, nil).Times(1),
107
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
108
				)
109
			},
110
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
111
				assert := assert.New(t)
112
				result, err := dynconfig.GetResolveSchedulerAddrs()
113
				assert.NoError(err)
114
				assert.EqualValues(result, []resolver.Address{{ServerName: "127.0.0.1", Addr: "127.0.0.1:3000"}})
115
			},
116
		},
117
		{
118
			name: "get scheduler ip addrs",
119
			config: &DaemonOption{
120
				Scheduler: SchedulerOption{
121
					Manager: ManagerOption{
122
						RefreshInterval: 10 * time.Millisecond,
123
					},
124
				},
125
				Host: HostOption{
126
					Hostname: "foo",
127
				},
128
				ObjectStorage: ObjectStorageOption{
129
					Enable: true,
130
				},
131
			},
132
			data: &DynconfigData{
133
				Schedulers: []*managerv1.Scheduler{
134
					{
135
						Ip:   "127.0.0.1",
136
						Port: 3000,
137
					},
138
				},
139
			},
140
			sleep: func() {
141
				time.Sleep(100 * time.Millisecond)
142
			},
143
			cleanFileCache: func(t *testing.T) {
144
				if err := os.Remove(mockCachePath); err != nil {
145
					t.Fatal(err)
146
				}
147
			},
148
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
149
				gomock.InOrder(
150
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
151
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
152
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
153
						Schedulers: []*managerv1.Scheduler{
154
							{
155
								Ip:   data.Schedulers[0].Ip,
156
								Port: data.Schedulers[0].Port,
157
							},
158
						},
159
					}, nil).Times(1),
160
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
161
				)
162
			},
163
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
164
				assert := assert.New(t)
165
				result, err := dynconfig.GetResolveSchedulerAddrs()
166
				assert.NoError(err)
167
				assert.EqualValues(result, []resolver.Address{{ServerName: "127.0.0.1", Addr: "127.0.0.1:3000"}})
168
			},
169
		},
170
		{
171
			name: "get scheduler host addrs",
172
			config: &DaemonOption{
173
				Scheduler: SchedulerOption{
174
					Manager: ManagerOption{
175
						RefreshInterval: 10 * time.Millisecond,
176
					},
177
				},
178
				Host: HostOption{
179
					Hostname: "foo",
180
				},
181
				ObjectStorage: ObjectStorageOption{
182
					Enable: true,
183
				},
184
			},
185
			data: &DynconfigData{
186
				Schedulers: []*managerv1.Scheduler{
187
					{
188
						Ip:       "101.1.1.1",
189
						Hostname: "localhost",
190
						Port:     3000,
191
					},
192
				},
193
			},
194
			sleep: func() {
195
				time.Sleep(100 * time.Millisecond)
196
			},
197
			cleanFileCache: func(t *testing.T) {
198
				if err := os.Remove(mockCachePath); err != nil {
199
					t.Fatal(err)
200
				}
201
			},
202
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
203
				gomock.InOrder(
204
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
205
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
206
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
207
						Schedulers: []*managerv1.Scheduler{
208
							{
209
								Ip:       data.Schedulers[0].Ip,
210
								Hostname: data.Schedulers[0].Hostname,
211
								Port:     data.Schedulers[0].Port,
212
							},
213
						},
214
					}, nil).Times(1),
215
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
216
				)
217
			},
218
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
219
				assert := assert.New(t)
220
				result, err := dynconfig.GetResolveSchedulerAddrs()
221
				assert.NoError(err)
222
				assert.EqualValues(result, []resolver.Address{{ServerName: "localhost", Addr: "localhost:3000"}})
223
			},
224
		},
225
		{
226
			name: "scheduler addrs can not reachable",
227
			config: &DaemonOption{
228
				Scheduler: SchedulerOption{
229
					Manager: ManagerOption{
230
						RefreshInterval: 10 * time.Millisecond,
231
					},
232
				},
233
				Host: HostOption{
234
					Hostname: "foo",
235
				},
236
				ObjectStorage: ObjectStorageOption{
237
					Enable: true,
238
				},
239
			},
240
			data: &DynconfigData{
241
				Schedulers: []*managerv1.Scheduler{
242
					{
243
						Ip:   "127.0.0.1",
244
						Port: 3003,
245
					},
246
				},
247
			},
248
			sleep: func() {
249
				time.Sleep(100 * time.Millisecond)
250
			},
251
			cleanFileCache: func(t *testing.T) {
252
				if err := os.Remove(mockCachePath); err != nil {
253
					t.Fatal(err)
254
				}
255
			},
256
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
257
				gomock.InOrder(
258
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
259
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
260
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
261
						Schedulers: []*managerv1.Scheduler{
262
							{
263
								Ip:   data.Schedulers[0].Ip,
264
								Port: data.Schedulers[0].Port,
265
							},
266
						},
267
					}, nil).Times(1),
268
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
269
				)
270
			},
271
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
272
				assert := assert.New(t)
273
				_, err := dynconfig.GetResolveSchedulerAddrs()
274
				assert.EqualError(err, "can not found available scheduler addresses")
275
			},
276
		},
277
		{
278
			name: "data has duplicate scheduler addrs",
279
			config: &DaemonOption{
280
				Scheduler: SchedulerOption{
281
					Manager: ManagerOption{
282
						RefreshInterval: 10 * time.Millisecond,
283
					},
284
				},
285
				Host: HostOption{
286
					Hostname: "foo",
287
				},
288
				ObjectStorage: ObjectStorageOption{
289
					Enable: true,
290
				},
291
			},
292
			data: &DynconfigData{
293
				Schedulers: []*managerv1.Scheduler{
294
					{
295
						Ip:   "127.0.0.1",
296
						Port: 3000,
297
					},
298
					{
299
						Ip:   "127.0.0.1",
300
						Port: 3000,
301
					},
302
				},
303
			},
304
			sleep: func() {
305
				time.Sleep(100 * time.Millisecond)
306
			},
307
			cleanFileCache: func(t *testing.T) {
308
				if err := os.Remove(mockCachePath); err != nil {
309
					t.Fatal(err)
310
				}
311
			},
312
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
313
				gomock.InOrder(
314
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
315
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
316
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
317
						Schedulers: []*managerv1.Scheduler{
318
							{
319
								Ip:   data.Schedulers[0].Ip,
320
								Port: data.Schedulers[0].Port,
321
							},
322
						},
323
					}, nil).Times(1),
324
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
325
				)
326
			},
327
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
328
				assert := assert.New(t)
329
				result, err := dynconfig.GetResolveSchedulerAddrs()
330
				assert.NoError(err)
331
				assert.EqualValues(result, []resolver.Address{{ServerName: "127.0.0.1", Addr: "127.0.0.1:3000"}})
332
			},
333
		},
334
		{
335
			name: "list schedulers error",
336
			config: &DaemonOption{
337
				Scheduler: SchedulerOption{
338
					Manager: ManagerOption{
339
						RefreshInterval: 10 * time.Millisecond,
340
					},
341
				},
342
				Host: HostOption{
343
					Hostname: "foo",
344
				},
345
				ObjectStorage: ObjectStorageOption{
346
					Enable: true,
347
				},
348
			},
349
			data: &DynconfigData{
350
				Schedulers: []*managerv1.Scheduler{
351
					{
352
						Ip:   "127.0.0.1",
353
						Port: 3000,
354
					},
355
				},
356
			},
357
			sleep: func() {
358
				time.Sleep(100 * time.Millisecond)
359
			},
360
			cleanFileCache: func(t *testing.T) {
361
				if err := os.Remove(mockCachePath); err != nil {
362
					t.Fatal(err)
363
				}
364
			},
365
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
366
				gomock.InOrder(
367
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
368
						Schedulers: []*managerv1.Scheduler{
369
							{
370
								Ip:   data.Schedulers[0].Ip,
371
								Port: data.Schedulers[0].Port,
372
							},
373
						},
374
					}, nil).Times(1),
375
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
376
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1),
377
				)
378
			},
379
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
380
				assert := assert.New(t)
381
				result, err := dynconfig.GetResolveSchedulerAddrs()
382
				assert.NoError(err)
383
				assert.EqualValues(result, []resolver.Address{{ServerName: "127.0.0.1", Addr: "127.0.0.1:3000"}})
384
			},
385
		},
386
		{
387
			name: "scheduler addrs is empty",
388
			config: &DaemonOption{
389
				Scheduler: SchedulerOption{
390
					Manager: ManagerOption{
391
						RefreshInterval: 10 * time.Millisecond,
392
					},
393
				},
394
				Host: HostOption{
395
					Hostname: "foo",
396
				},
397
				ObjectStorage: ObjectStorageOption{
398
					Enable: true,
399
				},
400
			},
401
			data: &DynconfigData{
402
				Schedulers: []*managerv1.Scheduler(nil),
403
			},
404
			sleep: func() {
405
				time.Sleep(100 * time.Millisecond)
406
			},
407
			cleanFileCache: func(t *testing.T) {
408
				if err := os.Remove(mockCachePath); err != nil {
409
					t.Fatal(err)
410
				}
411
			},
412
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
413
				gomock.InOrder(
414
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
415
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
416
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
417
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
418
				)
419
			},
420
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
421
				assert := assert.New(t)
422
				_, err := dynconfig.GetResolveSchedulerAddrs()
423
				assert.EqualError(err, "schedulers not found")
424
			},
425
		},
426
	}
427

428
	for _, tc := range tests {
429
		t.Run(tc.name, func(t *testing.T) {
430
			ctl := gomock.NewController(t)
431
			defer ctl.Finish()
432

433
			mockManagerClient := mocks.NewMockV1(ctl)
434
			tc.mock(mockManagerClient.EXPECT(), tc.data)
435
			dynconfig, err := NewDynconfig(
436
				ManagerSourceType, tc.config,
437
				WithCacheDir(mockCacheDir),
438
				WithManagerClient(mockManagerClient),
439
			)
440
			if err != nil {
441
				t.Fatal(err)
442
			}
443

444
			tc.sleep()
445
			tc.expect(t, dynconfig, tc.data)
446
			tc.cleanFileCache(t)
447
		})
448
	}
449
}
450

451
func TestDynconfigManager_Get(t *testing.T) {
452
	mockCacheDir := t.TempDir()
453
	mockCachePath := filepath.Join(mockCacheDir, cacheFileName)
454
	tests := []struct {
455
		name           string
456
		config         *DaemonOption
457
		data           *DynconfigData
458
		sleep          func()
459
		cleanFileCache func(t *testing.T)
460
		mock           func(m *mocks.MockV1MockRecorder, data *DynconfigData)
461
		expect         func(t *testing.T, dynconfig Dynconfig, data *DynconfigData)
462
	}{
463
		{
464
			name: "get dynconfig cache data",
465
			config: &DaemonOption{
466
				Scheduler: SchedulerOption{
467
					Manager: ManagerOption{
468
						RefreshInterval: 10 * time.Second,
469
					},
470
				},
471
				Host: HostOption{
472
					Hostname: "foo",
473
				},
474
				ObjectStorage: ObjectStorageOption{
475
					Enable: true,
476
				},
477
			},
478
			data: &DynconfigData{
479
				Schedulers: []*managerv1.Scheduler{
480
					{
481
						Hostname: "foo",
482
					},
483
				},
484
				ObjectStorage: &managerv1.ObjectStorage{
485
					Name: "foo",
486
				},
487
			},
488
			sleep: func() {},
489
			cleanFileCache: func(t *testing.T) {
490
				if err := os.Remove(mockCachePath); err != nil {
491
					t.Fatal(err)
492
				}
493
			},
494
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
495
				gomock.InOrder(
496
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
497
						Schedulers: []*managerv1.Scheduler{
498
							{
499
								Hostname: data.Schedulers[0].Hostname,
500
							},
501
						},
502
					}, nil).Times(1),
503
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
504
						Name: data.ObjectStorage.Name,
505
					}, nil).Times(1),
506
				)
507
			},
508
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
509
				assert := assert.New(t)
510
				result, err := dynconfig.Get()
511
				assert.NoError(err)
512
				assert.EqualValues(result, data)
513
			},
514
		},
515
		{
516
			name: "get dynconfig data",
517
			config: &DaemonOption{
518
				Scheduler: SchedulerOption{
519
					Manager: ManagerOption{
520
						RefreshInterval: 10 * time.Millisecond,
521
					},
522
				},
523
				Host: HostOption{
524
					Hostname: "foo",
525
				},
526
				ObjectStorage: ObjectStorageOption{
527
					Enable: true,
528
				},
529
			},
530
			data: &DynconfigData{
531
				Schedulers: []*managerv1.Scheduler{
532
					{
533
						Hostname: "foo",
534
					},
535
				},
536
				ObjectStorage: &managerv1.ObjectStorage{
537
					Name: "foo",
538
				},
539
			},
540
			sleep: func() {
541
				time.Sleep(100 * time.Millisecond)
542
			},
543
			cleanFileCache: func(t *testing.T) {
544
				if err := os.Remove(mockCachePath); err != nil {
545
					t.Fatal(err)
546
				}
547
			},
548
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
549
				gomock.InOrder(
550
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
551
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
552
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
553
						Schedulers: []*managerv1.Scheduler{
554
							{
555
								Hostname: data.Schedulers[0].Hostname,
556
							},
557
						},
558
					}, nil).Times(1),
559
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
560
						Name: data.ObjectStorage.Name,
561
					}, nil).Times(1),
562
				)
563
			},
564
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
565
				assert := assert.New(t)
566
				result, err := dynconfig.Get()
567
				assert.NoError(err)
568
				assert.EqualValues(result, data)
569
			},
570
		},
571
		{
572
			name: "disable object storage",
573
			config: &DaemonOption{
574
				Scheduler: SchedulerOption{
575
					Manager: ManagerOption{
576
						RefreshInterval: 10 * time.Millisecond,
577
					},
578
				},
579
				Host: HostOption{
580
					Hostname: "foo",
581
				},
582
				ObjectStorage: ObjectStorageOption{
583
					Enable: false,
584
				},
585
			},
586
			data: &DynconfigData{
587
				Schedulers: []*managerv1.Scheduler{
588
					{
589
						Hostname: "foo",
590
					},
591
				},
592
			},
593
			sleep: func() {
594
				time.Sleep(100 * time.Millisecond)
595
			},
596
			cleanFileCache: func(t *testing.T) {
597
				if err := os.Remove(mockCachePath); err != nil {
598
					t.Fatal(err)
599
				}
600
			},
601
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
602
				gomock.InOrder(
603
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
604
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
605
						Schedulers: []*managerv1.Scheduler{
606
							{
607
								Hostname: data.Schedulers[0].Hostname,
608
							},
609
						},
610
					}, nil).Times(1),
611
				)
612
			},
613
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
614
				assert := assert.New(t)
615
				result, err := dynconfig.Get()
616
				assert.NoError(err)
617
				assert.EqualValues(result, data)
618
			},
619
		},
620
		{
621
			name: "list schedulers error",
622
			config: &DaemonOption{
623
				Scheduler: SchedulerOption{
624
					Manager: ManagerOption{
625
						RefreshInterval: 10 * time.Millisecond,
626
					},
627
				},
628
				Host: HostOption{
629
					Hostname: "foo",
630
				},
631
				ObjectStorage: ObjectStorageOption{
632
					Enable: true,
633
				},
634
			},
635
			data: &DynconfigData{
636
				Schedulers: []*managerv1.Scheduler{
637
					{
638
						Hostname: "foo",
639
					},
640
				},
641
				ObjectStorage: &managerv1.ObjectStorage{
642
					Name: "foo",
643
				},
644
			},
645
			sleep: func() {
646
				time.Sleep(100 * time.Millisecond)
647
			},
648
			cleanFileCache: func(t *testing.T) {
649
				if err := os.Remove(mockCachePath); err != nil {
650
					t.Fatal(err)
651
				}
652
			},
653
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
654
				gomock.InOrder(
655
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
656
						Schedulers: []*managerv1.Scheduler{
657
							{
658
								Hostname: data.Schedulers[0].Hostname,
659
							},
660
						},
661
					}, nil).Times(1),
662
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
663
						Name: data.ObjectStorage.Name,
664
					}, nil).Times(1),
665
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1),
666
				)
667
			},
668
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
669
				assert := assert.New(t)
670
				result, err := dynconfig.Get()
671
				assert.NoError(err)
672
				assert.EqualValues(result, data)
673
			},
674
		},
675
		{
676
			name: "get object storage error",
677
			config: &DaemonOption{
678
				Scheduler: SchedulerOption{
679
					Manager: ManagerOption{
680
						RefreshInterval: 10 * time.Millisecond,
681
					},
682
				},
683
				Host: HostOption{
684
					Hostname: "foo",
685
				},
686
				ObjectStorage: ObjectStorageOption{
687
					Enable: true,
688
				},
689
			},
690
			data: &DynconfigData{
691
				Schedulers: []*managerv1.Scheduler{
692
					{
693
						Hostname: "foo",
694
					},
695
				},
696
				ObjectStorage: &managerv1.ObjectStorage{
697
					Name: "foo",
698
				},
699
			},
700
			sleep: func() {
701
				time.Sleep(100 * time.Millisecond)
702
			},
703
			cleanFileCache: func(t *testing.T) {
704
				if err := os.Remove(mockCachePath); err != nil {
705
					t.Fatal(err)
706
				}
707
			},
708
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
709
				gomock.InOrder(
710
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
711
						Schedulers: []*managerv1.Scheduler{
712
							{
713
								Hostname: data.Schedulers[0].Hostname,
714
							},
715
						},
716
					}, nil).Times(1),
717
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
718
						Name: data.ObjectStorage.Name,
719
					}, nil).Times(1),
720
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
721
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1),
722
				)
723
			},
724
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
725
				assert := assert.New(t)
726
				result, err := dynconfig.Get()
727
				assert.NoError(err)
728
				assert.EqualValues(result, data)
729
			},
730
		},
731
		{
732
			name: "object storage is not found",
733
			config: &DaemonOption{
734
				Scheduler: SchedulerOption{
735
					Manager: ManagerOption{
736
						RefreshInterval: 10 * time.Millisecond,
737
					},
738
				},
739
				Host: HostOption{
740
					Hostname: "foo",
741
				},
742
				ObjectStorage: ObjectStorageOption{
743
					Enable: true,
744
				},
745
			},
746
			data: &DynconfigData{
747
				Schedulers: []*managerv1.Scheduler{
748
					{
749
						Hostname: "foo",
750
					},
751
				},
752
				ObjectStorage: &managerv1.ObjectStorage{
753
					Name: "foo",
754
				},
755
			},
756
			sleep: func() {
757
				time.Sleep(100 * time.Millisecond)
758
			},
759
			cleanFileCache: func(t *testing.T) {
760
				if err := os.Remove(mockCachePath); err != nil {
761
					t.Fatal(err)
762
				}
763
			},
764
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
765
				gomock.InOrder(
766
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
767
						Schedulers: []*managerv1.Scheduler{
768
							{
769
								Hostname: data.Schedulers[0].Hostname,
770
							},
771
						},
772
					}, nil).Times(1),
773
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
774
						Name: data.ObjectStorage.Name,
775
					}, nil).Times(1),
776
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
777
						Schedulers: []*managerv1.Scheduler{
778
							{
779
								Hostname: data.Schedulers[0].Hostname,
780
							},
781
						},
782
					}, nil).Times(1),
783
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.NotFound, "")).Times(1),
784
				)
785
			},
786
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
787
				assert := assert.New(t)
788
				result, err := dynconfig.Get()
789
				assert.NoError(err)
790
				assert.EqualValues(result, &DynconfigData{
791
					Schedulers: []*managerv1.Scheduler{
792
						{
793
							Hostname: data.Schedulers[0].Hostname,
794
						},
795
					},
796
					ObjectStorage: &managerv1.ObjectStorage{
797
						Name: data.ObjectStorage.Name,
798
					},
799
				})
800
			},
801
		},
802
		{
803
			name: "resource is empty",
804
			config: &DaemonOption{
805
				Scheduler: SchedulerOption{
806
					Manager: ManagerOption{
807
						RefreshInterval: 10 * time.Millisecond,
808
					},
809
				},
810
				Host: HostOption{
811
					Hostname: "foo",
812
				},
813
				ObjectStorage: ObjectStorageOption{
814
					Enable: true,
815
				},
816
			},
817
			data: &DynconfigData{
818
				Schedulers:    []*managerv1.Scheduler(nil),
819
				ObjectStorage: &managerv1.ObjectStorage{},
820
			},
821
			sleep: func() {
822
				time.Sleep(100 * time.Millisecond)
823
			},
824
			cleanFileCache: func(t *testing.T) {
825
				if err := os.Remove(mockCachePath); err != nil {
826
					t.Fatal(err)
827
				}
828
			},
829
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
830
				gomock.InOrder(
831
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
832
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
833
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
834
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
835
				)
836
			},
837
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
838
				assert := assert.New(t)
839
				result, err := dynconfig.Get()
840
				assert.NoError(err)
841
				assert.EqualValues(result, data)
842
			},
843
		},
844
	}
845

846
	for _, tc := range tests {
847
		t.Run(tc.name, func(t *testing.T) {
848
			ctl := gomock.NewController(t)
849
			defer ctl.Finish()
850

851
			mockManagerClient := mocks.NewMockV1(ctl)
852
			tc.mock(mockManagerClient.EXPECT(), tc.data)
853
			dynconfig, err := NewDynconfig(
854
				ManagerSourceType, tc.config,
855
				WithCacheDir(mockCacheDir),
856
				WithManagerClient(mockManagerClient),
857
			)
858
			if err != nil {
859
				t.Fatal(err)
860
			}
861

862
			tc.sleep()
863
			tc.expect(t, dynconfig, tc.data)
864
			tc.cleanFileCache(t)
865
		})
866
	}
867
}
868

869
func TestDynconfigManager_GetSchedulers(t *testing.T) {
870
	mockCacheDir := t.TempDir()
871
	mockCachePath := filepath.Join(mockCacheDir, cacheFileName)
872
	tests := []struct {
873
		name           string
874
		config         *DaemonOption
875
		data           *DynconfigData
876
		sleep          func()
877
		cleanFileCache func(t *testing.T)
878
		mock           func(m *mocks.MockV1MockRecorder, data *DynconfigData)
879
		expect         func(t *testing.T, dynconfig Dynconfig, data *DynconfigData)
880
	}{
881
		{
882
			name: "get cache schedulers",
883
			config: &DaemonOption{
884
				Scheduler: SchedulerOption{
885
					Manager: ManagerOption{
886
						RefreshInterval: 10 * time.Second,
887
					},
888
				},
889
				Host: HostOption{
890
					Hostname: "foo",
891
				},
892
				ObjectStorage: ObjectStorageOption{
893
					Enable: true,
894
				},
895
			},
896
			data: &DynconfigData{
897
				Schedulers: []*managerv1.Scheduler{
898
					{
899
						Hostname: "foo",
900
					},
901
				},
902
			},
903
			sleep: func() {},
904
			cleanFileCache: func(t *testing.T) {
905
				if err := os.Remove(mockCachePath); err != nil {
906
					t.Fatal(err)
907
				}
908
			},
909
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
910
				gomock.InOrder(
911
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
912
						Schedulers: []*managerv1.Scheduler{
913
							{
914
								Hostname: data.Schedulers[0].Hostname,
915
							},
916
						},
917
					}, nil).Times(1),
918
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
919
				)
920
			},
921
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
922
				assert := assert.New(t)
923
				result, err := dynconfig.GetSchedulers()
924
				assert.NoError(err)
925
				assert.EqualValues(result, data.Schedulers)
926
			},
927
		},
928
		{
929
			name: "get schedulers",
930
			config: &DaemonOption{
931
				Scheduler: SchedulerOption{
932
					Manager: ManagerOption{
933
						RefreshInterval: 10 * time.Millisecond,
934
					},
935
				},
936
				Host: HostOption{
937
					Hostname: "foo",
938
				},
939
				ObjectStorage: ObjectStorageOption{
940
					Enable: true,
941
				},
942
			},
943
			data: &DynconfigData{
944
				Schedulers: []*managerv1.Scheduler{
945
					{
946
						Hostname: "foo",
947
					},
948
				},
949
			},
950
			sleep: func() {
951
				time.Sleep(100 * time.Millisecond)
952
			},
953
			cleanFileCache: func(t *testing.T) {
954
				if err := os.Remove(mockCachePath); err != nil {
955
					t.Fatal(err)
956
				}
957
			},
958
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
959
				gomock.InOrder(
960
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
961
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
962
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
963
						Schedulers: []*managerv1.Scheduler{
964
							{
965
								Hostname: data.Schedulers[0].Hostname,
966
							},
967
						},
968
					}, nil).Times(1),
969
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
970
				)
971
			},
972
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
973
				assert := assert.New(t)
974
				result, err := dynconfig.GetSchedulers()
975
				assert.NoError(err)
976
				assert.EqualValues(result, data.Schedulers)
977
			},
978
		},
979
		{
980
			name: "list schedulers error",
981
			config: &DaemonOption{
982
				Scheduler: SchedulerOption{
983
					Manager: ManagerOption{
984
						RefreshInterval: 10 * time.Millisecond,
985
					},
986
				},
987
				Host: HostOption{
988
					Hostname: "foo",
989
				},
990
				ObjectStorage: ObjectStorageOption{
991
					Enable: true,
992
				},
993
			},
994
			data: &DynconfigData{
995
				Schedulers: []*managerv1.Scheduler{
996
					{
997
						Hostname: "foo",
998
					},
999
				},
1000
			},
1001
			sleep: func() {
1002
				time.Sleep(100 * time.Millisecond)
1003
			},
1004
			cleanFileCache: func(t *testing.T) {
1005
				if err := os.Remove(mockCachePath); err != nil {
1006
					t.Fatal(err)
1007
				}
1008
			},
1009
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1010
				gomock.InOrder(
1011
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{
1012
						Schedulers: []*managerv1.Scheduler{
1013
							{
1014
								Hostname: data.Schedulers[0].Hostname,
1015
							},
1016
						},
1017
					}, nil).Times(1),
1018
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
1019
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1),
1020
				)
1021
			},
1022
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1023
				assert := assert.New(t)
1024
				result, err := dynconfig.GetSchedulers()
1025
				assert.NoError(err)
1026
				assert.EqualValues(result, data.Schedulers)
1027
			},
1028
		},
1029
		{
1030
			name: "schedulers is empty",
1031
			config: &DaemonOption{
1032
				Scheduler: SchedulerOption{
1033
					Manager: ManagerOption{
1034
						RefreshInterval: 10 * time.Millisecond,
1035
					},
1036
				},
1037
				Host: HostOption{
1038
					Hostname: "foo",
1039
				},
1040
				ObjectStorage: ObjectStorageOption{
1041
					Enable: true,
1042
				},
1043
			},
1044
			data: &DynconfigData{
1045
				Schedulers: []*managerv1.Scheduler(nil),
1046
			},
1047
			sleep: func() {
1048
				time.Sleep(100 * time.Millisecond)
1049
			},
1050
			cleanFileCache: func(t *testing.T) {
1051
				if err := os.Remove(mockCachePath); err != nil {
1052
					t.Fatal(err)
1053
				}
1054
			},
1055
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1056
				gomock.InOrder(
1057
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1058
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
1059
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1060
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
1061
				)
1062
			},
1063
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1064
				assert := assert.New(t)
1065
				_, err := dynconfig.GetSchedulers()
1066
				assert.Error(err)
1067
			},
1068
		},
1069
	}
1070

1071
	for _, tc := range tests {
1072
		t.Run(tc.name, func(t *testing.T) {
1073
			ctl := gomock.NewController(t)
1074
			defer ctl.Finish()
1075

1076
			mockManagerClient := mocks.NewMockV1(ctl)
1077
			tc.mock(mockManagerClient.EXPECT(), tc.data)
1078
			dynconfig, err := NewDynconfig(
1079
				ManagerSourceType, tc.config,
1080
				WithCacheDir(mockCacheDir),
1081
				WithManagerClient(mockManagerClient),
1082
			)
1083
			if err != nil {
1084
				t.Fatal(err)
1085
			}
1086

1087
			tc.sleep()
1088
			tc.expect(t, dynconfig, tc.data)
1089
			tc.cleanFileCache(t)
1090
		})
1091
	}
1092
}
1093

1094
func TestDynconfigManager_GetObjectStorage(t *testing.T) {
1095
	mockCacheDir := t.TempDir()
1096
	mockCachePath := filepath.Join(mockCacheDir, cacheFileName)
1097
	tests := []struct {
1098
		name           string
1099
		config         *DaemonOption
1100
		data           *DynconfigData
1101
		sleep          func()
1102
		cleanFileCache func(t *testing.T)
1103
		mock           func(m *mocks.MockV1MockRecorder, data *DynconfigData)
1104
		expect         func(t *testing.T, dynconfig Dynconfig, data *DynconfigData)
1105
	}{
1106
		{
1107
			name: "get cache object storage",
1108
			config: &DaemonOption{
1109
				Scheduler: SchedulerOption{
1110
					Manager: ManagerOption{
1111
						RefreshInterval: 10 * time.Second,
1112
					},
1113
				},
1114
				Host: HostOption{
1115
					Hostname: "foo",
1116
				},
1117
				ObjectStorage: ObjectStorageOption{
1118
					Enable: true,
1119
				},
1120
			},
1121
			data: &DynconfigData{
1122
				ObjectStorage: &managerv1.ObjectStorage{
1123
					Name: "foo",
1124
				},
1125
			},
1126
			sleep: func() {},
1127
			cleanFileCache: func(t *testing.T) {
1128
				if err := os.Remove(mockCachePath); err != nil {
1129
					t.Fatal(err)
1130
				}
1131
			},
1132
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1133
				gomock.InOrder(
1134
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1135
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
1136
						Name: data.ObjectStorage.Name,
1137
					}, nil).Times(1),
1138
				)
1139
			},
1140
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1141
				assert := assert.New(t)
1142
				result, err := dynconfig.GetObjectStorage()
1143
				assert.NoError(err)
1144
				assert.EqualValues(result, data.ObjectStorage)
1145
			},
1146
		},
1147
		{
1148
			name: "get object storage",
1149
			config: &DaemonOption{
1150
				Scheduler: SchedulerOption{
1151
					Manager: ManagerOption{
1152
						RefreshInterval: 10 * time.Millisecond,
1153
					},
1154
				},
1155
				Host: HostOption{
1156
					Hostname: "foo",
1157
				},
1158
				ObjectStorage: ObjectStorageOption{
1159
					Enable: true,
1160
				},
1161
			},
1162
			data: &DynconfigData{
1163
				ObjectStorage: &managerv1.ObjectStorage{
1164
					Name: "foo",
1165
				},
1166
			},
1167
			sleep: func() {
1168
				time.Sleep(100 * time.Millisecond)
1169
			},
1170
			cleanFileCache: func(t *testing.T) {
1171
				if err := os.Remove(mockCachePath); err != nil {
1172
					t.Fatal(err)
1173
				}
1174
			},
1175
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1176
				gomock.InOrder(
1177
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1178
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
1179
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1180
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
1181
						Name: data.ObjectStorage.Name,
1182
					}, nil).Times(1),
1183
				)
1184
			},
1185
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1186
				assert := assert.New(t)
1187
				result, err := dynconfig.GetObjectStorage()
1188
				assert.NoError(err)
1189
				assert.EqualValues(result, data.ObjectStorage)
1190
			},
1191
		},
1192
		{
1193
			name: "get object storage error",
1194
			config: &DaemonOption{
1195
				Scheduler: SchedulerOption{
1196
					Manager: ManagerOption{
1197
						RefreshInterval: 10 * time.Millisecond,
1198
					},
1199
				},
1200
				Host: HostOption{
1201
					Hostname: "foo",
1202
				},
1203
				ObjectStorage: ObjectStorageOption{
1204
					Enable: true,
1205
				},
1206
			},
1207
			data: &DynconfigData{
1208
				ObjectStorage: &managerv1.ObjectStorage{
1209
					Name: "foo",
1210
				},
1211
			},
1212
			sleep: func() {
1213
				time.Sleep(100 * time.Millisecond)
1214
			},
1215
			cleanFileCache: func(t *testing.T) {
1216
				if err := os.Remove(mockCachePath); err != nil {
1217
					t.Fatal(err)
1218
				}
1219
			},
1220
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1221
				gomock.InOrder(
1222
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1223
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
1224
						Name: data.ObjectStorage.Name,
1225
					}, nil).Times(1),
1226
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1227
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(nil, errors.New("foo")).Times(1),
1228
				)
1229
			},
1230
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1231
				assert := assert.New(t)
1232
				result, err := dynconfig.GetObjectStorage()
1233
				assert.NoError(err)
1234
				assert.EqualValues(result, data.ObjectStorage)
1235
			},
1236
		},
1237
		{
1238
			name: "object storage is not found",
1239
			config: &DaemonOption{
1240
				Scheduler: SchedulerOption{
1241
					Manager: ManagerOption{
1242
						RefreshInterval: 10 * time.Millisecond,
1243
					},
1244
				},
1245
				Host: HostOption{
1246
					Hostname: "foo",
1247
				},
1248
				ObjectStorage: ObjectStorageOption{
1249
					Enable: true,
1250
				},
1251
			},
1252
			data: &DynconfigData{
1253
				ObjectStorage: &managerv1.ObjectStorage{
1254
					Name: "foo",
1255
				},
1256
			},
1257
			sleep: func() {
1258
				time.Sleep(100 * time.Millisecond)
1259
			},
1260
			cleanFileCache: func(t *testing.T) {
1261
				if err := os.Remove(mockCachePath); err != nil {
1262
					t.Fatal(err)
1263
				}
1264
			},
1265
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1266
				gomock.InOrder(
1267
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1268
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{
1269
						Name: data.ObjectStorage.Name,
1270
					}, nil).Times(1),
1271
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1272
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(nil, status.Error(codes.NotFound, "")).Times(1),
1273
				)
1274
			},
1275
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1276
				assert := assert.New(t)
1277
				result, err := dynconfig.GetObjectStorage()
1278
				assert.NoError(err)
1279
				assert.EqualValues(result, &managerv1.ObjectStorage{
1280
					Name: data.ObjectStorage.Name,
1281
				})
1282
			},
1283
		},
1284
		{
1285
			name: "object storage is empty",
1286
			config: &DaemonOption{
1287
				Scheduler: SchedulerOption{
1288
					Manager: ManagerOption{
1289
						RefreshInterval: 10 * time.Millisecond,
1290
					},
1291
				},
1292
				Host: HostOption{
1293
					Hostname: "foo",
1294
				},
1295
				ObjectStorage: ObjectStorageOption{
1296
					Enable: true,
1297
				},
1298
			},
1299
			data: &DynconfigData{
1300
				ObjectStorage: &managerv1.ObjectStorage{},
1301
			},
1302
			sleep: func() {
1303
				time.Sleep(100 * time.Millisecond)
1304
			},
1305
			cleanFileCache: func(t *testing.T) {
1306
				if err := os.Remove(mockCachePath); err != nil {
1307
					t.Fatal(err)
1308
				}
1309
			},
1310
			mock: func(m *mocks.MockV1MockRecorder, data *DynconfigData) {
1311
				gomock.InOrder(
1312
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1313
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
1314
					m.ListSchedulers(gomock.Any(), gomock.Any()).Return(&managerv1.ListSchedulersResponse{}, nil).Times(1),
1315
					m.GetObjectStorage(gomock.Any(), gomock.Any()).Return(&managerv1.ObjectStorage{}, nil).Times(1),
1316
				)
1317
			},
1318
			expect: func(t *testing.T, dynconfig Dynconfig, data *DynconfigData) {
1319
				assert := assert.New(t)
1320
				result, err := dynconfig.GetObjectStorage()
1321
				assert.NoError(err)
1322
				assert.EqualValues(result, data.ObjectStorage)
1323
			},
1324
		},
1325
	}
1326

1327
	for _, tc := range tests {
1328
		t.Run(tc.name, func(t *testing.T) {
1329
			ctl := gomock.NewController(t)
1330
			defer ctl.Finish()
1331

1332
			mockManagerClient := mocks.NewMockV1(ctl)
1333
			tc.mock(mockManagerClient.EXPECT(), tc.data)
1334
			dynconfig, err := NewDynconfig(
1335
				ManagerSourceType, tc.config,
1336
				WithCacheDir(mockCacheDir),
1337
				WithManagerClient(mockManagerClient),
1338
			)
1339
			if err != nil {
1340
				t.Fatal(err)
1341
			}
1342

1343
			tc.sleep()
1344
			tc.expect(t, dynconfig, tc.data)
1345
			tc.cleanFileCache(t)
1346
		})
1347
	}
1348
}
1349