test: add Validate test to scheduler config (#2129)

Signed-off-by: Gaius <gaius.qi@gmail.com>

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")
 			},
 		},

codecov.yml

@@ -6,7 +6,7 @@ coverage:
     project:
       default:
         enabled: yes
-        target: 40%
+        target: 46%
     patch:
       default:
         enabled: no

manager/config/config.go

@@ -465,7 +465,6 @@ 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")
 	}
@@ -477,7 +476,6 @@ func (cfg *Config) Validate() error {
 	if cfg.Database.Redis.BackendDB < 0 {
 		return errors.New("redis requires parameter backendDB")
 	}
-	}
 
 	if cfg.Cache.Redis.TTL == 0 {
 		return errors.New("redis requires parameter ttl")
@@ -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.Security.CertSpec.ValidityPeriod <= 0 {
-		if cfg.Metrics.Addr == "" {
+			return errors.New("certSpec requires parameter validityPeriod")
-			return errors.New("metrics requires parameter addr")
 		}
 	}
 

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,
+		Port:      DefaultMysqlPort,
-		DBName:    "manager",
+		DBName:    DefaultMysqlDBName,
 		TLSConfig: "true",
 		Migrate:   true,
 	}
@@ -51,10 +52,10 @@ var (
 		User:     "foo",
 		Password: "bar",
 		Host:     "localhost",
-		Port:     5432,
+		Port:     DefaultPostgresPort,
-		DBName:   "manager",
+		DBName:   DefaultPostgresDBName,
-		SSLMode:  "verify-ca",
+		SSLMode:  DefaultPostgresSSLMode,
-		Timezone: "UTC",
+		Timezone: DefaultPostgresTimezone,
 		Migrate:  true,
 	}
 
@@ -63,9 +64,9 @@ var (
 		MasterName: "master",
 		Username:   "baz",
 		Password:   "bax",
-		DB:         0,
+		DB:         DefaultRedisDB,
-		BrokerDB:   1,
+		BrokerDB:   DefaultRedisBrokerDB,
-		BackendDB:  2,
+		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"},
+			DNSNames:       DefaultCertDNSNames,
-			IPAddresses:    []net.IP{net.ParseIP("127.0.0.1")},
+			IPAddresses:    DefaultCertIPAddresses,
-			ValidityPeriod: time.Duration(1 * time.Second),
+			ValidityPeriod: DefaultCertValidityPeriod,
 		},
 	}
-
-	mockMetricsConfig = MetricsConfig{
-		Enable:          true,
-		Addr:            "localhost",
-		EnablePeerGauge: true,
-	}
 )
 
-func TestManagerConfig_Load(t *testing.T) {
+func TestConfig_Load(t *testing.T) {
-	assert := assert.New(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.Security = mockSecurityConfig
-				cfg.Metrics.Addr = ""
+				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")
 			},
 		},
 	}

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,7 +493,6 @@ 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")
 		}
@@ -501,7 +501,6 @@ func (cfg *Config) Validate() error {
 			return errors.New("job requires parameter redis backendDB")
 		}
 	}
-	}
 
 	if cfg.Storage.MaxSize <= 0 {
 		return errors.New("storage requires parameter maxSize")
@@ -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")
 		}

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())
+		})
+	}
+}