dragonflyoss
/
dragonfly
mirror of https://github.com/dragonflyoss/dragonfly.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

Signed-off-by: Gaius <gaius.qi@gmail.com>
This commit is contained in:
Gaius 2023-02-28 21:31:30 +08:00
parent 06022edd15
commit c672e75ed8
No known key found for this signature in database
GPG Key ID: 8B4E5D1290FA2FFB
6 changed files with 678 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
client/config/peerhost_test.go
View File

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

2
codecov.yml
View File

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

30
manager/config/config.go
View File

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

69
manager/config/config_test.go
View File

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

17
scheduler/config/config.go
View File

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

595
scheduler/config/config_test.go
View File

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