637 lines
20 KiB
Go
637 lines
20 KiB
Go
package cosmovisor
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/rs/zerolog"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
"github.com/cosmos/cosmos-sdk/cosmovisor/errors"
|
|
)
|
|
|
|
type argsTestSuite struct {
|
|
suite.Suite
|
|
}
|
|
|
|
func TestArgsTestSuite(t *testing.T) {
|
|
suite.Run(t, new(argsTestSuite))
|
|
}
|
|
|
|
// cosmovisorEnv are the string values of environment variables used to configure Cosmovisor.
|
|
type cosmovisorEnv struct {
|
|
Home string
|
|
Name string
|
|
DownloadBin string
|
|
RestartUpgrade string
|
|
SkipBackup string
|
|
DataBackupPath string
|
|
Interval string
|
|
PreupgradeMaxRetries string
|
|
}
|
|
|
|
// ToMap creates a map of the cosmovisorEnv where the keys are the env var names.
|
|
func (c cosmovisorEnv) ToMap() map[string]string {
|
|
return map[string]string{
|
|
EnvHome: c.Home,
|
|
EnvName: c.Name,
|
|
EnvDownloadBin: c.DownloadBin,
|
|
EnvRestartUpgrade: c.RestartUpgrade,
|
|
EnvSkipBackup: c.SkipBackup,
|
|
EnvDataBackupPath: c.DataBackupPath,
|
|
EnvInterval: c.Interval,
|
|
EnvPreupgradeMaxRetries: c.PreupgradeMaxRetries,
|
|
}
|
|
}
|
|
|
|
// Set sets the field in this cosmovisorEnv corresponding to the provided envVar to the given envVal.
|
|
func (c *cosmovisorEnv) Set(envVar, envVal string) {
|
|
switch envVar {
|
|
case EnvHome:
|
|
c.Home = envVal
|
|
case EnvName:
|
|
c.Name = envVal
|
|
case EnvDownloadBin:
|
|
c.DownloadBin = envVal
|
|
case EnvRestartUpgrade:
|
|
c.RestartUpgrade = envVal
|
|
case EnvSkipBackup:
|
|
c.SkipBackup = envVal
|
|
case EnvDataBackupPath:
|
|
c.DataBackupPath = envVal
|
|
case EnvInterval:
|
|
c.Interval = envVal
|
|
case EnvPreupgradeMaxRetries:
|
|
c.PreupgradeMaxRetries = envVal
|
|
default:
|
|
panic(fmt.Errorf("Unknown environment variable [%s]. Ccannot set field to [%s]. ", envVar, envVal))
|
|
}
|
|
}
|
|
|
|
// clearEnv clears environment variables and what they were.
|
|
// Designed to be used like this:
|
|
// initialEnv := clearEnv()
|
|
// defer setEnv(nil, initialEnv)
|
|
func (s *argsTestSuite) clearEnv() *cosmovisorEnv {
|
|
s.T().Logf("Clearing environment variables.")
|
|
rv := cosmovisorEnv{}
|
|
for envVar := range rv.ToMap() {
|
|
rv.Set(envVar, os.Getenv(envVar))
|
|
s.Require().NoError(os.Unsetenv(envVar))
|
|
}
|
|
return &rv
|
|
}
|
|
|
|
// setEnv sets environment variables to the values provided.
|
|
// If t is not nil, and there's a problem, the test will fail immediately.
|
|
// If t is nil, problems will just be logged using s.T().
|
|
func (s *argsTestSuite) setEnv(t *testing.T, env *cosmovisorEnv) {
|
|
if t == nil {
|
|
s.T().Logf("Restoring environment variables.")
|
|
}
|
|
for envVar, envVal := range env.ToMap() {
|
|
var err error
|
|
var msg string
|
|
if len(envVal) != 0 {
|
|
err = os.Setenv(envVar, envVal)
|
|
msg = fmt.Sprintf("setting %s to %s", envVar, envVal)
|
|
} else {
|
|
err = os.Unsetenv(envVar)
|
|
msg = fmt.Sprintf("unsetting %s", envVar)
|
|
}
|
|
switch {
|
|
case t != nil:
|
|
require.NoError(t, err, msg)
|
|
case err != nil:
|
|
s.T().Logf("error %s: %v", msg, err)
|
|
default:
|
|
s.T().Logf("done %s", msg)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *argsTestSuite) TestConfigPaths() {
|
|
cases := map[string]struct {
|
|
cfg Config
|
|
upgradeName string
|
|
expectRoot string
|
|
expectGenesis string
|
|
expectUpgrade string
|
|
}{
|
|
"simple": {
|
|
cfg: Config{Home: "/foo", Name: "myd"},
|
|
upgradeName: "bar",
|
|
expectRoot: fmt.Sprintf("/foo/%s", rootName),
|
|
expectGenesis: fmt.Sprintf("/foo/%s/genesis/bin/myd", rootName),
|
|
expectUpgrade: fmt.Sprintf("/foo/%s/upgrades/bar/bin/myd", rootName),
|
|
},
|
|
"handle space": {
|
|
cfg: Config{Home: "/longer/prefix/", Name: "yourd"},
|
|
upgradeName: "some spaces",
|
|
expectRoot: fmt.Sprintf("/longer/prefix/%s", rootName),
|
|
expectGenesis: fmt.Sprintf("/longer/prefix/%s/genesis/bin/yourd", rootName),
|
|
expectUpgrade: "/longer/prefix/cosmovisor/upgrades/some%20spaces/bin/yourd",
|
|
},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
s.Require().Equal(tc.cfg.Root(), filepath.FromSlash(tc.expectRoot))
|
|
s.Require().Equal(tc.cfg.GenesisBin(), filepath.FromSlash(tc.expectGenesis))
|
|
s.Require().Equal(tc.cfg.UpgradeBin(tc.upgradeName), filepath.FromSlash(tc.expectUpgrade))
|
|
}
|
|
}
|
|
|
|
// Test validate
|
|
// add more test in test validate
|
|
func (s *argsTestSuite) TestValidate() {
|
|
relPath := filepath.Join("testdata", "validate")
|
|
absPath, err := filepath.Abs(relPath)
|
|
s.Require().NoError(err)
|
|
|
|
testdata, err := filepath.Abs("testdata")
|
|
s.Require().NoError(err)
|
|
|
|
cases := map[string]struct {
|
|
cfg Config
|
|
valid bool
|
|
}{
|
|
"happy": {
|
|
cfg: Config{Home: absPath, Name: "bind", DataBackupPath: absPath},
|
|
valid: true,
|
|
},
|
|
"happy with download": {
|
|
cfg: Config{Home: absPath, Name: "bind", AllowDownloadBinaries: true, DataBackupPath: absPath},
|
|
valid: true,
|
|
},
|
|
"happy with skip data backup": {
|
|
cfg: Config{Home: absPath, Name: "bind", UnsafeSkipBackup: true, DataBackupPath: absPath},
|
|
valid: true,
|
|
},
|
|
"happy with skip data backup and empty data backup path": {
|
|
cfg: Config{Home: absPath, Name: "bind", UnsafeSkipBackup: true, DataBackupPath: ""},
|
|
valid: true,
|
|
},
|
|
"happy with skip data backup and no such data backup path dir": {
|
|
cfg: Config{Home: absPath, Name: "bind", UnsafeSkipBackup: true, DataBackupPath: filepath.FromSlash("/no/such/dir")},
|
|
valid: true,
|
|
},
|
|
"happy with skip data backup and relative data backup path": {
|
|
cfg: Config{Home: absPath, Name: "bind", UnsafeSkipBackup: true, DataBackupPath: relPath},
|
|
valid: true,
|
|
},
|
|
"missing home": {
|
|
cfg: Config{Name: "bind"},
|
|
valid: false,
|
|
},
|
|
"missing name": {
|
|
cfg: Config{Home: absPath},
|
|
valid: false,
|
|
},
|
|
"relative home path": {
|
|
cfg: Config{Home: relPath, Name: "bind"},
|
|
valid: false,
|
|
},
|
|
"no upgrade manager subdir": {
|
|
cfg: Config{Home: testdata, Name: "bind"},
|
|
valid: false,
|
|
},
|
|
"no such home dir": {
|
|
cfg: Config{Home: filepath.FromSlash("/no/such/dir"), Name: "bind"},
|
|
valid: false,
|
|
},
|
|
"empty data backup path": {
|
|
cfg: Config{Home: absPath, Name: "bind", DataBackupPath: ""},
|
|
valid: false,
|
|
},
|
|
"no such data backup path dir": {
|
|
cfg: Config{Home: absPath, Name: "bind", DataBackupPath: filepath.FromSlash("/no/such/dir")},
|
|
valid: false,
|
|
},
|
|
"relative data backup path": {
|
|
cfg: Config{Home: absPath, Name: "bind", DataBackupPath: relPath},
|
|
valid: false,
|
|
},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
errs := tc.cfg.validate()
|
|
if tc.valid {
|
|
s.Require().Len(errs, 0)
|
|
} else {
|
|
s.Require().Greater(len(errs), 0, "number of errors returned")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *argsTestSuite) TestEnsureBin() {
|
|
relPath := filepath.Join("testdata", "validate")
|
|
absPath, err := filepath.Abs(relPath)
|
|
s.Require().NoError(err)
|
|
|
|
cfg := Config{Home: absPath, Name: "dummyd", DataBackupPath: absPath}
|
|
s.Require().Len(cfg.validate(), 0, "validation errors")
|
|
|
|
s.Require().NoError(EnsureBinary(cfg.GenesisBin()))
|
|
|
|
cases := map[string]struct {
|
|
upgrade string
|
|
hasBin bool
|
|
}{
|
|
"proper": {"chain2", true},
|
|
"no binary": {"nobin", false},
|
|
"not executable": {"noexec", false},
|
|
"no directory": {"foobarbaz", false},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
err := EnsureBinary(cfg.UpgradeBin(tc.upgrade))
|
|
if tc.hasBin {
|
|
s.Require().NoError(err)
|
|
} else {
|
|
s.Require().Error(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *argsTestSuite) TestBooleanOption() {
|
|
initialEnv := s.clearEnv()
|
|
defer s.setEnv(nil, initialEnv)
|
|
|
|
name := "COSMOVISOR_TEST_VAL"
|
|
|
|
check := func(def, expected, isErr bool, msg string) {
|
|
v, err := booleanOption(name, def)
|
|
if isErr {
|
|
s.Require().Error(err)
|
|
return
|
|
}
|
|
s.Require().NoError(err)
|
|
s.Require().Equal(expected, v, msg)
|
|
}
|
|
|
|
os.Setenv(name, "")
|
|
check(true, true, false, "should correctly set default value")
|
|
check(false, false, false, "should correctly set default value")
|
|
|
|
os.Setenv(name, "wrong")
|
|
check(true, true, true, "should error on wrong value")
|
|
os.Setenv(name, "truee")
|
|
check(true, true, true, "should error on wrong value")
|
|
|
|
os.Setenv(name, "false")
|
|
check(true, false, false, "should handle false value")
|
|
check(false, false, false, "should handle false value")
|
|
os.Setenv(name, "faLSe")
|
|
check(true, false, false, "should handle false value case not sensitive")
|
|
check(false, false, false, "should handle false value case not sensitive")
|
|
|
|
os.Setenv(name, "true")
|
|
check(true, true, false, "should handle true value")
|
|
check(false, true, false, "should handle true value")
|
|
|
|
os.Setenv(name, "TRUE")
|
|
check(true, true, false, "should handle true value case not sensitive")
|
|
check(false, true, false, "should handle true value case not sensitive")
|
|
}
|
|
|
|
func (s *argsTestSuite) TestDetailString() {
|
|
home := "/home"
|
|
name := "test-name"
|
|
allowDownloadBinaries := true
|
|
restartAfterUpgrade := true
|
|
pollInterval := 406 * time.Millisecond
|
|
unsafeSkipBackup := false
|
|
dataBackupPath := "/home"
|
|
preupgradeMaxRetries := 8
|
|
cfg := &Config{
|
|
Home: home,
|
|
Name: name,
|
|
AllowDownloadBinaries: allowDownloadBinaries,
|
|
RestartAfterUpgrade: restartAfterUpgrade,
|
|
PollInterval: pollInterval,
|
|
UnsafeSkipBackup: unsafeSkipBackup,
|
|
DataBackupPath: dataBackupPath,
|
|
PreupgradeMaxRetries: preupgradeMaxRetries,
|
|
}
|
|
|
|
expectedPieces := []string{
|
|
"Configurable Values:",
|
|
fmt.Sprintf("%s: %s", EnvHome, home),
|
|
fmt.Sprintf("%s: %s", EnvName, name),
|
|
fmt.Sprintf("%s: %t", EnvDownloadBin, allowDownloadBinaries),
|
|
fmt.Sprintf("%s: %t", EnvRestartUpgrade, restartAfterUpgrade),
|
|
fmt.Sprintf("%s: %s", EnvInterval, pollInterval),
|
|
fmt.Sprintf("%s: %t", EnvSkipBackup, unsafeSkipBackup),
|
|
fmt.Sprintf("%s: %s", EnvDataBackupPath, home),
|
|
fmt.Sprintf("%s: %d", EnvPreupgradeMaxRetries, preupgradeMaxRetries),
|
|
"Derived Values:",
|
|
fmt.Sprintf("Root Dir: %s", home),
|
|
fmt.Sprintf("Upgrade Dir: %s", home),
|
|
fmt.Sprintf("Genesis Bin: %s", home),
|
|
fmt.Sprintf("Monitored File: %s", home),
|
|
fmt.Sprintf("Data Backup Dir: %s", home),
|
|
}
|
|
|
|
actual := cfg.DetailString()
|
|
|
|
for _, piece := range expectedPieces {
|
|
s.Assert().Contains(actual, piece)
|
|
}
|
|
}
|
|
|
|
func (s *argsTestSuite) TestGetConfigFromEnv() {
|
|
initialEnv := s.clearEnv()
|
|
defer s.setEnv(nil, initialEnv)
|
|
|
|
relPath := filepath.Join("testdata", "validate")
|
|
absPath, perr := filepath.Abs(relPath)
|
|
s.Require().NoError(perr)
|
|
|
|
newConfig := func(home, name, dataBackupPath string, downloadBin, restartUpgrade, skipBackup bool, interval, preupgradeMaxRetries int) *Config {
|
|
return &Config{
|
|
Home: home,
|
|
Name: name,
|
|
AllowDownloadBinaries: downloadBin,
|
|
RestartAfterUpgrade: restartUpgrade,
|
|
PollInterval: time.Millisecond * time.Duration(interval),
|
|
UnsafeSkipBackup: skipBackup,
|
|
DataBackupPath: dataBackupPath,
|
|
PreupgradeMaxRetries: preupgradeMaxRetries,
|
|
}
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
envVals cosmovisorEnv
|
|
expectedCfg *Config
|
|
expectedErrCount int
|
|
}{
|
|
// EnvHome, EnvName, EnvDownloadBin, EnvRestartUpgrade, EnvSkipBackup, EnvDataBackupPath, EnvDataBackupPath, EnvInterval, EnvPreupgradeMaxRetries
|
|
{
|
|
name: "all bad",
|
|
envVals: cosmovisorEnv{"", "", "bad", "bad", "bad", "", "bad", "bad"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 8,
|
|
},
|
|
{
|
|
name: "all good",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, false, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "nothing set",
|
|
envVals: cosmovisorEnv{"", "", "", "", "", "", "", ""},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 3,
|
|
},
|
|
// Note: Home and Name tests are done in TestValidate
|
|
{
|
|
name: "download bin bad",
|
|
envVals: cosmovisorEnv{absPath, "testname", "bad", "false", "true", "", "303", "1"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
{
|
|
name: "download bin not set",
|
|
envVals: cosmovisorEnv{absPath, "testname", "", "false", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "download bin true",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, false, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "download bin false",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
// EnvHome, EnvName, EnvDownloadBin, EnvRestartUpgrade, EnvSkipBackup, EnvDataBackupPath, EnvInterval, EnvPreupgradeMaxRetries
|
|
{
|
|
name: "restart upgrade bad",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "bad", "true", "", "303", "1"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
{
|
|
name: "restart upgrade not set",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, true, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "restart upgrade true",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "true", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, true, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "restart upgrade true",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, false, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
// EnvHome, EnvName, EnvDownloadBin, EnvRestartUpgrade, EnvSkipBackup, EnvDataBackupPath, EnvInterval, EnvPreupgradeMaxRetries
|
|
{
|
|
name: "skip unsafe backups bad",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "bad", "", "303", "1"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
{
|
|
name: "skip unsafe backups not set",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, false, false, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "skip unsafe backups true",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "true", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, false, true, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "skip unsafe backups false",
|
|
envVals: cosmovisorEnv{absPath, "testname", "true", "false", "false", "", "303", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, true, false, false, 303, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
// EnvHome, EnvName, EnvDownloadBin, EnvRestartUpgrade, EnvSkipBackup, EnvDataBackupPath, EnvInterval, EnvPreupgradeMaxRetries
|
|
{
|
|
name: "poll interval bad",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "bad", "1"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
{
|
|
name: "poll interval 0",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "0", "1"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
{
|
|
name: "poll interval not set",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, false, 300, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "poll interval 987",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "987", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, false, 987, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "poll interval 1s",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "1s", "1"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, false, 1000, 1),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "poll interval -3m",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "-3m", "1"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
// EnvHome, EnvName, EnvDownloadBin, EnvRestartUpgrade, EnvSkipBackup, EnvDataBackupPath, EnvInterval, EnvPreupgradeMaxRetries
|
|
{
|
|
name: "prepupgrade max retries bad",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "406", "bad"},
|
|
expectedCfg: nil,
|
|
expectedErrCount: 1,
|
|
},
|
|
{
|
|
name: "prepupgrade max retries 0",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "406", "0"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, false, 406, 0),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "prepupgrade max retries not set",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "406", ""},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, false, 406, 0),
|
|
expectedErrCount: 0,
|
|
},
|
|
{
|
|
name: "prepupgrade max retries 5",
|
|
envVals: cosmovisorEnv{absPath, "testname", "false", "false", "false", "", "406", "5"},
|
|
expectedCfg: newConfig(absPath, "testname", absPath, false, false, false, 406, 5),
|
|
expectedErrCount: 0,
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
s.T().Run(tc.name, func(t *testing.T) {
|
|
s.setEnv(t, &tc.envVals)
|
|
cfg, err := GetConfigFromEnv()
|
|
if tc.expectedErrCount == 0 {
|
|
assert.NoError(t, err)
|
|
} else {
|
|
if assert.Error(t, err) {
|
|
errCount := 1
|
|
if multi, isMulti := err.(*errors.MultiError); isMulti {
|
|
errCount = multi.Len()
|
|
}
|
|
assert.Equal(t, tc.expectedErrCount, errCount, "error count")
|
|
}
|
|
}
|
|
assert.Equal(t, tc.expectedCfg, cfg, "config")
|
|
})
|
|
}
|
|
}
|
|
|
|
func (s *argsTestSuite) TestLogConfigOrError() {
|
|
cfg := &Config{
|
|
Home: "/no/place/like/it",
|
|
Name: "cosmotestvisor",
|
|
AllowDownloadBinaries: true,
|
|
RestartAfterUpgrade: true,
|
|
PollInterval: 999,
|
|
UnsafeSkipBackup: false,
|
|
DataBackupPath: "/no/place/like/it",
|
|
PreupgradeMaxRetries: 20,
|
|
}
|
|
errNormal := fmt.Errorf("this is a single error")
|
|
errs := []error{
|
|
fmt.Errorf("multi-error error 1"),
|
|
fmt.Errorf("multi-error error 2"),
|
|
fmt.Errorf("multi-error error 3"),
|
|
}
|
|
errMulti := errors.FlattenErrors(errs...)
|
|
|
|
makeTestLogger := func(testName string, out io.Writer) zerolog.Logger {
|
|
output := zerolog.ConsoleWriter{Out: out, TimeFormat: time.Kitchen, NoColor: true}
|
|
return zerolog.New(output).With().Str("test", testName).Timestamp().Logger()
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
cfg *Config
|
|
err error
|
|
contains []string
|
|
notcontains []string
|
|
}{
|
|
{
|
|
name: "normal error",
|
|
cfg: nil,
|
|
err: errNormal,
|
|
contains: []string{"configuration error", errNormal.Error()}, // TODO: Fix this.
|
|
notcontains: nil,
|
|
},
|
|
{
|
|
name: "multi error",
|
|
cfg: nil,
|
|
err: errMulti,
|
|
contains: []string{"configuration errors found", errs[0].Error(), errs[1].Error(), errs[2].Error()},
|
|
notcontains: nil,
|
|
},
|
|
{
|
|
name: "config",
|
|
cfg: cfg,
|
|
err: nil,
|
|
contains: []string{"Configurable Values", cfg.DetailString()},
|
|
notcontains: nil,
|
|
},
|
|
{
|
|
name: "error and config - no config details",
|
|
cfg: cfg,
|
|
err: errNormal,
|
|
contains: []string{"error"},
|
|
notcontains: []string{"Configuration is valid", EnvName, cfg.Home}, // Just some spot checks.
|
|
},
|
|
{
|
|
name: "nil nil - no output",
|
|
cfg: nil,
|
|
err: nil,
|
|
contains: nil,
|
|
notcontains: []string{" "},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
s.T().Run(tc.name, func(t *testing.T) {
|
|
var b bytes.Buffer
|
|
logger := makeTestLogger(tc.name, &b)
|
|
LogConfigOrError(logger, tc.cfg, tc.err)
|
|
output := b.String()
|
|
for _, expected := range tc.contains {
|
|
assert.Contains(t, output, expected)
|
|
}
|
|
for _, unexpected := range tc.notcontains {
|
|
assert.NotContains(t, output, unexpected)
|
|
}
|
|
})
|
|
}
|
|
}
|