416 lines
12 KiB
Go
416 lines
12 KiB
Go
/*
|
|
* Copyright (C) 2017 eschao <esc.chao@gmail.com>
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package config
|
|
|
|
import (
|
|
"os"
|
|
"strconv"
|
|
"testing"
|
|
|
|
"git.mousesoft.ru/ms/config/test"
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
const (
|
|
LOGIN_USER = "test-login-user"
|
|
LOGIN_PASSWORD = "test-login-passwd"
|
|
SERVICE_HOST = "test-service-host"
|
|
SERVICE_PORT = 8080
|
|
SERVICE_LOG_PATH = "/var/log/service"
|
|
SERVICE_LOG_LEVEL = "debug"
|
|
DB_HOST = "test-db-host"
|
|
DB_PORT = 9090
|
|
DB_USER = "test-db-user"
|
|
DB_PASSWORD = "test-db-password"
|
|
DB_LOG_PATH = "/var/log/db"
|
|
DB_LOG_LEVEL = "error"
|
|
)
|
|
|
|
func TestLoginConfigEnv(t *testing.T) {
|
|
var err error
|
|
|
|
assert := assert.New(t)
|
|
|
|
err = os.Setenv("USER", LOGIN_USER)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv("PASSWORD", LOGIN_PASSWORD)
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv("USER") }()
|
|
defer func() { _ = os.Unsetenv("PASSWORD") }()
|
|
|
|
loginConfig := test.LoginConfig{}
|
|
assert.NoError(ParseEnv(&loginConfig))
|
|
|
|
assert.Equal(LOGIN_USER, loginConfig.User)
|
|
assert.Equal(LOGIN_PASSWORD, loginConfig.Password)
|
|
}
|
|
|
|
func TestLoginConfigEnvWithPrefix(t *testing.T) {
|
|
var err error
|
|
|
|
assert := assert.New(t)
|
|
|
|
err = os.Setenv("DB_USER", LOGIN_USER)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv("DB_PASSWORD", LOGIN_PASSWORD)
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv("DB_USER") }()
|
|
defer func() { _ = os.Unsetenv("DB_PASSWORD") }()
|
|
|
|
loginConfig := test.LoginConfig{}
|
|
assert.NoError(ParseEnvWith(&loginConfig, "DB_", parseValueEnv))
|
|
assert.Equal(LOGIN_USER, loginConfig.User)
|
|
assert.Equal(LOGIN_PASSWORD, loginConfig.Password)
|
|
}
|
|
|
|
func TestServiceConfigEnv(t *testing.T) {
|
|
servicePrefix := "CONFIG_TEST_SERVICE_"
|
|
serviceLogPrefix := servicePrefix + "LOG_"
|
|
dbPrefix := servicePrefix + "DB_"
|
|
dbLogPrefix := dbPrefix + "LOG_"
|
|
assert := assert.New(t)
|
|
|
|
err := os.Setenv(servicePrefix+"HOST", SERVICE_HOST)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(servicePrefix+"PORT", strconv.Itoa(SERVICE_PORT))
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(serviceLogPrefix+"PATH", SERVICE_LOG_PATH)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(serviceLogPrefix+"LEVEL", SERVICE_LOG_LEVEL)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(dbPrefix+"HOST", DB_HOST)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(dbPrefix+"PORT", strconv.Itoa(DB_PORT))
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(dbPrefix+"USER", DB_USER)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(dbPrefix+"PASSWORD", DB_PASSWORD)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL)
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv(servicePrefix + "HOST") }()
|
|
defer func() { _ = os.Unsetenv(servicePrefix + "PORT") }()
|
|
defer func() { _ = os.Unsetenv(serviceLogPrefix + "PATH") }()
|
|
defer func() { _ = os.Unsetenv(serviceLogPrefix + "LEVEL") }()
|
|
defer func() { _ = os.Unsetenv(dbPrefix + "HOST") }()
|
|
defer func() { _ = os.Unsetenv(dbPrefix + "PORT") }()
|
|
defer func() { _ = os.Unsetenv(dbPrefix + "USER") }()
|
|
defer func() { _ = os.Unsetenv(dbPrefix + "PASSWORD") }()
|
|
defer func() { _ = os.Unsetenv(dbLogPrefix + "PATH") }()
|
|
defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }()
|
|
|
|
serviceConfig := test.ServiceConfig{}
|
|
assert.NoError(ParseEnv(&serviceConfig))
|
|
assert.Equal(SERVICE_HOST, serviceConfig.Host)
|
|
assert.Equal(SERVICE_PORT, serviceConfig.Port)
|
|
assert.Equal(SERVICE_LOG_PATH, serviceConfig.Log.Path)
|
|
assert.Equal(SERVICE_LOG_LEVEL, serviceConfig.Log.Level)
|
|
assert.Equal(DB_HOST, serviceConfig.DBConfig.Host)
|
|
assert.Equal(DB_PORT, serviceConfig.DBConfig.Port)
|
|
assert.Equal(DB_USER, serviceConfig.DBConfig.User)
|
|
assert.Equal(DB_PASSWORD, serviceConfig.DBConfig.Password)
|
|
assert.Equal(DB_LOG_PATH, serviceConfig.DBConfig.Log.Path)
|
|
assert.Equal(DB_LOG_LEVEL, serviceConfig.DBConfig.Log.Level)
|
|
}
|
|
|
|
func TestEnvUsage(t *testing.T) {
|
|
conf := test.ServiceConfig{}
|
|
assert.NoError(t, UsageEnv(os.Stdout, &conf))
|
|
}
|
|
|
|
func TestServiceLoginConfigEnv(t *testing.T) {
|
|
var err error
|
|
|
|
serviceLoginPrefix := "CONFIG_TEST_SERVICE_LOGIN_"
|
|
assert := assert.New(t)
|
|
|
|
err = os.Setenv(serviceLoginPrefix+"USER", LOGIN_USER)
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(serviceLoginPrefix+"PASSWORD", LOGIN_PASSWORD)
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv(serviceLoginPrefix + "USER") }()
|
|
defer func() { _ = os.Unsetenv(serviceLoginPrefix + "PASSWORD") }()
|
|
|
|
serviceConfig := test.ServiceConfig{Login: &test.LoginConfig{}}
|
|
assert.NoError(ParseEnv(&serviceConfig))
|
|
assert.Equal(LOGIN_USER, serviceConfig.Login.User)
|
|
assert.Equal(LOGIN_PASSWORD, serviceConfig.Login.Password)
|
|
}
|
|
|
|
func TestTypesConfigEnv(t *testing.T) {
|
|
var err error
|
|
|
|
typesPrefix := "CONFIG_TEST_"
|
|
assert := assert.New(t)
|
|
|
|
err = os.Setenv(typesPrefix+"BOOL", "true")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"STR", "test-string")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT8", "100")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT16", "1000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT", "10000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT32", "100000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT64", "1000000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT8", "200")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT16", "2000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT", "20000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT32", "200000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT64", "2000000")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"FLOAT32", "1.234")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"FLOAT64", "2222.33333")
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "STR") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT16") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT32") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT64") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT8") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT16") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT32") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT64") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT32") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT64") }()
|
|
|
|
typesConfig := test.TypesConfig{}
|
|
|
|
err = ParseEnv(&typesConfig)
|
|
assert.NoError(err)
|
|
|
|
assert.True(typesConfig.BoolValue)
|
|
assert.Equal("test-string", typesConfig.StrValue)
|
|
assert.Equal(int8(100), typesConfig.Int8Value)
|
|
assert.Equal(int16(1000), typesConfig.Int16Value)
|
|
assert.Equal(10000, typesConfig.IntValue)
|
|
assert.Equal(int32(100000), typesConfig.Int32Value)
|
|
assert.Equal(int64(1000000), typesConfig.Int64Value)
|
|
assert.Equal(uint8(200), typesConfig.Uint8Value)
|
|
assert.Equal(uint16(2000), typesConfig.Uint16Value)
|
|
assert.Equal(uint(20000), typesConfig.UintValue)
|
|
assert.Equal(uint32(200000), typesConfig.Uint32Value)
|
|
assert.Equal(uint64(2000000), typesConfig.Uint64Value)
|
|
assert.Equal(float32(1.234), typesConfig.Float32Value)
|
|
assert.Equal(float64(2222.33333), typesConfig.Float64Value)
|
|
}
|
|
|
|
func TestTypesConfigWithErrorEnv(t *testing.T) {
|
|
var err error
|
|
|
|
typesConfig := test.TypesConfig{}
|
|
typesPrefix := "CONFIG_TEST_"
|
|
assert := assert.New(t)
|
|
|
|
err = os.Setenv(typesPrefix+"BOOL", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "BOOL")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT8", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "INT8")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT16", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "INT16")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "INT")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT32", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "INT32")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"INT64", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "INT64")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT8", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "UINT8")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT16", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "UINT16")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "UINT")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT32", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "UINT32")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"UINT64", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "UINT64")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"FLOAT32", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "FLOAT32")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(typesPrefix+"FLOAT64", "xxx")
|
|
assert.NoError(err)
|
|
|
|
assert.Error(ParseEnv(&typesConfig))
|
|
|
|
err = os.Unsetenv(typesPrefix + "FLOAT64")
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT16") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT32") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "INT64") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT8") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT16") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT32") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "UINT64") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT32") }()
|
|
defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT64") }()
|
|
}
|
|
|
|
func TestSlicesConfigEnv(t *testing.T) {
|
|
var err error
|
|
|
|
prefix := "CONFIG_TEST_SLICES_"
|
|
assert := assert.New(t)
|
|
|
|
err = os.Setenv(prefix+"PATHS", "/var:/usr:/home")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(prefix+"DEBUG", "/root;/log;/opt")
|
|
assert.NoError(err)
|
|
|
|
err = os.Setenv(prefix+"VALUES", "1,2,4,5")
|
|
assert.NoError(err)
|
|
|
|
defer func() { _ = os.Unsetenv(prefix + "PATHS") }()
|
|
defer func() { _ = os.Unsetenv(prefix + "DEBUG") }()
|
|
defer func() { _ = os.Unsetenv(prefix + "VALUES") }()
|
|
|
|
conf := test.SlicesConfig{}
|
|
assert.NoError(ParseEnv(&conf))
|
|
assert.Equal(3, len(conf.Paths))
|
|
assert.Equal("/var", conf.Paths[0])
|
|
assert.Equal("/usr", conf.Paths[1])
|
|
assert.Equal("/home", conf.Paths[2])
|
|
assert.Equal(3, len(conf.Debugs))
|
|
assert.Equal("/root", conf.Debugs[0])
|
|
assert.Equal("/log", conf.Debugs[1])
|
|
assert.Equal("/opt", conf.Debugs[2])
|
|
assert.Equal(4, len(conf.Values))
|
|
assert.Equal(1, conf.Values[0])
|
|
assert.Equal(2, conf.Values[1])
|
|
assert.Equal(4, conf.Values[2])
|
|
assert.Equal(5, conf.Values[3])
|
|
}
|