Dragonfly2

1
/*
2
 *     Copyright 2020 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
	"net"
21
	"os"
22
	"testing"
23
	"time"
24

25
	"github.com/stretchr/testify/assert"
26
	"gopkg.in/yaml.v3"
27

28
	"d7y.io/dragonfly/v2/pkg/objectstorage"
29
	"d7y.io/dragonfly/v2/pkg/rpc"
30
	"d7y.io/dragonfly/v2/pkg/types"
31
)
32

33
var (
34
	mockJWTConfig = JWTConfig{
35
		Realm:      "foo",
36
		Key:        "bar",
37
		Timeout:    30 * time.Second,
38
		MaxRefresh: 1 * time.Minute,
39
	}
40

41
	mockMysqlConfig = MysqlConfig{
42
		User:      "foo",
43
		Password:  "bar",
44
		Host:      "localhost",
45
		Port:      DefaultMysqlPort,
46
		DBName:    DefaultMysqlDBName,
47
		TLSConfig: "true",
48
		Migrate:   true,
49
	}
50

51
	mockMysqlTLSConfig = &MysqlTLSClientConfig{
52
		Cert:               "ca.crt",
53
		Key:                "ca.key",
54
		CA:                 "ca",
55
		InsecureSkipVerify: false,
56
	}
57

58
	mockPostgresConfig = PostgresConfig{
59
		User:                 "foo",
60
		Password:             "bar",
61
		Host:                 "localhost",
62
		Port:                 DefaultPostgresPort,
63
		DBName:               DefaultPostgresDBName,
64
		SSLMode:              DefaultPostgresSSLMode,
65
		PreferSimpleProtocol: DefaultPostgresPreferSimpleProtocol,
66
		Timezone:             DefaultPostgresTimezone,
67
		Migrate:              true,
68
	}
69

70
	mockRedisConfig = RedisConfig{
71
		Addrs:      []string{"127.0.0.0:6379"},
72
		MasterName: "master",
73
		Username:   "baz",
74
		Password:   "bax",
75
		DB:         DefaultRedisDB,
76
		BrokerDB:   DefaultRedisBrokerDB,
77
		BackendDB:  DefaultRedisBackendDB,
78
	}
79

80
	mockObjectStorageConfig = ObjectStorageConfig{
81
		Enable:           true,
82
		Name:             objectstorage.ServiceNameS3,
83
		Region:           "bas",
84
		Endpoint:         "127.0.0.1",
85
		AccessKey:        "ak",
86
		SecretKey:        "sk",
87
		S3ForcePathStyle: true,
88
	}
89

90
	mockMetricsConfig = MetricsConfig{
91
		Enable: true,
92
		Addr:   DefaultMetricsAddr,
93
	}
94

95
	mockSecurityConfig = SecurityConfig{
96
		AutoIssueCert: true,
97
		CACert:        types.PEMContent("foo"),
98
		CAKey:         types.PEMContent("bar"),
99
		TLSPolicy:     rpc.PreferTLSPolicy,
100
		CertSpec: CertSpec{
101
			DNSNames:       DefaultCertDNSNames,
102
			IPAddresses:    DefaultCertIPAddresses,
103
			ValidityPeriod: DefaultCertValidityPeriod,
104
		},
105
	}
106

107
	mockTrainerConfig = TrainerConfig{
108
		Enable:     true,
109
		BucketName: DefaultTrainerBucketName,
110
	}
111
)
112

113
func TestConfig_Load(t *testing.T) {
114
	config := &Config{
115
		Server: ServerConfig{
116
			Name:      "foo",
117
			WorkHome:  "foo",
118
			CacheDir:  "foo",
119
			LogDir:    "foo",
120
			PluginDir: "foo",
121
			GRPC: GRPCConfig{
122
				AdvertiseIP: net.IPv4zero,
123
				ListenIP:    net.IPv4zero,
124
				PortRange: TCPListenPortRange{
125
					Start: 65003,
126
					End:   65003,
127
				},
128
			},
129
			REST: RESTConfig{
130
				Addr: ":8080",
131
				TLS: &TLSServerConfig{
132
					Cert: "foo",
133
					Key:  "foo",
134
				},
135
			},
136
		},
137
		Auth: AuthConfig{
138
			JWT: JWTConfig{
139
				Realm:      "foo",
140
				Key:        "bar",
141
				Timeout:    30 * time.Second,
142
				MaxRefresh: 1 * time.Minute,
143
			},
144
		},
145
		Database: DatabaseConfig{
146
			Type: "mysql",
147
			Mysql: MysqlConfig{
148
				User:      "foo",
149
				Password:  "foo",
150
				Host:      "foo",
151
				Port:      3306,
152
				DBName:    "foo",
153
				TLSConfig: "preferred",
154
				TLS: &MysqlTLSClientConfig{
155
					Cert:               "foo",
156
					Key:                "foo",
157
					CA:                 "foo",
158
					InsecureSkipVerify: true,
159
				},
160
				Migrate: true,
161
			},
162
			Postgres: PostgresConfig{
163
				User:                 "foo",
164
				Password:             "foo",
165
				Host:                 "foo",
166
				Port:                 5432,
167
				DBName:               "foo",
168
				SSLMode:              "disable",
169
				PreferSimpleProtocol: false,
170
				Timezone:             "UTC",
171
				Migrate:              true,
172
			},
173
			Redis: RedisConfig{
174
				Password:   "bar",
175
				Addrs:      []string{"foo", "bar"},
176
				MasterName: "baz",
177
				DB:         0,
178
				BrokerDB:   1,
179
				BackendDB:  2,
180
			},
181
		},
182
		Cache: CacheConfig{
183
			Redis: RedisCacheConfig{
184
				TTL: 1 * time.Second,
185
			},
186
			Local: LocalCacheConfig{
187
				Size: 10000,
188
				TTL:  1 * time.Second,
189
			},
190
		},
191
		Job: JobConfig{
192
			Preheat: PreheatConfig{
193
				RegistryTimeout: DefaultJobPreheatRegistryTimeout,
194
				TLS: &PreheatTLSClientConfig{
195
					CACert: "foo",
196
				},
197
			},
198
			SyncPeers: SyncPeersConfig{
199
				Interval: 13 * time.Hour,
200
				Timeout:  2 * time.Minute,
201
			},
202
		},
203
		ObjectStorage: ObjectStorageConfig{
204
			Enable:           true,
205
			Name:             objectstorage.ServiceNameS3,
206
			Endpoint:         "127.0.0.1",
207
			AccessKey:        "foo",
208
			SecretKey:        "bar",
209
			Region:           "baz",
210
			S3ForcePathStyle: false,
211
		},
212
		Security: SecurityConfig{
213
			AutoIssueCert: true,
214
			CACert:        "foo",
215
			CAKey:         "bar",
216
			TLSPolicy:     "force",
217
			CertSpec: CertSpec{
218
				DNSNames:       []string{"foo"},
219
				IPAddresses:    []net.IP{net.IPv4zero},
220
				ValidityPeriod: 1 * time.Second,
221
			},
222
		},
223
		Metrics: MetricsConfig{
224
			Enable: true,
225
			Addr:   ":8000",
226
		},
227
		Network: NetworkConfig{
228
			EnableIPv6: true,
229
		},
230
		Trainer: TrainerConfig{
231
			Enable:     true,
232
			BucketName: "models",
233
		},
234
	}
235

236
	managerConfigYAML := &Config{}
237
	contentYAML, _ := os.ReadFile("./testdata/manager.yaml")
238
	if err := yaml.Unmarshal(contentYAML, &managerConfigYAML); err != nil {
239
		t.Fatal(err)
240
	}
241

242
	assert := assert.New(t)
243
	assert.EqualValues(config, managerConfigYAML)
244
}
245

246
func TestConfig_Validate(t *testing.T) {
247
	tests := []struct {
248
		name   string
249
		config *Config
250
		mock   func(cfg *Config)
251
		expect func(t *testing.T, err error)
252
	}{
253
		{
254
			name:   "valid config",
255
			config: New(),
256
			mock: func(cfg *Config) {
257
				cfg.Auth.JWT = mockJWTConfig
258
				cfg.Database.Mysql = mockMysqlConfig
259
				cfg.Database.Redis = mockRedisConfig
260
			},
261
			expect: func(t *testing.T, err error) {
262
				assert := assert.New(t)
263
				assert.NoError(err)
264
			},
265
		},
266
		{
267
			name:   "server requires parameter name",
268
			config: New(),
269
			mock: func(cfg *Config) {
270
				cfg.Server.Name = ""
271
			},
272
			expect: func(t *testing.T, err error) {
273
				assert := assert.New(t)
274
				assert.EqualError(err, "server requires parameter name")
275
			},
276
		},
277
		{
278
			name:   "grpc requires parameter advertiseIP",
279
			config: New(),
280
			mock: func(cfg *Config) {
281
				cfg.Server.GRPC.AdvertiseIP = nil
282
			},
283
			expect: func(t *testing.T, err error) {
284
				assert := assert.New(t)
285
				assert.EqualError(err, "grpc requires parameter advertiseIP")
286
			},
287
		},
288
		{
289
			name:   "grpc requires parameter listenIP",
290
			config: New(),
291
			mock: func(cfg *Config) {
292
				cfg.Server.GRPC.ListenIP = nil
293
			},
294
			expect: func(t *testing.T, err error) {
295
				assert := assert.New(t)
296
				assert.EqualError(err, "grpc requires parameter listenIP")
297
			},
298
		},
299
		{
300
			name:   "rest tls requires parameter cert",
301
			config: New(),
302
			mock: func(cfg *Config) {
303
				cfg.Server.REST.TLS = &TLSServerConfig{
304
					Cert: "",
305
					Key:  "foo",
306
				}
307
			},
308
			expect: func(t *testing.T, err error) {
309
				assert := assert.New(t)
310
				assert.EqualError(err, "tls requires parameter cert")
311
			},
312
		},
313
		{
314
			name:   "rest tls requires parameter key",
315
			config: New(),
316
			mock: func(cfg *Config) {
317
				cfg.Server.REST.TLS = &TLSServerConfig{
318
					Cert: "foo",
319
					Key:  "",
320
				}
321
			},
322
			expect: func(t *testing.T, err error) {
323
				assert := assert.New(t)
324
				assert.EqualError(err, "tls requires parameter key")
325
			},
326
		},
327
		{
328
			name:   "jwt requires parameter realm",
329
			config: New(),
330
			mock: func(cfg *Config) {
331
				cfg.Auth.JWT.Realm = ""
332
			},
333
			expect: func(t *testing.T, err error) {
334
				assert := assert.New(t)
335
				assert.EqualError(err, "jwt requires parameter realm")
336
			},
337
		},
338
		{
339
			name:   "jwt requires parameter key",
340
			config: New(),
341
			mock: func(cfg *Config) {
342
				cfg.Auth.JWT.Key = ""
343
			},
344
			expect: func(t *testing.T, err error) {
345
				assert := assert.New(t)
346
				assert.EqualError(err, "jwt requires parameter key")
347
			},
348
		},
349
		{
350
			name:   "jwt requires parameter timeout",
351
			config: New(),
352
			mock: func(cfg *Config) {
353
				cfg.Auth.JWT = mockJWTConfig
354
				cfg.Auth.JWT.Timeout = 0
355
			},
356
			expect: func(t *testing.T, err error) {
357
				assert := assert.New(t)
358
				assert.EqualError(err, "jwt requires parameter timeout")
359
			},
360
		},
361
		{
362
			name:   "jwt requires parameter maxRefresh",
363
			config: New(),
364
			mock: func(cfg *Config) {
365
				cfg.Auth.JWT = mockJWTConfig
366
				cfg.Auth.JWT.MaxRefresh = 0
367
			},
368
			expect: func(t *testing.T, err error) {
369
				assert := assert.New(t)
370
				assert.EqualError(err, "jwt requires parameter maxRefresh")
371
			},
372
		},
373
		{
374
			name:   "database requires parameter type",
375
			config: New(),
376
			mock: func(cfg *Config) {
377
				cfg.Auth.JWT = mockJWTConfig
378
				cfg.Database.Type = ""
379
			},
380
			expect: func(t *testing.T, err error) {
381
				assert := assert.New(t)
382
				assert.EqualError(err, "database requires parameter type")
383
			},
384
		},
385
		{
386
			name:   "mysql requires parameter user",
387
			config: New(),
388
			mock: func(cfg *Config) {
389
				cfg.Auth.JWT = mockJWTConfig
390
				cfg.Database.Type = DatabaseTypeMysql
391
				cfg.Database.Mysql = mockMysqlConfig
392
				cfg.Database.Mysql.User = ""
393
			},
394
			expect: func(t *testing.T, err error) {
395
				assert := assert.New(t)
396
				assert.EqualError(err, "mysql requires parameter user")
397
			},
398
		},
399
		{
400
			name:   "mysql requires parameter password",
401
			config: New(),
402
			mock: func(cfg *Config) {
403
				cfg.Auth.JWT = mockJWTConfig
404
				cfg.Database.Type = DatabaseTypeMysql
405
				cfg.Database.Mysql = mockMysqlConfig
406
				cfg.Database.Mysql.Password = ""
407
			},
408
			expect: func(t *testing.T, err error) {
409
				assert := assert.New(t)
410
				assert.EqualError(err, "mysql requires parameter password")
411
			},
412
		},
413
		{
414
			name:   "mysql requires parameter host",
415
			config: New(),
416
			mock: func(cfg *Config) {
417
				cfg.Auth.JWT = mockJWTConfig
418
				cfg.Database.Type = DatabaseTypeMysql
419
				cfg.Database.Mysql = mockMysqlConfig
420
				cfg.Database.Mysql.Host = ""
421
			},
422
			expect: func(t *testing.T, err error) {
423
				assert := assert.New(t)
424
				assert.EqualError(err, "mysql requires parameter host")
425
			},
426
		},
427
		{
428
			name:   "mysql requires parameter port",
429
			config: New(),
430
			mock: func(cfg *Config) {
431
				cfg.Auth.JWT = mockJWTConfig
432
				cfg.Database.Type = DatabaseTypeMysql
433
				cfg.Database.Mysql = mockMysqlConfig
434
				cfg.Database.Mysql.Port = 0
435
			},
436
			expect: func(t *testing.T, err error) {
437
				assert := assert.New(t)
438
				assert.EqualError(err, "mysql requires parameter port")
439
			},
440
		},
441
		{
442
			name:   "mysql requires parameter dbname",
443
			config: New(),
444
			mock: func(cfg *Config) {
445
				cfg.Auth.JWT = mockJWTConfig
446
				cfg.Database.Type = DatabaseTypeMysql
447
				cfg.Database.Mysql = mockMysqlConfig
448
				cfg.Database.Mysql.DBName = ""
449
			},
450
			expect: func(t *testing.T, err error) {
451
				assert := assert.New(t)
452
				assert.EqualError(err, "mysql requires parameter dbname")
453
			},
454
		},
455
		{
456
			name:   "tls requires parameter cert",
457
			config: New(),
458
			mock: func(cfg *Config) {
459
				cfg.Auth.JWT = mockJWTConfig
460
				cfg.Database.Type = DatabaseTypeMysql
461
				cfg.Database.Mysql = mockMysqlConfig
462
				cfg.Database.Mysql.TLS = mockMysqlTLSConfig
463
				cfg.Database.Mysql.TLS.Cert = ""
464
			},
465
			expect: func(t *testing.T, err error) {
466
				assert := assert.New(t)
467
				assert.EqualError(err, "tls requires parameter cert")
468
			},
469
		},
470
		{
471
			name:   "tls requires parameter key",
472
			config: New(),
473
			mock: func(cfg *Config) {
474
				cfg.Auth.JWT = mockJWTConfig
475
				cfg.Database.Type = DatabaseTypeMysql
476
				cfg.Database.Mysql = mockMysqlConfig
477
				cfg.Database.Mysql.TLS = mockMysqlTLSConfig
478
				cfg.Database.Mysql.TLS.Cert = "ca.crt"
479
				cfg.Database.Mysql.TLS.Key = ""
480
			},
481
			expect: func(t *testing.T, err error) {
482
				assert := assert.New(t)
483
				assert.EqualError(err, "tls requires parameter key")
484
			},
485
		},
486
		{
487
			name:   "tls requires parameter ca",
488
			config: New(),
489
			mock: func(cfg *Config) {
490
				cfg.Auth.JWT = mockJWTConfig
491
				cfg.Database.Type = DatabaseTypeMysql
492
				cfg.Database.Mysql = mockMysqlConfig
493
				cfg.Database.Mysql.TLS = mockMysqlTLSConfig
494
				cfg.Database.Mysql.TLS.Cert = "ca.crt"
495
				cfg.Database.Mysql.TLS.Key = "ca.key"
496
				cfg.Database.Mysql.TLS.CA = ""
497
			},
498
			expect: func(t *testing.T, err error) {
499
				assert := assert.New(t)
500
				assert.EqualError(err, "tls requires parameter ca")
501
			},
502
		},
503
		{
504
			name:   "postgres requires parameter user",
505
			config: New(),
506
			mock: func(cfg *Config) {
507
				cfg.Auth.JWT = mockJWTConfig
508
				cfg.Database.Type = DatabaseTypePostgres
509
				cfg.Database.Postgres = mockPostgresConfig
510
				cfg.Database.Postgres.User = ""
511
			},
512
			expect: func(t *testing.T, err error) {
513
				assert := assert.New(t)
514
				assert.EqualError(err, "postgres requires parameter user")
515
			},
516
		},
517
		{
518
			name:   "postgres requires parameter password",
519
			config: New(),
520
			mock: func(cfg *Config) {
521
				cfg.Auth.JWT = mockJWTConfig
522
				cfg.Database.Type = DatabaseTypePostgres
523
				cfg.Database.Postgres = mockPostgresConfig
524
				cfg.Database.Postgres.Password = ""
525
			},
526
			expect: func(t *testing.T, err error) {
527
				assert := assert.New(t)
528
				assert.EqualError(err, "postgres requires parameter password")
529
			},
530
		},
531
		{
532
			name:   "postgres requires parameter host",
533
			config: New(),
534
			mock: func(cfg *Config) {
535
				cfg.Auth.JWT = mockJWTConfig
536
				cfg.Database.Type = DatabaseTypePostgres
537
				cfg.Database.Postgres = mockPostgresConfig
538
				cfg.Database.Postgres.Host = ""
539
			},
540
			expect: func(t *testing.T, err error) {
541
				assert := assert.New(t)
542
				assert.EqualError(err, "postgres requires parameter host")
543
			},
544
		},
545
		{
546
			name:   "postgres requires parameter port",
547
			config: New(),
548
			mock: func(cfg *Config) {
549
				cfg.Auth.JWT = mockJWTConfig
550
				cfg.Database.Type = DatabaseTypePostgres
551
				cfg.Database.Postgres = mockPostgresConfig
552
				cfg.Database.Postgres.Port = 0
553
			},
554
			expect: func(t *testing.T, err error) {
555
				assert := assert.New(t)
556
				assert.EqualError(err, "postgres requires parameter port")
557
			},
558
		},
559
		{
560
			name:   "postgres requires parameter dbname",
561
			config: New(),
562
			mock: func(cfg *Config) {
563
				cfg.Auth.JWT = mockJWTConfig
564
				cfg.Database.Type = DatabaseTypePostgres
565
				cfg.Database.Postgres = mockPostgresConfig
566
				cfg.Database.Postgres.DBName = ""
567
			},
568
			expect: func(t *testing.T, err error) {
569
				assert := assert.New(t)
570
				assert.EqualError(err, "postgres requires parameter dbname")
571
			},
572
		},
573
		{
574
			name:   "postgres requires parameter sslMode",
575
			config: New(),
576
			mock: func(cfg *Config) {
577
				cfg.Auth.JWT = mockJWTConfig
578
				cfg.Database.Type = DatabaseTypePostgres
579
				cfg.Database.Postgres = mockPostgresConfig
580
				cfg.Database.Postgres.SSLMode = ""
581
			},
582
			expect: func(t *testing.T, err error) {
583
				assert := assert.New(t)
584
				assert.EqualError(err, "postgres requires parameter sslMode")
585
			},
586
		},
587
		{
588
			name:   "postgres requires parameter timezone",
589
			config: New(),
590
			mock: func(cfg *Config) {
591
				cfg.Auth.JWT = mockJWTConfig
592
				cfg.Database.Type = DatabaseTypePostgres
593
				cfg.Database.Postgres = mockPostgresConfig
594
				cfg.Database.Postgres.Timezone = ""
595
			},
596
			expect: func(t *testing.T, err error) {
597
				assert := assert.New(t)
598
				assert.EqualError(err, "postgres requires parameter timezone")
599
			},
600
		},
601
		{
602
			name:   "redis requires parameter addrs",
603
			config: New(),
604
			mock: func(cfg *Config) {
605
				cfg.Auth.JWT = mockJWTConfig
606
				cfg.Database.Type = DatabaseTypeMysql
607
				cfg.Database.Mysql = mockMysqlConfig
608
				cfg.Database.Redis = mockRedisConfig
609
				cfg.Database.Redis.Addrs = []string{}
610
			},
611
			expect: func(t *testing.T, err error) {
612
				assert := assert.New(t)
613
				assert.EqualError(err, "redis requires parameter addrs")
614
			},
615
		},
616
		{
617
			name:   "redis requires parameter db",
618
			config: New(),
619
			mock: func(cfg *Config) {
620
				cfg.Auth.JWT = mockJWTConfig
621
				cfg.Database.Type = DatabaseTypeMysql
622
				cfg.Database.Mysql = mockMysqlConfig
623
				cfg.Database.Redis = mockRedisConfig
624
				cfg.Database.Redis.DB = -1
625
			},
626
			expect: func(t *testing.T, err error) {
627
				assert := assert.New(t)
628
				assert.EqualError(err, "redis requires parameter db")
629
			},
630
		},
631
		{
632
			name:   "redis requires parameter brokerDB",
633
			config: New(),
634
			mock: func(cfg *Config) {
635
				cfg.Auth.JWT = mockJWTConfig
636
				cfg.Database.Type = DatabaseTypeMysql
637
				cfg.Database.Mysql = mockMysqlConfig
638
				cfg.Database.Redis = mockRedisConfig
639
				cfg.Database.Redis.BrokerDB = -1
640
			},
641
			expect: func(t *testing.T, err error) {
642
				assert := assert.New(t)
643
				assert.EqualError(err, "redis requires parameter brokerDB")
644
			},
645
		},
646
		{
647
			name:   "redis requires parameter backendDB",
648
			config: New(),
649
			mock: func(cfg *Config) {
650
				cfg.Auth.JWT = mockJWTConfig
651
				cfg.Database.Type = DatabaseTypeMysql
652
				cfg.Database.Mysql = mockMysqlConfig
653
				cfg.Database.Redis = mockRedisConfig
654
				cfg.Database.Redis.BackendDB = -1
655
			},
656
			expect: func(t *testing.T, err error) {
657
				assert := assert.New(t)
658
				assert.EqualError(err, "redis requires parameter backendDB")
659
			},
660
		},
661
		{
662
			name:   "redis requires parameter ttl",
663
			config: New(),
664
			mock: func(cfg *Config) {
665
				cfg.Auth.JWT = mockJWTConfig
666
				cfg.Database.Type = DatabaseTypeMysql
667
				cfg.Database.Mysql = mockMysqlConfig
668
				cfg.Database.Redis = mockRedisConfig
669
				cfg.Cache.Redis.TTL = 0
670
			},
671
			expect: func(t *testing.T, err error) {
672
				assert := assert.New(t)
673
				assert.EqualError(err, "redis requires parameter ttl")
674
			},
675
		},
676
		{
677
			name:   "local requires parameter size",
678
			config: New(),
679
			mock: func(cfg *Config) {
680
				cfg.Auth.JWT = mockJWTConfig
681
				cfg.Database.Type = DatabaseTypeMysql
682
				cfg.Database.Mysql = mockMysqlConfig
683
				cfg.Database.Redis = mockRedisConfig
684
				cfg.Cache.Local.Size = 0
685
			},
686
			expect: func(t *testing.T, err error) {
687
				assert := assert.New(t)
688
				assert.EqualError(err, "local requires parameter size")
689
			},
690
		},
691
		{
692
			name:   "local requires parameter ttl",
693
			config: New(),
694
			mock: func(cfg *Config) {
695
				cfg.Auth.JWT = mockJWTConfig
696
				cfg.Database.Type = DatabaseTypeMysql
697
				cfg.Database.Mysql = mockMysqlConfig
698
				cfg.Database.Redis = mockRedisConfig
699
				cfg.Cache.Local.TTL = 0
700
			},
701
			expect: func(t *testing.T, err error) {
702
				assert := assert.New(t)
703
				assert.EqualError(err, "local requires parameter ttl")
704
			},
705
		},
706
		{
707
			name:   "preheat requires parameter caCert",
708
			config: New(),
709
			mock: func(cfg *Config) {
710
				cfg.Auth.JWT = mockJWTConfig
711
				cfg.Database.Type = DatabaseTypeMysql
712
				cfg.Database.Mysql = mockMysqlConfig
713
				cfg.Database.Redis = mockRedisConfig
714
				cfg.Job.Preheat.TLS = &PreheatTLSClientConfig{
715
					CACert: "",
716
				}
717
			},
718
			expect: func(t *testing.T, err error) {
719
				assert := assert.New(t)
720
				assert.EqualError(err, "preheat requires parameter caCert")
721
			},
722
		},
723
		{
724
			name:   "preheat requires parameter registryTimeout",
725
			config: New(),
726
			mock: func(cfg *Config) {
727
				cfg.Auth.JWT = mockJWTConfig
728
				cfg.Database.Type = DatabaseTypeMysql
729
				cfg.Database.Mysql = mockMysqlConfig
730
				cfg.Database.Redis = mockRedisConfig
731
				cfg.Job.Preheat.RegistryTimeout = 0
732
			},
733
			expect: func(t *testing.T, err error) {
734
				assert := assert.New(t)
735
				assert.EqualError(err, "preheat requires parameter registryTimeout")
736
			},
737
		},
738
		{
739
			name:   "syncPeers requires parameter interval",
740
			config: New(),
741
			mock: func(cfg *Config) {
742
				cfg.Auth.JWT = mockJWTConfig
743
				cfg.Database.Type = DatabaseTypeMysql
744
				cfg.Database.Mysql = mockMysqlConfig
745
				cfg.Database.Redis = mockRedisConfig
746
				cfg.Job.SyncPeers.Interval = 11 * time.Hour
747
			},
748
			expect: func(t *testing.T, err error) {
749
				assert := assert.New(t)
750
				assert.EqualError(err, "syncPeers requires parameter interval and it must be greater than 12 hours")
751
			},
752
		},
753
		{
754
			name:   "syncPeers requires parameter timeout",
755
			config: New(),
756
			mock: func(cfg *Config) {
757
				cfg.Auth.JWT = mockJWTConfig
758
				cfg.Database.Type = DatabaseTypeMysql
759
				cfg.Database.Mysql = mockMysqlConfig
760
				cfg.Database.Redis = mockRedisConfig
761
				cfg.Job.SyncPeers.Timeout = 0
762
			},
763
			expect: func(t *testing.T, err error) {
764
				assert := assert.New(t)
765
				assert.EqualError(err, "syncPeers requires parameter timeout")
766
			},
767
		},
768
		{
769
			name:   "objectStorage requires parameter name",
770
			config: New(),
771
			mock: func(cfg *Config) {
772
				cfg.Auth.JWT = mockJWTConfig
773
				cfg.Database.Type = DatabaseTypeMysql
774
				cfg.Database.Mysql = mockMysqlConfig
775
				cfg.Database.Redis = mockRedisConfig
776
				cfg.ObjectStorage = mockObjectStorageConfig
777
				cfg.ObjectStorage.Name = ""
778
			},
779
			expect: func(t *testing.T, err error) {
780
				assert := assert.New(t)
781
				assert.EqualError(err, "objectStorage requires parameter name")
782
			},
783
		},
784
		{
785
			name:   "invalid objectStorage name",
786
			config: New(),
787
			mock: func(cfg *Config) {
788
				cfg.Auth.JWT = mockJWTConfig
789
				cfg.Database.Type = DatabaseTypeMysql
790
				cfg.Database.Mysql = mockMysqlConfig
791
				cfg.Database.Redis = mockRedisConfig
792
				cfg.ObjectStorage = mockObjectStorageConfig
793
				cfg.ObjectStorage.Name = "foo"
794
			},
795
			expect: func(t *testing.T, err error) {
796
				assert := assert.New(t)
797
				assert.EqualError(err, "objectStorage requires parameter name")
798
			},
799
		},
800
		{
801
			name:   "objectStorage requires parameter accessKey",
802
			config: New(),
803
			mock: func(cfg *Config) {
804
				cfg.Auth.JWT = mockJWTConfig
805
				cfg.Database.Type = DatabaseTypeMysql
806
				cfg.Database.Mysql = mockMysqlConfig
807
				cfg.Database.Redis = mockRedisConfig
808
				cfg.ObjectStorage = mockObjectStorageConfig
809
				cfg.ObjectStorage.AccessKey = ""
810
			},
811
			expect: func(t *testing.T, err error) {
812
				assert := assert.New(t)
813
				assert.EqualError(err, "objectStorage requires parameter accessKey")
814
			},
815
		},
816
		{
817
			name:   "objectStorage requires parameter secretKey",
818
			config: New(),
819
			mock: func(cfg *Config) {
820
				cfg.Auth.JWT = mockJWTConfig
821
				cfg.Database.Type = DatabaseTypeMysql
822
				cfg.Database.Mysql = mockMysqlConfig
823
				cfg.Database.Redis = mockRedisConfig
824
				cfg.ObjectStorage = mockObjectStorageConfig
825
				cfg.ObjectStorage.SecretKey = ""
826
			},
827
			expect: func(t *testing.T, err error) {
828
				assert := assert.New(t)
829
				assert.EqualError(err, "objectStorage requires parameter secretKey")
830
			},
831
		},
832
		{
833
			name:   "metrics requires parameter addr",
834
			config: New(),
835
			mock: func(cfg *Config) {
836
				cfg.Auth.JWT = mockJWTConfig
837
				cfg.Database.Type = DatabaseTypeMysql
838
				cfg.Database.Mysql = mockMysqlConfig
839
				cfg.Database.Redis = mockRedisConfig
840
				cfg.Metrics = mockMetricsConfig
841
				cfg.Metrics.Addr = ""
842
			},
843
			expect: func(t *testing.T, err error) {
844
				assert := assert.New(t)
845
				assert.EqualError(err, "metrics requires parameter addr")
846
			},
847
		},
848
		{
849
			name:   "security requires parameter caCert",
850
			config: New(),
851
			mock: func(cfg *Config) {
852
				cfg.Auth.JWT = mockJWTConfig
853
				cfg.Database.Type = DatabaseTypeMysql
854
				cfg.Database.Mysql = mockMysqlConfig
855
				cfg.Database.Redis = mockRedisConfig
856
				cfg.Security = mockSecurityConfig
857
				cfg.Security.CACert = ""
858
			},
859
			expect: func(t *testing.T, err error) {
860
				assert := assert.New(t)
861
				assert.EqualError(err, "security requires parameter caCert")
862
			},
863
		},
864
		{
865
			name:   "security requires parameter caKey",
866
			config: New(),
867
			mock: func(cfg *Config) {
868
				cfg.Auth.JWT = mockJWTConfig
869
				cfg.Database.Type = DatabaseTypeMysql
870
				cfg.Database.Mysql = mockMysqlConfig
871
				cfg.Database.Redis = mockRedisConfig
872
				cfg.Security = mockSecurityConfig
873
				cfg.Security.CAKey = ""
874
			},
875
			expect: func(t *testing.T, err error) {
876
				assert := assert.New(t)
877
				assert.EqualError(err, "security requires parameter caKey")
878
			},
879
		},
880
		{
881
			name:   "security requires parameter tlsPolicy",
882
			config: New(),
883
			mock: func(cfg *Config) {
884
				cfg.Auth.JWT = mockJWTConfig
885
				cfg.Database.Type = DatabaseTypeMysql
886
				cfg.Database.Mysql = mockMysqlConfig
887
				cfg.Database.Redis = mockRedisConfig
888
				cfg.Security = mockSecurityConfig
889
				cfg.Security.TLSPolicy = ""
890
			},
891
			expect: func(t *testing.T, err error) {
892
				assert := assert.New(t)
893
				assert.EqualError(err, "security requires parameter tlsPolicy")
894
			},
895
		},
896
		{
897
			name:   "certSpec requires parameter ipAddresses",
898
			config: New(),
899
			mock: func(cfg *Config) {
900
				cfg.Auth.JWT = mockJWTConfig
901
				cfg.Database.Type = DatabaseTypeMysql
902
				cfg.Database.Mysql = mockMysqlConfig
903
				cfg.Database.Redis = mockRedisConfig
904
				cfg.Security = mockSecurityConfig
905
				cfg.Security.CertSpec.IPAddresses = []net.IP{}
906
			},
907
			expect: func(t *testing.T, err error) {
908
				assert := assert.New(t)
909
				assert.EqualError(err, "certSpec requires parameter ipAddresses")
910
			},
911
		},
912
		{
913
			name:   "certSpec requires parameter dnsNames",
914
			config: New(),
915
			mock: func(cfg *Config) {
916
				cfg.Auth.JWT = mockJWTConfig
917
				cfg.Database.Type = DatabaseTypeMysql
918
				cfg.Database.Mysql = mockMysqlConfig
919
				cfg.Database.Redis = mockRedisConfig
920
				cfg.Security = mockSecurityConfig
921
				cfg.Security.CertSpec.DNSNames = []string{}
922
			},
923
			expect: func(t *testing.T, err error) {
924
				assert := assert.New(t)
925
				assert.EqualError(err, "certSpec requires parameter dnsNames")
926
			},
927
		},
928
		{
929
			name:   "certSpec requires parameter validityPeriod",
930
			config: New(),
931
			mock: func(cfg *Config) {
932
				cfg.Auth.JWT = mockJWTConfig
933
				cfg.Database.Type = DatabaseTypeMysql
934
				cfg.Database.Mysql = mockMysqlConfig
935
				cfg.Database.Redis = mockRedisConfig
936
				cfg.Security = mockSecurityConfig
937
				cfg.Security.CertSpec.ValidityPeriod = 0
938
			},
939
			expect: func(t *testing.T, err error) {
940
				assert := assert.New(t)
941
				assert.EqualError(err, "certSpec requires parameter validityPeriod")
942
			},
943
		},
944
		{
945
			name:   "trainer requires parameter bucketName",
946
			config: New(),
947
			mock: func(cfg *Config) {
948
				cfg.Auth.JWT = mockJWTConfig
949
				cfg.Database.Type = DatabaseTypeMysql
950
				cfg.Database.Mysql = mockMysqlConfig
951
				cfg.Database.Redis = mockRedisConfig
952
				cfg.Security = mockSecurityConfig
953
				cfg.Trainer = mockTrainerConfig
954
				cfg.Trainer.BucketName = ""
955
			},
956
			expect: func(t *testing.T, err error) {
957
				assert := assert.New(t)
958
				assert.EqualError(err, "trainer requires parameter bucketName")
959
			},
960
		},
961
	}
962

963
	for _, tc := range tests {
964
		t.Run(tc.name, func(t *testing.T) {
965
			if err := tc.config.Convert(); err != nil {
966
				t.Fatal(err)
967
			}
968

969
			tc.mock(tc.config)
970
			tc.expect(t, tc.config.Validate())
971
		})
972
	}
973
}
974