conf: add unit tests (#5954)

* conf: add tests for utils.go

* conf: add tests for static.go

* mock os/exec

* Run tests on Windows

* appveyor: fix gcc not found

* computed: add unit tests

* log: add unit tests

* log: fix tests on Windows

* conf: add some tests

* Finish adding tests

* Cover more cases

* Add tests for testutil

* Add more tests

1 files changed, 79 insertions, 43 deletions

diff --git a/internal/conf/log.go b/internal/conf/log.go
index fdb1d64e..3087c7c8 100644
--- a/internal/conf/log.go
+++ b/internal/conf/log.go
@@ -9,28 +9,39 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/pkg/errors"
+	"gopkg.in/ini.v1"
 	log "unknwon.dev/clog/v2"
 )
 
-// Log settings
-var Log struct {
+type loggerConf struct {
+	Buffer int64
+	Config interface{}
+}
+
+type logConf struct {
 	RootPath string
 	Modes    []string
-	Configs  []interface{}
+	Configs  []*loggerConf
 }
 
-// InitLogging initializes the logging service of the application.
-func InitLogging() {
-	Log.RootPath = File.Section("log").Key("ROOT_PATH").MustString(filepath.Join(WorkDir(), "log"))
-
-	// Because we always create a console logger as the primary logger at init time,
-	// we need to remove it in case the user doesn't configure to use it after the
-	// logging service is initalized.
-	hasConsole := false
+// Log settings
+var Log *logConf
+
+// initLogConf returns parsed logging configuration from given INI file.
+// NOTE: Because we always create a console logger as the primary logger at init time,
+// we need to remove it in case the user doesn't configure to use it after the logging
+// service is initalized.
+func initLogConf(cfg *ini.File) (_ *logConf, hasConsole bool, _ error) {
+	rootPath := cfg.Section("log").Key("ROOT_PATH").MustString(filepath.Join(WorkDir(), "log"))
+	modes := strings.Split(cfg.Section("log").Key("MODE").MustString("console"), ",")
+	lc := &logConf{
+		RootPath: ensureAbs(rootPath),
+		Modes:    make([]string, 0, len(modes)),
+		Configs:  make([]*loggerConf, 0, len(modes)),
+	}
 
 	// Iterate over [log.*] sections to initialize individual logger.
-	Log.Modes = strings.Split(File.Section("log").Key("MODE").MustString("console"), ",")
-	Log.Configs = make([]interface{}, 0, len(Log.Modes))
 	levelMappings := map[string]log.Level{
 		"trace": log.LevelTrace,
 		"info":  log.LevelInfo,
@@ -39,43 +50,30 @@ func InitLogging() {
 		"fatal": log.LevelFatal,
 	}
 
-	type config struct {
-		Buffer int64
-		Config interface{}
-	}
-	for _, mode := range Log.Modes {
-		mode = strings.ToLower(strings.TrimSpace(mode))
-		secName := "log." + mode
-		sec, err := File.GetSection(secName)
+	for i := range modes {
+		modes[i] = strings.ToLower(strings.TrimSpace(modes[i]))
+		secName := "log." + modes[i]
+		sec, err := cfg.GetSection(secName)
 		if err != nil {
-			log.Fatal("Missing configuration section [%s] for %q logger", secName, mode)
-			return
+			return nil, hasConsole, errors.Errorf("missing configuration section [%s] for %q logger", secName, modes[i])
 		}
 
 		level := levelMappings[strings.ToLower(sec.Key("LEVEL").MustString("trace"))]
 		buffer := sec.Key("BUFFER_LEN").MustInt64(100)
-		var c *config
-		switch mode {
+		var c *loggerConf
+		switch modes[i] {
 		case log.DefaultConsoleName:
 			hasConsole = true
-			c = &config{
+			c = &loggerConf{
 				Buffer: buffer,
 				Config: log.ConsoleConfig{
 					Level: level,
 				},
 			}
-			err = log.NewConsole(c.Buffer, c.Config)
 
 		case log.DefaultFileName:
-			logPath := filepath.Join(Log.RootPath, "gogs.log")
-			logDir := filepath.Dir(logPath)
-			err = os.MkdirAll(logDir, os.ModePerm)
-			if err != nil {
-				log.Fatal("Failed to create log directory %q: %v", logDir, err)
-				return
-			}
-
-			c = &config{
+			logPath := filepath.Join(lc.RootPath, "gogs.log")
+			c = &loggerConf{
 				Buffer: buffer,
 				Config: log.FileConfig{
 					Level:    level,
@@ -89,20 +87,18 @@ func InitLogging() {
 					},
 				},
 			}
-			err = log.NewFile(c.Buffer, c.Config)
 
 		case log.DefaultSlackName:
-			c = &config{
+			c = &loggerConf{
 				Buffer: buffer,
 				Config: log.SlackConfig{
 					Level: level,
 					URL:   sec.Key("URL").String(),
 				},
 			}
-			err = log.NewSlack(c.Buffer, c.Config)
 
 		case log.DefaultDiscordName:
-			c = &config{
+			c = &loggerConf{
 				Buffer: buffer,
 				Config: log.DiscordConfig{
 					Level:    level,
@@ -110,22 +106,62 @@ func InitLogging() {
 					Username: sec.Key("USERNAME").String(),
 				},
 			}
-			err = log.NewDiscord(c.Buffer, c.Config)
 
 		default:
 			continue
 		}
 
+		lc.Modes = append(lc.Modes, modes[i])
+		lc.Configs = append(lc.Configs, c)
+	}
+
+	return lc, hasConsole, nil
+}
+
+// InitLogging initializes the logging service of the application.
+func InitLogging() {
+	logConf, hasConsole, err := initLogConf(File)
+	if err != nil {
+		log.Fatal("Failed to init logging configuration: %v", err)
+	}
+
+	err = os.MkdirAll(logConf.RootPath, os.ModePerm)
+	if err != nil {
+		log.Fatal("Failed to create log directory: %v", err)
+	}
+
+	for i, mode := range logConf.Modes {
+		c := logConf.Configs[i]
+
+		var err error
+		var level log.Level
+		switch mode {
+		case log.DefaultConsoleName:
+			level = c.Config.(log.ConsoleConfig).Level
+			err = log.NewConsole(c.Buffer, c.Config)
+		case log.DefaultFileName:
+			level = c.Config.(log.FileConfig).Level
+			err = log.NewFile(c.Buffer, c.Config)
+		case log.DefaultSlackName:
+			level = c.Config.(log.SlackConfig).Level
+			err = log.NewSlack(c.Buffer, c.Config)
+		case log.DefaultDiscordName:
+			level = c.Config.(log.DiscordConfig).Level
+			err = log.NewDiscord(c.Buffer, c.Config)
+		default:
+			panic("unreachable")
+		}
+
 		if err != nil {
 			log.Fatal("Failed to init %s logger: %v", mode, err)
 			return
 		}
-
-		Log.Configs = append(Log.Configs, c)
 		log.Trace("Log mode: %s (%s)", strings.Title(mode), strings.Title(strings.ToLower(level.String())))
 	}
 
 	if !hasConsole {
 		log.Remove(log.DefaultConsoleName)
 	}
+
+	Log = logConf
 }