Fix: Embolden main package test, improve default config warning

cmd/HellPot/HellPot.go

@@ -2,51 +2,23 @@ package main
 
 import (
 	"os"
-	"strconv"
 
-	"github.com/yunginnanet/HellPot/internal/config"
 	"github.com/yunginnanet/HellPot/internal/http"
-	"github.com/yunginnanet/HellPot/internal/version"
-)
-
-var (
-	runningConfig *config.Parameters
 )
 
 func main() {
 	stopChan := make(chan os.Signal, 1)
-	log, _, resolvedConf, err := setup(stopChan)
+	log, _, resolvedConf, realConf, err := setup(stopChan)
 
 	if err != nil {
 		println("failed to start: " + err.Error())
 		os.Exit(1)
 	}
 
-	log.Info().Msg("🔥 Starting HellPot 🔥")
-	log.Info().Msg("Version: " + version.Version)
-	log.Info().Msg("PID: " + strconv.Itoa(os.Getpid()))
-	log.Info().Msg("Using config file: " + resolvedConf)
-	if runningConfig.UsingDefaults {
-		log.Warn().Msg("Using default configuration")
-	}
-	if runningConfig.Logger.RSyslog != "" {
-		log.Info().Msg("Logging to syslog: " + runningConfig.Logger.RSyslog)
-	}
-	if runningConfig.Logger.ActiveLogFileName != "" {
-		log.Info().Msg("Logging to file: " + runningConfig.Logger.ActiveLogFileName)
-	}
-	if runningConfig.Logger.DockerLogging &&
-		runningConfig.Logger.File == "" &&
-		runningConfig.Logger.Directory == "" &&
-		runningConfig.Logger.RSyslog == "" {
-		log.Info().Msg("Only logging to standard output")
-	}
-
-	log.Debug().Msg("Debug logging enabled")
-	log.Trace().Msg("Trace logging enabled")
+	printInfo(log, resolvedConf, realConf)
 
 	go func() {
-		log.Fatal().Err(http.Serve(runningConfig)).Msg("HTTP error")
+		log.Fatal().Err(http.Serve(realConf)).Msg("HTTP error")
 	}()
 
 	sig := <-stopChan // wait for SIGINT

cmd/HellPot/HellPot_test.go

@@ -3,40 +3,45 @@ package main
 import (
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
 	"testing"
 	"time"
 
+	"github.com/yunginnanet/HellPot/internal/config"
 	"github.com/yunginnanet/HellPot/internal/http"
 )
 
-func testMain(t *testing.T) (string, string, chan os.Signal, error) {
+func testMain(t *testing.T) (string, string, chan os.Signal, *config.Parameters, error) {
+	t.Helper()
 	stopChan := make(chan os.Signal, 1)
 
-	log, logFile, resolvedConf, err := setup(stopChan)
+	log, logFile, resolvedConf, realConfig, err := setup(stopChan)
 	if err == nil {
-		log.Info().Msg("🔥 Starting HellPot 🔥")
+		printInfo(log, resolvedConf, realConfig)
 		go func() {
-			terr := http.Serve(runningConfig)
+			terr := http.Serve(realConfig)
 			if terr != nil {
 				t.Error("failed to serve HTTP: " + terr.Error())
 				close(stopChan)
 			}
 		}()
 	}
 	//goland:noinspection GoNilness
-	return resolvedConf, logFile, stopChan, err
+	return resolvedConf, logFile, stopChan, realConfig, err
 }
 
 func TestHellPot(t *testing.T) {
-	logDir := filepath.Join(t.TempDir(), "logs")
+	tDir := filepath.Join(t.TempDir(), strconv.Itoa(int(time.Now().Unix())))
+	logDir := filepath.Join(tDir, "logs")
 	if err := os.MkdirAll(logDir, 0755); err != nil {
 		t.Fatal(err)
 	}
-	confFile := filepath.Join(t.TempDir(), "HellPot_test.toml")
+	confFile := filepath.Join(tDir, "HellPot_test.toml")
 	t.Setenv("HELLPOT_LOGGER_DIRECTORY", logDir)
 	t.Setenv("HELLPOT_CONFIG", confFile)
 
-	resolvedConf, logFile, stopChan, err := testMain(t)
+	resolvedConf, logFile, stopChan, realConfig, err := testMain(t)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -58,8 +63,26 @@ func TestHellPot(t *testing.T) {
 	if logFile != filepath.Join(logDir, "HellPot.log") {
 		t.Errorf("expected %s, got %s", filepath.Join(logDir, "HellPot.log"), logFile)
 	}
+	time.Sleep(25 * time.Millisecond) // sync maybe
+	logDat, err := os.ReadFile(logFile)
+	if err != nil {
+		t.Error(err)
+	}
+	if !strings.Contains(string(logDat), "🔥 Starting HellPot 🔥") {
+		t.Errorf("expected log to contain '🔥 Starting HellPot 🔥', got %s", logDat)
+	}
+	if !strings.Contains(string(logDat), logFile) {
+		t.Errorf("expected log to contain '%s'", logFile)
+	}
+	if !strings.Contains(string(logDat), resolvedConf) {
+		t.Errorf("expected log to contain '%s'", resolvedConf)
+	}
+	if !strings.Contains(string(logDat), "PID: "+strconv.Itoa(os.Getpid())) {
+		t.Errorf("expected log to contain 'PID: %d', got %s", os.Getpid(), logDat)
+	}
 	t.Log("resolvedConf: ", resolvedConf)
 	t.Log("logFile: ", logFile)
+	t.Log("realConfig: ", realConfig)
 	time.Sleep(100 * time.Millisecond)
 	stopChan <- os.Interrupt
 }

cmd/HellPot/boot.go

@@ -19,6 +19,12 @@ import (
 	"github.com/yunginnanet/HellPot/internal/logger"
 )
 
+const (
+	defaultConfigWarningDelaySecs = 10
+	red                           = "\033[31m"
+	reset                         = "\033[0m"
+)
+
 func writeConfig(target string) (*config.Parameters, bool) {
 	var f *os.File
 	var err error
@@ -37,13 +43,13 @@ func writeConfig(target string) (*config.Parameters, bool) {
 	}
 	println("wrote default config to " + target)
 	var newConf *config.Parameters
-	newConf, err = config.Setup(f)
-	if err != nil {
+	if newConf, err = config.Setup(f); err != nil {
 		println("failed to setup config with newly written file: " + err.Error())
 		_ = f.Close()
 		return nil, false
 	}
 	_ = f.Close()
+	newConf.UsingDefaults = true
 	return newConf, true
 }
 
@@ -68,42 +74,45 @@ func searchConfig() string {
 	return resolvedConf
 }
 
-func readConfig(resolvedConf string) error {
+func readConfig(resolvedConf string) (*config.Parameters, error) {
 	var err error
 	var setupErr error
 	var f *os.File
 
 	if resolvedConf == "" {
-		return fmt.Errorf("%w: provided config file is an empty string", io.EOF)
+		return nil, fmt.Errorf("%w: provided config file is an empty string", io.EOF)
 	}
 
+	var runningConfig *config.Parameters
+
 	f, err = os.Open(resolvedConf) // #nosec G304 go home gosec, you're drunk
 	if err == nil {
 		runningConfig, setupErr = config.Setup(f)
 	}
 	switch {
 	case setupErr != nil:
 		println("failed to setup config: " + setupErr.Error())
-		_ = f.Close()
+		if f != nil {
+			_ = f.Close()
+		}
 		err = setupErr
 	case err != nil:
 		println("failed to open config file for reading: " + err.Error())
 		println("trying to create it....")
 		newRunningConfig, wroteOK := writeConfig(resolvedConf)
 		if wroteOK {
-			runningConfig = newRunningConfig
-			return nil
+			return newRunningConfig, nil
 		}
 		println("failed to create config file, cannot continue")
-		return fmt.Errorf("failed to create config file: %w", err)
+		return nil, fmt.Errorf("failed to create config file: %w", err)
 	case runningConfig != nil:
 		_ = f.Close()
 	}
 
-	return err
+	return runningConfig, err
 }
 
-func resolveConfig() (usingDefaults bool, resolvedConf string, err error) {
+func resolveConfig() (runningConfig *config.Parameters, usingDefaults bool, resolvedConf string, err error) {
 	setIfPresent := func(confRoot *flag.Flag) (ok bool) {
 		if confRoot != nil && confRoot.Value.String() != "" {
 			resolvedConf = confRoot.Value.String()
@@ -127,28 +136,32 @@ func resolveConfig() (usingDefaults bool, resolvedConf string, err error) {
 		resolvedConf = searchConfig()
 	}
 
-	if err = readConfig(resolvedConf); err != nil && !errors.Is(err, io.EOF) {
-		return false, "", err
+	if runningConfig, err = readConfig(resolvedConf); err != nil && !errors.Is(err, io.EOF) {
+		return runningConfig, false, "", err
 	}
 
 	if runningConfig == nil {
 		if runningConfig, err = config.Setup(nil); err != nil || runningConfig == nil {
 			if err == nil {
 				err = errors.New("unknown failure resulting in missing configuration, cannot continue")
 			}
-			return false, "", err
+			return runningConfig, false, "", err
 		}
-		return true, "", nil
+		return runningConfig, true, "", nil
 	}
 
-	return false, resolvedConf, nil
+	return runningConfig, false, resolvedConf, nil
 }
 
-func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string, resolvedConf string, err error) {
+func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string,
+	resolvedConf string, realConf *config.Parameters, err error) {
+
 	config.InitCLI()
+
 	var usingDefaults bool
+	var runningConfig *config.Parameters
 
-	if usingDefaults, resolvedConf, err = resolveConfig(); err != nil {
+	if runningConfig, usingDefaults, resolvedConf, err = resolveConfig(); err != nil {
 		return
 	}
 
@@ -157,6 +170,15 @@ func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string, resolve
 		return
 	}
 
+	// TODO: jesus bro r u ok
+	realConf = runningConfig
+	if usingDefaults && !realConf.UsingDefaults {
+		realConf.UsingDefaults = true
+	}
+	if realConf.UsingDefaults && !usingDefaults {
+		usingDefaults = true
+	}
+
 	//goland:noinspection GoNilness // we check for nil above
 	if log, err = logger.New(runningConfig.Logger); err != nil {
 		return
@@ -165,15 +187,16 @@ func setup(stopChan chan os.Signal) (log zerolog.Logger, logFile string, resolve
 	logFile = runningConfig.Logger.ActiveLogFileName
 
 	if usingDefaults {
-		runningConfig.UsingDefaults = true
-		log.Warn().Msg("continuing with default configuration in ")
-		for i := 5; i > 0; i-- {
+		log.Warn().Msg("using default configuration!")
+		print(red + "continuing with default configuration in ")
+		for i := defaultConfigWarningDelaySecs; i > 0; i-- {
 			print(strconv.Itoa(i))
 			for i := 0; i < 5; i++ {
 				time.Sleep(200 * time.Millisecond)
 				print(".")
 			}
 		}
+		print(reset + "\n")
 	}
 
 	if //goland:noinspection GoNilness

internal/config/setup.go

@@ -60,6 +60,10 @@ func Setup(source io.Reader) (*Parameters, error) {
 		source: k,
 	}
 
+	if source == nil {
+		p.UsingDefaults = true
+	}
+
 	if err := k.Unmarshal("", p); err != nil {
 		return nil, fmt.Errorf("failed to unmarshal config: %w", err)
 	}