From c672e75ed8a570b4598c0bee3ee482cd656c364f Mon Sep 17 00:00:00 2001 From: Gaius Date: Tue, 28 Feb 2023 21:31:30 +0800 Subject: [PATCH] test: add Validate test to scheduler config (#2129) Signed-off-by: Gaius --- client/config/peerhost_test.go | 34 +- codecov.yml | 2 +- manager/config/config.go | 30 +- manager/config/config_test.go | 69 ++-- scheduler/config/config.go | 17 +- scheduler/config/config_test.go | 595 +++++++++++++++++++++++++++++++- 6 files changed, 678 insertions(+), 69 deletions(-) diff --git a/client/config/peerhost_test.go b/client/config/peerhost_test.go index abbd30d6c..887e3a4f5 100644 --- a/client/config/peerhost_test.go +++ b/client/config/peerhost_test.go @@ -26,7 +26,7 @@ import ( "testing" "time" - testifyassert "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/assert" "golang.org/x/time/rate" "gopkg.in/yaml.v3" @@ -38,7 +38,6 @@ import ( ) func Test_AllUnmarshalYAML(t *testing.T) { - assert := testifyassert.New(t) var cases = []struct { text string target any @@ -160,6 +159,8 @@ diskGCThreshold: 1Ki for _, c := range cases { actual := reflect.New(reflect.TypeOf(c.target).Elem()).Interface() err := yaml.Unmarshal([]byte(c.text), actual) + + assert := assert.New(t) assert.Nil(err, "yaml.Unmarshal should return nil") assert.EqualValues(c.target, actual) } @@ -219,8 +220,6 @@ schedulers2: } func TestPeerHostOption_Load(t *testing.T) { - assert := testifyassert.New(t) - proxyExp, _ := NewRegexp("blobs/sha256.*") hijackExp, _ := NewRegexp("mirror.aliyuncs.com:443") @@ -521,6 +520,7 @@ func TestPeerHostOption_Load(t *testing.T) { t.Fatal(err) } + assert := assert.New(t) assert.EqualValues(peerHostOption, peerHostOptionYAML) } @@ -536,7 +536,7 @@ func TestPeerHostOption_Validate(t *testing.T) { config: NewDaemonConfig(), mock: func(cfg *DaemonConfig) {}, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.NoError(err) }, }, @@ -548,7 +548,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Scheduler.Manager.NetAddrs = nil }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "manager addr is not specified") }, }, @@ -566,7 +566,7 @@ func TestPeerHostOption_Validate(t *testing.T) { } }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "manager refreshInterval is not specified") }, }, @@ -577,7 +577,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Scheduler.NetAddrs = nil }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "empty schedulers and config server is not specified") }, }, @@ -588,7 +588,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Download.TotalRateLimit.Limit = rate.Limit(10 * unit.MB) }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) msg := fmt.Sprintf("rate limit must be greater than %s", DefaultMinRate.String()) assert.EqualError(err, msg) }, @@ -600,7 +600,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Upload.RateLimit.Limit = rate.Limit(10 * unit.MB) }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) msg := fmt.Sprintf("rate limit must be greater than %s", DefaultMinRate.String()) assert.EqualError(err, msg) }, @@ -613,7 +613,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.ObjectStorage.MaxReplicas = 0 }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "max replicas must be greater than 0") }, }, @@ -624,7 +624,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Reload.Interval.Duration = time.Millisecond }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "reload interval too short, must great than 1 second") }, }, @@ -635,7 +635,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.GCInterval.Duration = 0 }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "gcInterval must be greater than 0") }, }, @@ -647,7 +647,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Security.CACert = "" }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "security requires parameter caCert") }, }, @@ -660,7 +660,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Security.CertSpec.IPAddresses = nil }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "certSpec requires parameter ipAddresses") }, }, @@ -674,7 +674,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Security.CertSpec.DNSNames = nil }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "certSpec requires parameter dnsNames") }, }, @@ -687,7 +687,7 @@ func TestPeerHostOption_Validate(t *testing.T) { cfg.Security.CertSpec.ValidityPeriod = 0 }, expect: func(t *testing.T, err error) { - assert := testifyassert.New(t) + assert := assert.New(t) assert.EqualError(err, "certSpec requires parameter validityPeriod") }, }, diff --git a/codecov.yml b/codecov.yml index eb0b9a824..c23aa6732 100644 --- a/codecov.yml +++ b/codecov.yml @@ -6,7 +6,7 @@ coverage: project: default: enabled: yes - target: 40% + target: 46% patch: default: enabled: no diff --git a/manager/config/config.go b/manager/config/config.go index bc6931fc3..48dc11afe 100644 --- a/manager/config/config.go +++ b/manager/config/config.go @@ -465,18 +465,16 @@ func (cfg *Config) Validate() error { return errors.New("redis requires parameter addrs") } - if len(cfg.Database.Redis.Addrs) == 1 { - if cfg.Database.Redis.DB < 0 { - return errors.New("redis requires parameter db") - } + if cfg.Database.Redis.DB < 0 { + return errors.New("redis requires parameter db") + } - if cfg.Database.Redis.BrokerDB < 0 { - return errors.New("redis requires parameter brokerDB") - } + if cfg.Database.Redis.BrokerDB < 0 { + return errors.New("redis requires parameter brokerDB") + } - if cfg.Database.Redis.BackendDB < 0 { - return errors.New("redis requires parameter backendDB") - } + if cfg.Database.Redis.BackendDB < 0 { + return errors.New("redis requires parameter backendDB") } if cfg.Cache.Redis.TTL == 0 { @@ -509,6 +507,12 @@ func (cfg *Config) Validate() error { } } + if cfg.Metrics.Enable { + if cfg.Metrics.Addr == "" { + return errors.New("metrics requires parameter addr") + } + } + if cfg.Security.AutoIssueCert { if cfg.Security.CACert == "" { return errors.New("security requires parameter caCert") @@ -529,11 +533,9 @@ func (cfg *Config) Validate() error { if len(cfg.Security.CertSpec.DNSNames) == 0 { return errors.New("certSpec requires parameter dnsNames") } - } - if cfg.Metrics.Enable { - if cfg.Metrics.Addr == "" { - return errors.New("metrics requires parameter addr") + if cfg.Security.CertSpec.ValidityPeriod <= 0 { + return errors.New("certSpec requires parameter validityPeriod") } } diff --git a/manager/config/config_test.go b/manager/config/config_test.go index 6fdf35515..326306f43 100644 --- a/manager/config/config_test.go +++ b/manager/config/config_test.go @@ -26,6 +26,7 @@ import ( "gopkg.in/yaml.v3" "d7y.io/dragonfly/v2/pkg/objectstorage" + "d7y.io/dragonfly/v2/pkg/rpc" "d7y.io/dragonfly/v2/pkg/types" ) @@ -34,8 +35,8 @@ var ( User: "foo", Password: "bar", Host: "localhost", - Port: 3306, - DBName: "manager", + Port: DefaultMysqlPort, + DBName: DefaultMysqlDBName, TLSConfig: "true", Migrate: true, } @@ -51,10 +52,10 @@ var ( User: "foo", Password: "bar", Host: "localhost", - Port: 5432, - DBName: "manager", - SSLMode: "verify-ca", - Timezone: "UTC", + Port: DefaultPostgresPort, + DBName: DefaultPostgresDBName, + SSLMode: DefaultPostgresSSLMode, + Timezone: DefaultPostgresTimezone, Migrate: true, } @@ -63,9 +64,9 @@ var ( MasterName: "master", Username: "baz", Password: "bax", - DB: 0, - BrokerDB: 1, - BackendDB: 2, + DB: DefaultRedisDB, + BrokerDB: DefaultRedisBrokerDB, + BackendDB: DefaultRedisBackendDB, } mockObjectStorageConfig = ObjectStorageConfig{ @@ -78,28 +79,26 @@ var ( S3ForcePathStyle: true, } + mockMetricsConfig = MetricsConfig{ + Enable: true, + Addr: DefaultMetricsAddr, + EnablePeerGauge: true, + } + mockSecurityConfig = SecurityConfig{ AutoIssueCert: true, CACert: types.PEMContent("foo"), CAKey: types.PEMContent("bar"), - TLSPolicy: "force", + TLSPolicy: rpc.PreferTLSPolicy, CertSpec: CertSpec{ - DNSNames: []string{"localhost"}, - IPAddresses: []net.IP{net.ParseIP("127.0.0.1")}, - ValidityPeriod: time.Duration(1 * time.Second), + DNSNames: DefaultCertDNSNames, + IPAddresses: DefaultCertIPAddresses, + ValidityPeriod: DefaultCertValidityPeriod, }, } - - mockMetricsConfig = MetricsConfig{ - Enable: true, - Addr: "localhost", - EnablePeerGauge: true, - } ) -func TestManagerConfig_Load(t *testing.T) { - assert := assert.New(t) - +func TestConfig_Load(t *testing.T) { config := &Config{ Server: ServerConfig{ Name: "foo", @@ -202,10 +201,11 @@ func TestManagerConfig_Load(t *testing.T) { t.Fatal(err) } + assert := assert.New(t) assert.EqualValues(config, managerConfigYAML) } -func TestManagerConfig_Validate(t *testing.T) { +func TestConfig_Validate(t *testing.T) { tests := []struct { name string config *Config @@ -627,6 +627,21 @@ func TestManagerConfig_Validate(t *testing.T) { assert.EqualError(err, "objectStorage requires parameter secretKey") }, }, + { + name: "metrics requires parameter addr", + config: New(), + mock: func(cfg *Config) { + cfg.Database.Type = DatabaseTypeMysql + cfg.Database.Mysql = mockMysqlConfig + cfg.Database.Redis = mockRedisConfig + cfg.Metrics = mockMetricsConfig + cfg.Metrics.Addr = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "metrics requires parameter addr") + }, + }, { name: "security requires parameter caCert", config: New(), @@ -703,18 +718,18 @@ func TestManagerConfig_Validate(t *testing.T) { }, }, { - name: "metrics requires parameter addr", + name: "certSpec requires parameter validityPeriod", config: New(), mock: func(cfg *Config) { cfg.Database.Type = DatabaseTypeMysql cfg.Database.Mysql = mockMysqlConfig cfg.Database.Redis = mockRedisConfig - cfg.Metrics = mockMetricsConfig - cfg.Metrics.Addr = "" + cfg.Security = mockSecurityConfig + cfg.Security.CertSpec.ValidityPeriod = 0 }, expect: func(t *testing.T, err error) { assert := assert.New(t) - assert.EqualError(err, "metrics requires parameter addr") + assert.EqualError(err, "certSpec requires parameter validityPeriod") }, }, } diff --git a/scheduler/config/config.go b/scheduler/config/config.go index 5357402f6..aa356e964 100644 --- a/scheduler/config/config.go +++ b/scheduler/config/config.go @@ -26,6 +26,7 @@ import ( "d7y.io/dragonfly/v2/pkg/net/fqdn" "d7y.io/dragonfly/v2/pkg/net/ip" "d7y.io/dragonfly/v2/pkg/rpc" + "d7y.io/dragonfly/v2/pkg/slices" "d7y.io/dragonfly/v2/pkg/types" ) @@ -492,14 +493,12 @@ func (cfg *Config) Validate() error { return errors.New("job requires parameter addrs") } - if len(cfg.Job.Redis.Addrs) == 1 { - if cfg.Job.Redis.BrokerDB <= 0 { - return errors.New("job requires parameter redis brokerDB") - } + if cfg.Job.Redis.BrokerDB <= 0 { + return errors.New("job requires parameter redis brokerDB") + } - if cfg.Job.Redis.BackendDB <= 0 { - return errors.New("job requires parameter redis backendDB") - } + if cfg.Job.Redis.BackendDB <= 0 { + return errors.New("job requires parameter redis backendDB") } } @@ -526,6 +525,10 @@ func (cfg *Config) Validate() error { return errors.New("security requires parameter caCert") } + if !slices.Contains([]string{rpc.DefaultTLSPolicy, rpc.ForceTLSPolicy, rpc.PreferTLSPolicy}, cfg.Security.TLSPolicy) { + return errors.New("security requires parameter tlsPolicy") + } + if len(cfg.Security.CertSpec.IPAddresses) == 0 { return errors.New("certSpec requires parameter ipAddresses") } diff --git a/scheduler/config/config_test.go b/scheduler/config/config_test.go index 1d56cc441..312bb1590 100644 --- a/scheduler/config/config_test.go +++ b/scheduler/config/config_test.go @@ -22,13 +22,55 @@ import ( "testing" "time" - testifyassert "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/assert" "gopkg.in/yaml.v3" + + "d7y.io/dragonfly/v2/pkg/rpc" + "d7y.io/dragonfly/v2/pkg/types" +) + +var ( + mockManagerConfig = ManagerConfig{ + Addr: "localhost", + SchedulerClusterID: DefaultManagerSchedulerClusterID, + KeepAlive: KeepAliveConfig{ + Interval: DefaultManagerKeepAliveInterval, + }, + } + + mockJobConfig = JobConfig{ + Enable: true, + GlobalWorkerNum: DefaultJobGlobalWorkerNum, + SchedulerWorkerNum: DefaultJobSchedulerWorkerNum, + LocalWorkerNum: DefaultJobLocalWorkerNum, + Redis: RedisConfig{ + Addrs: []string{"127.0.0.1:6379"}, + MasterName: "master", + Username: "foo", + Password: "bar", + BrokerDB: DefaultJobRedisBrokerDB, + BackendDB: DefaultJobRedisBackendDB, + }, + } + + mockMetricsConfig = MetricsConfig{ + Enable: true, + Addr: DefaultMetricsAddr, + } + + mockSecurityConfig = SecurityConfig{ + AutoIssueCert: true, + CACert: types.PEMContent("foo"), + TLSPolicy: rpc.PreferTLSPolicy, + CertSpec: CertSpec{ + DNSNames: DefaultCertDNSNames, + IPAddresses: DefaultCertIPAddresses, + ValidityPeriod: DefaultCertValidityPeriod, + }, + } ) func TestConfig_Load(t *testing.T) { - assert := testifyassert.New(t) - config := &Config{ Scheduler: SchedulerConfig{ Algorithm: "default", @@ -130,5 +172,552 @@ func TestConfig_Load(t *testing.T) { t.Fatal(err) } + assert := assert.New(t) assert.EqualValues(schedulerConfigYAML, config) } + +func TestConfig_Validate(t *testing.T) { + tests := []struct { + name string + config *Config + mock func(cfg *Config) + expect func(t *testing.T, err error) + }{ + { + name: "valid config", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.NoError(err) + }, + }, + { + name: "server requires parameter advertiseIP", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Server.AdvertiseIP = nil + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "server requires parameter advertiseIP") + }, + }, + { + name: "server requires parameter listenIP", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Server.ListenIP = nil + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "server requires parameter listenIP") + }, + }, + { + name: "server requires parameter port", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Server.Port = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "server requires parameter port") + }, + }, + { + name: "server requires parameter host", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Server.Host = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "server requires parameter host") + }, + }, + { + name: "scheduler requires parameter algorithm", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.Algorithm = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter algorithm") + }, + }, + { + name: "scheduler requires parameter backToSourceCount", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.BackToSourceCount = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter backToSourceCount") + }, + }, + { + name: "scheduler requires parameter retryBackToSourceLimit", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.RetryBackToSourceLimit = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter retryBackToSourceLimit") + }, + }, + { + name: "scheduler requires parameter retryLimit", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.RetryLimit = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter retryLimit") + }, + }, + { + name: "scheduler requires parameter retryInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.RetryInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter retryInterval") + }, + }, + { + name: "scheduler requires parameter pieceDownloadTimeout", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.GC.PieceDownloadTimeout = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter pieceDownloadTimeout") + }, + }, + { + name: "scheduler requires parameter peerTTL", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.GC.PeerTTL = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter peerTTL") + }, + }, + { + name: "scheduler requires parameter peerGCInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.GC.PeerGCInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter peerGCInterval") + }, + }, + { + name: "scheduler requires parameter taskGCInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.GC.TaskGCInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter taskGCInterval") + }, + }, + { + name: "scheduler requires parameter hostGCInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.GC.HostGCInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter hostGCInterval") + }, + }, + { + name: "scheduler requires parameter hostTTL", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Scheduler.GC.HostTTL = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "scheduler requires parameter hostTTL") + }, + }, + { + name: "dynconfig requires parameter refreshInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.DynConfig.RefreshInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "dynconfig requires parameter refreshInterval") + }, + }, + { + name: "manager requires parameter addr", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Manager.Addr = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "manager requires parameter addr") + }, + }, + { + name: "manager requires parameter schedulerClusterID", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Manager.SchedulerClusterID = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "manager requires parameter schedulerClusterID") + }, + }, + { + name: "manager requires parameter keepAlive interval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Manager.KeepAlive.Interval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "manager requires parameter keepAlive interval") + }, + }, + { + name: "job requires parameter globalWorkerNum", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Job.GlobalWorkerNum = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "job requires parameter globalWorkerNum") + }, + }, + { + name: "job requires parameter schedulerWorkerNum", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Job.SchedulerWorkerNum = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "job requires parameter schedulerWorkerNum") + }, + }, + { + name: "job requires parameter localWorkerNum", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Job.LocalWorkerNum = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "job requires parameter localWorkerNum") + }, + }, + { + name: "job requires parameter addrs", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Job.Redis.Addrs = []string{} + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "job requires parameter addrs") + }, + }, + { + name: "job requires parameter redis brokerDB", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Job.Redis.BrokerDB = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "job requires parameter redis brokerDB") + }, + }, + { + name: "job requires parameter redis backendDB", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Job.Redis.BackendDB = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "job requires parameter redis backendDB") + }, + }, + { + name: "storage requires parameter maxSize", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Storage.MaxSize = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "storage requires parameter maxSize") + }, + }, + { + name: "storage requires parameter maxBackups", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Storage.MaxBackups = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "storage requires parameter maxBackups") + }, + }, + { + name: "storage requires parameter bufferSize", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Storage.BufferSize = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "storage requires parameter bufferSize") + }, + }, + { + name: "metrics requires parameter addr", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Metrics = mockMetricsConfig + cfg.Metrics.Addr = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "metrics requires parameter addr") + }, + }, + { + name: "security requires parameter caCert", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Security = mockSecurityConfig + cfg.Security.CACert = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "security requires parameter caCert") + }, + }, + { + name: "security requires parameter tlsPolicy", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Security = mockSecurityConfig + cfg.Security.TLSPolicy = "" + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "security requires parameter tlsPolicy") + }, + }, + { + name: "certSpec requires parameter ipAddresses", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Security = mockSecurityConfig + cfg.Security.CertSpec.IPAddresses = []net.IP{} + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "certSpec requires parameter ipAddresses") + }, + }, + { + name: "certSpec requires parameter dnsNames", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Security = mockSecurityConfig + cfg.Security.CertSpec.DNSNames = []string{} + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "certSpec requires parameter dnsNames") + }, + }, + { + name: "certSpec requires parameter validityPeriod", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.Security = mockSecurityConfig + cfg.Security.CertSpec.ValidityPeriod = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "certSpec requires parameter validityPeriod") + }, + }, + { + name: "networkTopology requires parameter SyncInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.NetworkTopology.SyncInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "networkTopology requires parameter SyncInterval") + }, + }, + { + name: "networkTopology requires parameter CollectInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.NetworkTopology.CollectInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "networkTopology requires parameter CollectInterval") + }, + }, + { + name: "probe requires parameter QueueLength", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.NetworkTopology.Probe.QueueLength = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "probe requires parameter QueueLength") + }, + }, + { + name: "probe requires parameter SyncInterval", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.NetworkTopology.Probe.SyncInterval = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "probe requires parameter SyncInterval") + }, + }, + { + name: "probe requires parameter SyncCount", + config: New(), + mock: func(cfg *Config) { + cfg.Manager = mockManagerConfig + cfg.Job = mockJobConfig + cfg.NetworkTopology.Probe.SyncCount = 0 + }, + expect: func(t *testing.T, err error) { + assert := assert.New(t) + assert.EqualError(err, "probe requires parameter SyncCount") + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if err := tc.config.Convert(); err != nil { + t.Fatal(err) + } + + tc.mock(tc.config) + tc.expect(t, tc.config.Validate()) + }) + } +}