343 lines
8.9 KiB
Go
343 lines
8.9 KiB
Go
package logger
|
|
|
|
import (
|
|
"os"
|
|
"testing"
|
|
)
|
|
|
|
// setupTestEnvironment setzt ENVIRONMENT=test für Tests
|
|
func setupTestEnvironment(t *testing.T) {
|
|
original := os.Getenv("ENVIRONMENT")
|
|
os.Setenv("ENVIRONMENT", "test")
|
|
t.Cleanup(func() {
|
|
if original != "" {
|
|
os.Setenv("ENVIRONMENT", original)
|
|
} else {
|
|
os.Unsetenv("ENVIRONMENT")
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestLogLevels(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
// Test String-Representation der Log-Levels
|
|
tests := []struct {
|
|
level LogLevel
|
|
expected string
|
|
}{
|
|
{DEBUG, "DEBUG"},
|
|
{INFO, "INFO"},
|
|
{WARN, "WARN"},
|
|
{ERROR, "ERROR"},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
if test.level.String() != test.expected {
|
|
t.Errorf("Expected %s, got %s", test.expected, test.level.String())
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDebugModeFromEnv(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test verschiedene Umgebungsvariablen-Werte
|
|
tests := []struct {
|
|
envValue string
|
|
expected bool
|
|
}{
|
|
{"true", true},
|
|
{"TRUE", true},
|
|
{"True", true},
|
|
{"1", true},
|
|
{"false", false},
|
|
{"FALSE", false},
|
|
{"False", false},
|
|
{"0", false},
|
|
{"", false},
|
|
{"invalid", false},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
os.Setenv("DEBUG", test.envValue)
|
|
result := getDebugModeFromEnv()
|
|
if result != test.expected {
|
|
t.Errorf("For DEBUG=%s, expected %v, got %v", test.envValue, test.expected, result)
|
|
}
|
|
}
|
|
|
|
// Cleanup
|
|
os.Unsetenv("DEBUG")
|
|
}
|
|
|
|
func TestMinLogLevelFromEnv(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test verschiedene LOG_LEVEL Werte
|
|
tests := []struct {
|
|
envValue string
|
|
expected LogLevel
|
|
}{
|
|
{"DEBUG", DEBUG},
|
|
{"debug", DEBUG},
|
|
{"INFO", INFO},
|
|
{"info", INFO},
|
|
{"WARN", WARN},
|
|
{"warn", WARN},
|
|
{"ERROR", ERROR},
|
|
{"error", ERROR},
|
|
{"invalid", INFO}, // Default zu INFO
|
|
{"", INFO}, // Default zu INFO
|
|
}
|
|
|
|
// DEBUG-Modus deaktivieren für diese Tests
|
|
os.Setenv("DEBUG", "false")
|
|
|
|
for _, test := range tests {
|
|
os.Setenv("LOG_LEVEL", test.envValue)
|
|
result := getMinLogLevelFromEnv()
|
|
if result != test.expected {
|
|
t.Errorf("For LOG_LEVEL=%s, expected %v, got %v", test.envValue, test.expected, result)
|
|
}
|
|
}
|
|
|
|
// Test: Wenn DEBUG=true und kein LOG_LEVEL gesetzt, sollte DEBUG returned werden
|
|
os.Setenv("DEBUG", "true")
|
|
os.Unsetenv("LOG_LEVEL")
|
|
result := getMinLogLevelFromEnv()
|
|
if result != DEBUG {
|
|
t.Errorf("When DEBUG=true and no LOG_LEVEL set, expected DEBUG, got %v", result)
|
|
}
|
|
|
|
// Cleanup
|
|
os.Unsetenv("DEBUG")
|
|
os.Unsetenv("LOG_LEVEL")
|
|
}
|
|
|
|
func TestSetDebugMode(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test Debug-Modus aktivieren
|
|
SetDebugMode(true)
|
|
if !IsDebugEnabled() {
|
|
t.Error("Debug mode should be enabled")
|
|
}
|
|
|
|
// Test Debug-Modus deaktivieren
|
|
SetDebugMode(false)
|
|
if IsDebugEnabled() {
|
|
t.Error("Debug mode should be disabled")
|
|
}
|
|
}
|
|
|
|
func TestSetMinLogLevel(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test verschiedene Log-Level setzen
|
|
levels := []LogLevel{DEBUG, INFO, WARN, ERROR}
|
|
|
|
for _, level := range levels {
|
|
SetMinLogLevel(level)
|
|
if defaultLogger.minLevel != level {
|
|
t.Errorf("Expected min log level %v, got %v", level, defaultLogger.minLevel)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLoggingFunctions(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Capture output for testing
|
|
// Since logger writes to os.Stdout, we need to capture that output
|
|
// For simplicity, we'll test that the functions don't panic and work with different log levels
|
|
|
|
tests := []struct {
|
|
name string
|
|
logFunc func(string, ...interface{})
|
|
level LogLevel
|
|
message string
|
|
args []interface{}
|
|
enabled bool
|
|
}{
|
|
{"Debug", Debug, DEBUG, "Debug message: %s", []interface{}{"test"}, true},
|
|
{"Info", Info, INFO, "Info message: %s", []interface{}{"test"}, true},
|
|
{"Warn", Warn, WARN, "Warn message: %s", []interface{}{"test"}, true},
|
|
{"Error", Error, ERROR, "Error message: %s", []interface{}{"test"}, true},
|
|
{"Debugf", Debugf, DEBUG, "Debugf message: %s", []interface{}{"test"}, true},
|
|
{"Infof", Infof, INFO, "Infof message: %s", []interface{}{"test"}, true},
|
|
{"Warnf", Warnf, WARN, "Warnf message: %s", []interface{}{"test"}, true},
|
|
{"Errorf", Errorf, ERROR, "Errorf message: %s", []interface{}{"test"}, true},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
// Set appropriate log level and debug mode
|
|
SetDebugMode(true)
|
|
SetMinLogLevel(DEBUG)
|
|
|
|
// Test that the function doesn't panic
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("%s function panicked: %v", test.name, r)
|
|
}
|
|
}()
|
|
|
|
// Call the logging function
|
|
test.logFunc(test.message, test.args...)
|
|
|
|
// The test passes if no panic occurred
|
|
// In a more sophisticated test, we could capture stdout and verify the output format
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoggingWithDifferentLevels(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test that messages are filtered based on log level
|
|
tests := []struct {
|
|
minLevel LogLevel
|
|
debugMode bool
|
|
description string
|
|
}{
|
|
{ERROR, false, "ERROR level - only errors should log"},
|
|
{WARN, false, "WARN level - warnings and errors should log"},
|
|
{INFO, false, "INFO level - info, warnings and errors should log"},
|
|
{DEBUG, true, "DEBUG level with debug mode - all should log"},
|
|
{DEBUG, false, "DEBUG level without debug mode - debug should not log"},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.description, func(t *testing.T) {
|
|
// Configure logger
|
|
SetDebugMode(test.debugMode)
|
|
SetMinLogLevel(test.minLevel)
|
|
|
|
// Test that functions don't panic with this configuration
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("Logging function panicked with %s: %v", test.description, r)
|
|
}
|
|
}()
|
|
|
|
// Call all logging functions
|
|
Debug("Debug message")
|
|
Info("Info message")
|
|
Warn("Warn message")
|
|
Error("Error message")
|
|
Debugf("Debug message %s", "formatted")
|
|
Infof("Info message %s", "formatted")
|
|
Warnf("Warn message %s", "formatted")
|
|
Errorf("Error message %s", "formatted")
|
|
|
|
// Test passes if no panics occurred
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoggingWithNoArgs(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test logging functions with no format arguments
|
|
SetDebugMode(true)
|
|
SetMinLogLevel(DEBUG)
|
|
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("Logging function panicked with no args: %v", r)
|
|
}
|
|
}()
|
|
|
|
// Test all functions with simple messages (no format placeholders)
|
|
Debug("Simple debug message")
|
|
Info("Simple info message")
|
|
Warn("Simple warn message")
|
|
Error("Simple error message")
|
|
Debugf("Simple debugf message")
|
|
Infof("Simple infof message")
|
|
Warnf("Simple warnf message")
|
|
Errorf("Simple errorf message")
|
|
}
|
|
|
|
func TestLoggingWithMultipleArgs(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test logging functions with multiple format arguments
|
|
SetDebugMode(true)
|
|
SetMinLogLevel(DEBUG)
|
|
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("Logging function panicked with multiple args: %v", r)
|
|
}
|
|
}()
|
|
|
|
// Test all functions with multiple format arguments
|
|
Debug("Debug: %s %d %v", "test", 42, true)
|
|
Info("Info: %s %d %v", "test", 42, true)
|
|
Warn("Warn: %s %d %v", "test", 42, true)
|
|
Error("Error: %s %d %v", "test", 42, true)
|
|
Debugf("Debugf: %s %d %v", "test", 42, true)
|
|
Infof("Infof: %s %d %v", "test", 42, true)
|
|
Warnf("Warnf: %s %d %v", "test", 42, true)
|
|
Errorf("Errorf: %s %d %v", "test", 42, true)
|
|
}
|
|
|
|
func TestDebugModeFiltering(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test that Debug messages are actually filtered when debug mode is disabled
|
|
SetMinLogLevel(DEBUG) // Allow debug level
|
|
SetDebugMode(false) // But disable debug mode
|
|
|
|
// Verify IsDebugEnabled returns false
|
|
if IsDebugEnabled() {
|
|
t.Error("IsDebugEnabled should return false when debug mode is disabled")
|
|
}
|
|
|
|
// Test that debug functions don't panic even when filtered
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("Debug function panicked when filtered: %v", r)
|
|
}
|
|
}()
|
|
|
|
Debug("This debug message should be filtered")
|
|
Debugf("This debug message %s should be filtered", "also")
|
|
|
|
// Now enable debug mode and verify IsDebugEnabled returns true
|
|
SetDebugMode(true)
|
|
if !IsDebugEnabled() {
|
|
t.Error("IsDebugEnabled should return true when debug mode is enabled and level is DEBUG")
|
|
}
|
|
|
|
// These should not panic
|
|
Debug("This debug message should now log")
|
|
Debugf("This debug message %s should now log", "also")
|
|
}
|
|
|
|
func TestLogLevelFiltering(t *testing.T) {
|
|
setupTestEnvironment(t)
|
|
|
|
// Test that messages below the minimum level are filtered
|
|
SetDebugMode(false) // Disable debug mode for this test
|
|
SetMinLogLevel(WARN) // Only warnings and errors should log
|
|
|
|
// These should not panic even though they're filtered
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
t.Errorf("Logging function panicked when filtered: %v", r)
|
|
}
|
|
}()
|
|
|
|
Debug("This should be filtered") // Below WARN level
|
|
Info("This should be filtered") // Below WARN level
|
|
Warn("This should log") // At WARN level
|
|
Error("This should log") // Above WARN level
|
|
|
|
Debugf("This should be filtered") // Below WARN level
|
|
Infof("This should be filtered") // Below WARN level
|
|
Warnf("This should log") // At WARN level
|
|
Errorf("This should log") // Above WARN level
|
|
}
|