global_test.go

package log

import (
	"testing"

	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"go.uber.org/zap/zaptest/observer"
)

// setupGlobalLoggerTest creates an observer logger and sets it as the global logger
func setupGlobalLoggerTest() (*observer.ObservedLogs, func()) {
	// Create an observer core and logs
	core, observedLogs := observer.New(zapcore.DebugLevel)

	// Replace the global logger with our observer logger
	originalLogger := zap.L()
	zap.ReplaceGlobals(zap.New(core))

	// Return the observed logs and a cleanup function
	cleanup := func() {
		zap.ReplaceGlobals(originalLogger)
	}

	return observedLogs, cleanup
}

// TestDebug tests the Debug global function
func TestDebug(t *testing.T) {
	// Setup test
	observedLogs, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Call the function being tested
	Debug("debug message", zap.String("key", "value"))

	// Verify the log entry
	logs := observedLogs.All()
	if len(logs) != 1 {
		t.Fatalf("Expected 1 log entry, got %d", len(logs))
	}

	entry := logs[0]
	if entry.Level != zapcore.DebugLevel {
		t.Errorf("Expected level DebugLevel, got %v", entry.Level)
	}
	if entry.Message != "debug message" {
		t.Errorf("Expected message 'debug message', got '%s'", entry.Message)
	}

	// Check for the field
	contextMap := entry.ContextMap()
	fieldValue, ok := contextMap["key"]
	if !ok {
		t.Error("Field 'key' not found in log entry")
	} else if fieldValue != "value" {
		t.Errorf("Expected 'key' to be 'value', got '%v'", fieldValue)
	}
}

// TestInfo tests the Info global function
func TestInfo(t *testing.T) {
	// Setup test
	observedLogs, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Call the function being tested
	Info("info message", zap.Int("count", 42))

	// Verify the log entry
	logs := observedLogs.All()
	if len(logs) != 1 {
		t.Fatalf("Expected 1 log entry, got %d", len(logs))
	}

	entry := logs[0]
	if entry.Level != zapcore.InfoLevel {
		t.Errorf("Expected level InfoLevel, got %v", entry.Level)
	}
	if entry.Message != "info message" {
		t.Errorf("Expected message 'info message', got '%s'", entry.Message)
	}

	// Check for the field
	contextMap := entry.ContextMap()
	fieldValue, ok := contextMap["count"]
	if !ok {
		t.Error("Field 'count' not found in log entry")
	} else {
		// The number could be either int64 or float64 depending on the implementation
		switch v := fieldValue.(type) {
		case float64:
			if v != float64(42) {
				t.Errorf("Expected 'count' to be 42, got '%v'", v)
			}
		case int64:
			if v != int64(42) {
				t.Errorf("Expected 'count' to be 42, got '%v'", v)
			}
		default:
			t.Errorf("Expected 'count' to be a number, got type %T", fieldValue)
		}
	}
}

// TestWarn tests the Warn global function
func TestWarn(t *testing.T) {
	// Setup test
	observedLogs, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Call the function being tested
	Warn("warn message", zap.Bool("enabled", true))

	// Verify the log entry
	logs := observedLogs.All()
	if len(logs) != 1 {
		t.Fatalf("Expected 1 log entry, got %d", len(logs))
	}

	entry := logs[0]
	if entry.Level != zapcore.WarnLevel {
		t.Errorf("Expected level WarnLevel, got %v", entry.Level)
	}
	if entry.Message != "warn message" {
		t.Errorf("Expected message 'warn message', got '%s'", entry.Message)
	}

	// Check for the field
	contextMap := entry.ContextMap()
	fieldValue, ok := contextMap["enabled"]
	if !ok {
		t.Error("Field 'enabled' not found in log entry")
	} else if fieldValue != true {
		t.Errorf("Expected 'enabled' to be true, got '%v'", fieldValue)
	}
}

// TestError tests the Error global function
func TestError(t *testing.T) {
	// Setup test
	observedLogs, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Create an error
	err := &testError{"test error"}

	// Call the function being tested
	Error("error message", zap.Error(err))

	// Verify the log entry
	logs := observedLogs.All()
	if len(logs) != 1 {
		t.Fatalf("Expected 1 log entry, got %d", len(logs))
	}

	entry := logs[0]
	if entry.Level != zapcore.ErrorLevel {
		t.Errorf("Expected level ErrorLevel, got %v", entry.Level)
	}
	if entry.Message != "error message" {
		t.Errorf("Expected message 'error message', got '%s'", entry.Message)
	}

	// Check for the error field
	contextMap := entry.ContextMap()
	fieldValue, ok := contextMap["error"]
	if !ok {
		t.Error("Field 'error' not found in log entry")
	} else if fieldValue != "test error" {
		t.Errorf("Expected 'error' to be 'test error', got '%v'", fieldValue)
	}
}

// TestDPanic tests the DPanic global function
func TestDPanic(t *testing.T) {
	// Setup test
	observedLogs, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Call the function being tested
	DPanic("dpanic message", zap.String("key", "value"))

	// Verify the log entry
	logs := observedLogs.All()
	if len(logs) != 1 {
		t.Fatalf("Expected 1 log entry, got %d", len(logs))
	}

	entry := logs[0]
	if entry.Level != zapcore.DPanicLevel {
		t.Errorf("Expected level DPanicLevel, got %v", entry.Level)
	}
	if entry.Message != "dpanic message" {
		t.Errorf("Expected message 'dpanic message', got '%s'", entry.Message)
	}
}

// We don't test Panic and Fatal because they would terminate the test process

// TestSync tests the Sync global function
func TestSync(t *testing.T) {
	// Setup test
	_, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Call the function being tested
	// This just tests that Sync doesn't panic
	err := Sync()
	if err != nil {
		// Some implementations of zap.Logger.Sync() return an error
		// on certain platforms, so we don't fail the test if it returns an error
		t.Logf("Sync() returned error: %v", err)
	}
}

// TestWith tests the With global function
func TestWith(t *testing.T) {
	// Setup test
	observedLogs, cleanup := setupGlobalLoggerTest()
	defer cleanup()

	// Call the function being tested
	logger := With(zap.String("component", "test"))

	// Use the returned logger
	logger.Info("test message")

	// Verify the log entry
	logs := observedLogs.All()
	if len(logs) != 1 {
		t.Fatalf("Expected 1 log entry, got %d", len(logs))
	}

	entry := logs[0]
	if entry.Level != zapcore.InfoLevel {
		t.Errorf("Expected level InfoLevel, got %v", entry.Level)
	}
	if entry.Message != "test message" {
		t.Errorf("Expected message 'test message', got '%s'", entry.Message)
	}

	// Check for the component field
	contextMap := entry.ContextMap()
	fieldValue, ok := contextMap["component"]
	if !ok {
		t.Error("Field 'component' not found in log entry")
	} else if fieldValue != "test" {
		t.Errorf("Expected 'component' to be 'test', got '%v'", fieldValue)
	}
}

// testError is a simple error implementation for testing
type testError struct {
	message string
}

func (e *testError) Error() string {
	return e.message
}