ms/config
2
0
Fork 0
Code Actions

Выполнен рефакторинг тестов, обновлена документация.
All checks were successful
test / test (push) Successful in 58s
Details

Browse Source
This commit is contained in:
Алексей Бадяев 2024-10-21 18:55:14 +07:00
parent 7d6bc833a3
commit ce3402b295
Signed by: alexey
GPG Key ID: 686FBC1363E4AFAE
4 changed files with 168 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
README.md
View File

@ -62,8 +62,8 @@ Like parsing JSON object, using **json** keyword to define configuration name:
type Database struct { type Database struct {
Host string `json:"host"` Host string `json:"host"`
Port int `json:"port"` Port int `json:"port"`
Username string `json:"username" default:"admin"` Username string `default:"admin" json:"username"`
Password string `json:"password" default:"admin"` Password string `default:"admin" json:"password"`
Log Log `json:"log"` Log Log `json:"log"`
} }
``` ```
@ -91,8 +91,8 @@ Like parsing Yaml object, using **yaml** keyword to define configuration name
type Database struct { type Database struct {
Host string `yaml:"host"` Host string `yaml:"host"`
Port int `yaml:"port"` Port int `yaml:"port"`
Username string `yaml:"username" default:"admin"` Username string `default:"admin" yaml:"username"`
Password string `yaml:"password" default:"admin"` Password string `default:"admin" yaml:"password"`
Log Log `yaml:"log"` Log Log `yaml:"log"`
} }
``` ```
@ -117,8 +117,8 @@ Using **env** keyword to define configuration name
type Database struct { type Database struct {
Host string `env:"DB_HOST"` Host string `env:"DB_HOST"`
Port int `env:"DB_PORT"` Port int `env:"DB_PORT"`
Username string `env:"DB_USER" default:"admin"` Username string `default:"admin" env:"DB_USER"`
Password string `env:"DB_PASSWORD" default:"admin"` Password string `default:"admin" env:"DB_PASSWORD"`
Log Log `env:"DB_LOG_"` Log Log `env:"DB_LOG_"`
} }
``` ```
@ -142,7 +142,7 @@ be used, that means the `Path` will be mapped to `PATH`.
#### 6. Defines configuration name for Command line #### 6. Defines configuration name for Command line
Using **cli** keyword to define configuration name Using **cli** keyword to define configuration name:
```golang ```golang
type Database struct { type Database struct {
@ -154,19 +154,19 @@ Using **cli** keyword to define configuration name
} }
``` ```
For **cli** definition, the string before the first space is command line argument, For **cli** definition, the string is command line argument, and the **usage**
the rest string are the command line usage and will be outputted when printing usage tag are the command line usage and will be outputted when printing usage.
Corresponding command line: Corresponding command line:
```shell ```shell
./main -host test.db.hostname -port 8080 -username admin -password admin log -path /var/logs/db -level debug ./main --host test.db.hostname --port 8080 --username admin --password admin --log-path /var/logs/db --log-level debug
``` ```
or or
```shell ```shell
./main -host=test.db.hostname -port=8080 -username=admin -password=admin log -path=/var/logs/db -level=debug ./main --host=test.db.hostname --port=8080 --username=admin --password=admin --log-path=/var/logs/db --log-level=debug
``` ```
#### 7. Defines configuration name as a slice type #### 7. Defines configuration name as a slice type
@ -175,12 +175,12 @@ Using **separator** to split string as a slice:
```golang ```golang
type Log struct { type Log struct {
Levels []string `env:"LEVELS" cli:"levels log levels" separator:";"` Levels []string `env:"LEVELS" cli:"levels" separator:";" usage:"log levels"`
} }
``` ```
If the separator is not given, its default is **:**, The separator only works on If the separator is not given, its default is **:**, The separator only works on
**env** and **cli** tags **env** and **cli** tags.
```golang ```golang
logConfig := Log{} logConfig := Log{}
@ -271,16 +271,16 @@ Examples:
```golang ```golang
type Log struct { type Log struct {
Path string `json:"path" yaml:"path" env:"PATH" cli:"path log path" default:"/var/logs"` Path string `cli:"path" default:"/var/logs" env:"PATH" json:"path" usage:"log path" yaml:"path"`
Levels string `json:"levels" yaml:"levels" env:"LEVELS" cli:"levels log levels" default:"debug;error"` Levels string `cli:"levels" default:"debug;error" env:"LEVELS" json:"levels" usage:"log levels" yaml:"levels"`
} }
type Database struct { type Database struct {
Host string `json:"host" yaml:"host" env:"DB_HOST" cli:"host database host name"` Host string `cli:"host" env:"DB_HOST" json:"host" usage:"database host name" yaml:"host"`
Port int `json:"port" yaml:"port" env:"DB_PORT" cli:"port database port"` Port int `cli:"port" env:"DB_PORT" json:"port" usage:"database port" yaml:"port"`
Username string `json:"user" yaml" user" env:"DB_USER" cli:"username database username" default:"admin"` Username string `cli:"username" default:"admin" env:"DB_USER" json:"user" usage:"database username" yaml" user"`
Password string `json:"passwd" yaml:"passwd" env:"DB_PASSWD" cli:"password database password" default:"admin"` Password string `cli:"password" default:"admin" env:"DB_PASSWD" json:"passwd" usage:"database password" yaml:"passwd"`
Log Log `json:"log" yaml:"log" env:"DB_LOG_" cli:"log database log configurations"` Log Log `cli:"log" env:"DB_LOG_" json:"log" usage:"database log configurations" yaml:"log"`
} }
``` ```

2
cli_test.go
View File

@ -256,3 +256,5 @@ func TestCommandWithSlices(t *testing.T) {
assert.Equal(200, conf.Values[1]) assert.Equal(200, conf.Values[1])
assert.Equal(300, conf.Values[2]) assert.Equal(300, conf.Values[2])
} }
func TestUsage(t *testing.T) {}

31
config_test.go
View File

@ -43,27 +43,28 @@ func TestDefaultValueConfig(t *testing.T) {
} }
func TestEnvConfig(t *testing.T) { func TestEnvConfig(t *testing.T) {
dbLogPrefix := "LOG_"
var err error var err error
dbLogPrefix := "LOG_"
assert := assert.New(t)
err = os.Setenv("HOST", DB_HOST) err = os.Setenv("HOST", DB_HOST)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv("PORT", strconv.Itoa(DB_PORT)) err = os.Setenv("PORT", strconv.Itoa(DB_PORT))
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv("USER", DB_USER) err = os.Setenv("USER", DB_USER)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv("PASSWORD", DB_PASSWORD) err = os.Setenv("PASSWORD", DB_PASSWORD)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH) err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL) err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL)
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv("HOST") }() defer func() { _ = os.Unsetenv("HOST") }()
defer func() { _ = os.Unsetenv("PORT") }() defer func() { _ = os.Unsetenv("PORT") }()
@ -73,13 +74,13 @@ func TestEnvConfig(t *testing.T) {
defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }() defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }()
conf := test.DBConfig{} conf := test.DBConfig{}
assert.NoError(t, ParseEnv(&conf)) assert.NoError(ParseEnv(&conf))
assert.Equal(t, DB_HOST, conf.Host) assert.Equal(DB_HOST, conf.Host)
assert.Equal(t, DB_PORT, conf.Port) assert.Equal(DB_PORT, conf.Port)
assert.Equal(t, DB_USER, conf.User) assert.Equal(DB_USER, conf.User)
assert.Equal(t, DB_PASSWORD, conf.Password) assert.Equal(DB_PASSWORD, conf.Password)
assert.Equal(t, DB_LOG_PATH, conf.Log.Path) assert.Equal(DB_LOG_PATH, conf.Log.Path)
assert.Equal(t, DB_LOG_LEVEL, conf.Log.Level) assert.Equal(DB_LOG_LEVEL, conf.Log.Level)
} }
func TestJSONConfigFile(t *testing.T) { func TestJSONConfigFile(t *testing.T) {

251
env_test.go
View File

@ -42,38 +42,42 @@ const (
func TestLoginConfigEnv(t *testing.T) { func TestLoginConfigEnv(t *testing.T) {
var err error var err error
assert := assert.New(t)
err = os.Setenv("USER", LOGIN_USER) err = os.Setenv("USER", LOGIN_USER)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv("PASSWORD", LOGIN_PASSWORD) err = os.Setenv("PASSWORD", LOGIN_PASSWORD)
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv("USER") }() defer func() { _ = os.Unsetenv("USER") }()
defer func() { _ = os.Unsetenv("PASSWORD") }() defer func() { _ = os.Unsetenv("PASSWORD") }()
loginConfig := test.LoginConfig{} loginConfig := test.LoginConfig{}
assert.NoError(t, ParseEnv(&loginConfig)) assert.NoError(ParseEnv(&loginConfig))
assert.Equal(t, LOGIN_USER, loginConfig.User) assert.Equal(LOGIN_USER, loginConfig.User)
assert.Equal(t, LOGIN_PASSWORD, loginConfig.Password) assert.Equal(LOGIN_PASSWORD, loginConfig.Password)
} }
func TestLoginConfigEnvWithPrefix(t *testing.T) { func TestLoginConfigEnvWithPrefix(t *testing.T) {
var err error var err error
assert := assert.New(t)
err = os.Setenv("DB_USER", LOGIN_USER) err = os.Setenv("DB_USER", LOGIN_USER)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv("DB_PASSWORD", LOGIN_PASSWORD) err = os.Setenv("DB_PASSWORD", LOGIN_PASSWORD)
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv("DB_USER") }() defer func() { _ = os.Unsetenv("DB_USER") }()
defer func() { _ = os.Unsetenv("DB_PASSWORD") }() defer func() { _ = os.Unsetenv("DB_PASSWORD") }()
loginConfig := test.LoginConfig{} loginConfig := test.LoginConfig{}
assert.NoError(t, ParseEnvWith(&loginConfig, "DB_")) assert.NoError(ParseEnvWith(&loginConfig, "DB_"))
assert.Equal(t, LOGIN_USER, loginConfig.User) assert.Equal(LOGIN_USER, loginConfig.User)
assert.Equal(t, LOGIN_PASSWORD, loginConfig.Password) assert.Equal(LOGIN_PASSWORD, loginConfig.Password)
} }
func TestServiceConfigEnv(t *testing.T) { func TestServiceConfigEnv(t *testing.T) {
@ -81,36 +85,37 @@ func TestServiceConfigEnv(t *testing.T) {
serviceLogPrefix := servicePrefix + "LOG_" serviceLogPrefix := servicePrefix + "LOG_"
dbPrefix := servicePrefix + "DB_" dbPrefix := servicePrefix + "DB_"
dbLogPrefix := dbPrefix + "LOG_" dbLogPrefix := dbPrefix + "LOG_"
assert := assert.New(t)
err := os.Setenv(servicePrefix+"HOST", SERVICE_HOST) err := os.Setenv(servicePrefix+"HOST", SERVICE_HOST)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(servicePrefix+"PORT", strconv.Itoa(SERVICE_PORT)) err = os.Setenv(servicePrefix+"PORT", strconv.Itoa(SERVICE_PORT))
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(serviceLogPrefix+"PATH", SERVICE_LOG_PATH) err = os.Setenv(serviceLogPrefix+"PATH", SERVICE_LOG_PATH)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(serviceLogPrefix+"LEVEL", SERVICE_LOG_LEVEL) err = os.Setenv(serviceLogPrefix+"LEVEL", SERVICE_LOG_LEVEL)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbPrefix+"HOST", DB_HOST) err = os.Setenv(dbPrefix+"HOST", DB_HOST)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbPrefix+"PORT", strconv.Itoa(DB_PORT)) err = os.Setenv(dbPrefix+"PORT", strconv.Itoa(DB_PORT))
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbPrefix+"USER", DB_USER) err = os.Setenv(dbPrefix+"USER", DB_USER)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbPrefix+"PASSWORD", DB_PASSWORD) err = os.Setenv(dbPrefix+"PASSWORD", DB_PASSWORD)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH) err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL) err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL)
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv(servicePrefix + "HOST") }() defer func() { _ = os.Unsetenv(servicePrefix + "HOST") }()
defer func() { _ = os.Unsetenv(servicePrefix + "PORT") }() defer func() { _ = os.Unsetenv(servicePrefix + "PORT") }()
@ -124,85 +129,87 @@ func TestServiceConfigEnv(t *testing.T) {
defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }() defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }()
serviceConfig := test.ServiceConfig{} serviceConfig := test.ServiceConfig{}
assert.NoError(t, ParseEnv(&serviceConfig)) assert.NoError(ParseEnv(&serviceConfig))
assert.Equal(t, SERVICE_HOST, serviceConfig.Host) assert.Equal(SERVICE_HOST, serviceConfig.Host)
assert.Equal(t, SERVICE_PORT, serviceConfig.Port) assert.Equal(SERVICE_PORT, serviceConfig.Port)
assert.Equal(t, SERVICE_LOG_PATH, serviceConfig.Log.Path) assert.Equal(SERVICE_LOG_PATH, serviceConfig.Log.Path)
assert.Equal(t, SERVICE_LOG_LEVEL, serviceConfig.Log.Level) assert.Equal(SERVICE_LOG_LEVEL, serviceConfig.Log.Level)
assert.Equal(t, DB_HOST, serviceConfig.DBConfig.Host) assert.Equal(DB_HOST, serviceConfig.DBConfig.Host)
assert.Equal(t, DB_PORT, serviceConfig.DBConfig.Port) assert.Equal(DB_PORT, serviceConfig.DBConfig.Port)
assert.Equal(t, DB_USER, serviceConfig.DBConfig.User) assert.Equal(DB_USER, serviceConfig.DBConfig.User)
assert.Equal(t, DB_PASSWORD, serviceConfig.DBConfig.Password) assert.Equal(DB_PASSWORD, serviceConfig.DBConfig.Password)
assert.Equal(t, DB_LOG_PATH, serviceConfig.DBConfig.Log.Path) assert.Equal(DB_LOG_PATH, serviceConfig.DBConfig.Log.Path)
assert.Equal(t, DB_LOG_LEVEL, serviceConfig.DBConfig.Log.Level) assert.Equal(DB_LOG_LEVEL, serviceConfig.DBConfig.Log.Level)
} }
func TestServiceLoginConfigEnv(t *testing.T) { func TestServiceLoginConfigEnv(t *testing.T) {
var err error var err error
serviceLoginPrefix := "CONFIG_TEST_SERVICE_LOGIN_" serviceLoginPrefix := "CONFIG_TEST_SERVICE_LOGIN_"
assert := assert.New(t)
err = os.Setenv(serviceLoginPrefix+"USER", LOGIN_USER) err = os.Setenv(serviceLoginPrefix+"USER", LOGIN_USER)
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(serviceLoginPrefix+"PASSWORD", LOGIN_PASSWORD) err = os.Setenv(serviceLoginPrefix+"PASSWORD", LOGIN_PASSWORD)
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv(serviceLoginPrefix + "USER") }() defer func() { _ = os.Unsetenv(serviceLoginPrefix + "USER") }()
defer func() { _ = os.Unsetenv(serviceLoginPrefix + "PASSWORD") }() defer func() { _ = os.Unsetenv(serviceLoginPrefix + "PASSWORD") }()
serviceConfig := test.ServiceConfig{Login: &test.LoginConfig{}} serviceConfig := test.ServiceConfig{Login: &test.LoginConfig{}}
assert.NoError(t, ParseEnv(&serviceConfig)) assert.NoError(ParseEnv(&serviceConfig))
assert.Equal(t, LOGIN_USER, serviceConfig.Login.User) assert.Equal(LOGIN_USER, serviceConfig.Login.User)
assert.Equal(t, LOGIN_PASSWORD, serviceConfig.Login.Password) assert.Equal(LOGIN_PASSWORD, serviceConfig.Login.Password)
} }
func TestTypesConfigEnv(t *testing.T) { func TestTypesConfigEnv(t *testing.T) {
var err error var err error
typesPrefix := "CONFIG_TEST_" typesPrefix := "CONFIG_TEST_"
assert := assert.New(t)
err = os.Setenv(typesPrefix+"BOOL", "true") err = os.Setenv(typesPrefix+"BOOL", "true")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"STR", "test-string") err = os.Setenv(typesPrefix+"STR", "test-string")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT8", "100") err = os.Setenv(typesPrefix+"INT8", "100")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT16", "1000") err = os.Setenv(typesPrefix+"INT16", "1000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT", "10000") err = os.Setenv(typesPrefix+"INT", "10000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT32", "100000") err = os.Setenv(typesPrefix+"INT32", "100000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT64", "1000000") err = os.Setenv(typesPrefix+"INT64", "1000000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT8", "200") err = os.Setenv(typesPrefix+"UINT8", "200")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT16", "2000") err = os.Setenv(typesPrefix+"UINT16", "2000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT", "20000") err = os.Setenv(typesPrefix+"UINT", "20000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT32", "200000") err = os.Setenv(typesPrefix+"UINT32", "200000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT64", "2000000") err = os.Setenv(typesPrefix+"UINT64", "2000000")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"FLOAT32", "1.234") err = os.Setenv(typesPrefix+"FLOAT32", "1.234")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"FLOAT64", "2222.33333") err = os.Setenv(typesPrefix+"FLOAT64", "2222.33333")
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }() defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }()
defer func() { _ = os.Unsetenv(typesPrefix + "STR") }() defer func() { _ = os.Unsetenv(typesPrefix + "STR") }()
@ -222,22 +229,22 @@ func TestTypesConfigEnv(t *testing.T) {
typesConfig := test.TypesConfig{} typesConfig := test.TypesConfig{}
err = ParseEnv(&typesConfig) err = ParseEnv(&typesConfig)
assert.NoError(t, err) assert.NoError(err)
assert.True(t, typesConfig.BoolValue) assert.True(typesConfig.BoolValue)
assert.Equal(t, "test-string", typesConfig.StrValue) assert.Equal("test-string", typesConfig.StrValue)
assert.Equal(t, int8(100), typesConfig.Int8Value) assert.Equal(int8(100), typesConfig.Int8Value)
assert.Equal(t, int16(1000), typesConfig.Int16Value) assert.Equal(int16(1000), typesConfig.Int16Value)
assert.Equal(t, 10000, typesConfig.IntValue) assert.Equal(10000, typesConfig.IntValue)
assert.Equal(t, int32(100000), typesConfig.Int32Value) assert.Equal(int32(100000), typesConfig.Int32Value)
assert.Equal(t, int64(1000000), typesConfig.Int64Value) assert.Equal(int64(1000000), typesConfig.Int64Value)
assert.Equal(t, uint8(200), typesConfig.Uint8Value) assert.Equal(uint8(200), typesConfig.Uint8Value)
assert.Equal(t, uint16(2000), typesConfig.Uint16Value) assert.Equal(uint16(2000), typesConfig.Uint16Value)
assert.Equal(t, uint(20000), typesConfig.UintValue) assert.Equal(uint(20000), typesConfig.UintValue)
assert.Equal(t, uint32(200000), typesConfig.Uint32Value) assert.Equal(uint32(200000), typesConfig.Uint32Value)
assert.Equal(t, uint64(2000000), typesConfig.Uint64Value) assert.Equal(uint64(2000000), typesConfig.Uint64Value)
assert.Equal(t, float32(1.234), typesConfig.Float32Value) assert.Equal(float32(1.234), typesConfig.Float32Value)
assert.Equal(t, float64(2222.33333), typesConfig.Float64Value) assert.Equal(float64(2222.33333), typesConfig.Float64Value)
} }
func TestTypesConfigWithErrorEnv(t *testing.T) { func TestTypesConfigWithErrorEnv(t *testing.T) {
@ -245,110 +252,111 @@ func TestTypesConfigWithErrorEnv(t *testing.T) {
typesConfig := test.TypesConfig{} typesConfig := test.TypesConfig{}
typesPrefix := "CONFIG_TEST_" typesPrefix := "CONFIG_TEST_"
assert := assert.New(t)
err = os.Setenv(typesPrefix+"BOOL", "xxx") err = os.Setenv(typesPrefix+"BOOL", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "BOOL") err = os.Unsetenv(typesPrefix + "BOOL")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT8", "xxx") err = os.Setenv(typesPrefix+"INT8", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "INT8") err = os.Unsetenv(typesPrefix + "INT8")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT16", "xxx") err = os.Setenv(typesPrefix+"INT16", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "INT16") err = os.Unsetenv(typesPrefix + "INT16")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT", "xxx") err = os.Setenv(typesPrefix+"INT", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "INT") err = os.Unsetenv(typesPrefix + "INT")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT32", "xxx") err = os.Setenv(typesPrefix+"INT32", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "INT32") err = os.Unsetenv(typesPrefix + "INT32")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"INT64", "xxx") err = os.Setenv(typesPrefix+"INT64", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "INT64") err = os.Unsetenv(typesPrefix + "INT64")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT8", "xxx") err = os.Setenv(typesPrefix+"UINT8", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "UINT8") err = os.Unsetenv(typesPrefix + "UINT8")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT16", "xxx") err = os.Setenv(typesPrefix+"UINT16", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "UINT16") err = os.Unsetenv(typesPrefix + "UINT16")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT", "xxx") err = os.Setenv(typesPrefix+"UINT", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "UINT") err = os.Unsetenv(typesPrefix + "UINT")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT32", "xxx") err = os.Setenv(typesPrefix+"UINT32", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "UINT32") err = os.Unsetenv(typesPrefix + "UINT32")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"UINT64", "xxx") err = os.Setenv(typesPrefix+"UINT64", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "UINT64") err = os.Unsetenv(typesPrefix + "UINT64")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"FLOAT32", "xxx") err = os.Setenv(typesPrefix+"FLOAT32", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "FLOAT32") err = os.Unsetenv(typesPrefix + "FLOAT32")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(typesPrefix+"FLOAT64", "xxx") err = os.Setenv(typesPrefix+"FLOAT64", "xxx")
assert.NoError(t, err) assert.NoError(err)
assert.Error(t, ParseEnv(&typesConfig)) assert.Error(ParseEnv(&typesConfig))
err = os.Unsetenv(typesPrefix + "FLOAT64") err = os.Unsetenv(typesPrefix + "FLOAT64")
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }() defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }()
defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }() defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }()
@ -369,33 +377,34 @@ func TestSlicesConfigEnv(t *testing.T) {
var err error var err error
prefix := "CONFIG_TEST_SLICES_" prefix := "CONFIG_TEST_SLICES_"
assert := assert.New(t)
err = os.Setenv(prefix+"PATHS", "/var:/usr:/home") err = os.Setenv(prefix+"PATHS", "/var:/usr:/home")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(prefix+"DEBUG", "/root;/log;/opt") err = os.Setenv(prefix+"DEBUG", "/root;/log;/opt")
assert.NoError(t, err) assert.NoError(err)
err = os.Setenv(prefix+"VALUES", "1,2,4,5") err = os.Setenv(prefix+"VALUES", "1,2,4,5")
assert.NoError(t, err) assert.NoError(err)
defer func() { _ = os.Unsetenv(prefix + "PATHS") }() defer func() { _ = os.Unsetenv(prefix + "PATHS") }()
defer func() { _ = os.Unsetenv(prefix + "DEBUG") }() defer func() { _ = os.Unsetenv(prefix + "DEBUG") }()
defer func() { _ = os.Unsetenv(prefix + "VALUES") }() defer func() { _ = os.Unsetenv(prefix + "VALUES") }()
conf := test.SlicesConfig{} conf := test.SlicesConfig{}
assert.NoError(t, ParseEnv(&conf)) assert.NoError(ParseEnv(&conf))
assert.Equal(t, 3, len(conf.Paths)) assert.Equal(3, len(conf.Paths))
assert.Equal(t, "/var", conf.Paths[0]) assert.Equal("/var", conf.Paths[0])
assert.Equal(t, "/usr", conf.Paths[1]) assert.Equal("/usr", conf.Paths[1])
assert.Equal(t, "/home", conf.Paths[2]) assert.Equal("/home", conf.Paths[2])
assert.Equal(t, 3, len(conf.Debugs)) assert.Equal(3, len(conf.Debugs))
assert.Equal(t, "/root", conf.Debugs[0]) assert.Equal("/root", conf.Debugs[0])
assert.Equal(t, "/log", conf.Debugs[1]) assert.Equal("/log", conf.Debugs[1])
assert.Equal(t, "/opt", conf.Debugs[2]) assert.Equal("/opt", conf.Debugs[2])
assert.Equal(t, 4, len(conf.Values)) assert.Equal(4, len(conf.Values))
assert.Equal(t, 1, conf.Values[0]) assert.Equal(1, conf.Values[0])
assert.Equal(t, 2, conf.Values[1]) assert.Equal(2, conf.Values[1])
assert.Equal(t, 4, conf.Values[2]) assert.Equal(4, conf.Values[2])
assert.Equal(t, 5, conf.Values[3]) assert.Equal(5, conf.Values[3])
} }