aurganize-backend/backend/pkg/logger/logger_test.go

package logger

import (
	"bytes"
	"testing"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"
	"github.com/stretchr/testify/assert"
)

// TestInit_Developement tests logger initialization in development mode
func TestInit_Development(t *testing.T) {
	// Arrange
	environment := "development"

	// Act
	Init(environment)

	// Assert
	assert.Equal(t, zerolog.DebugLevel, zerolog.GlobalLevel(), "Development should use Debug level")
}

// TestInit_Production tests logger initialization in production mode
func TestInit_Production(t *testing.T) {
	// Arrange
	environment := "production"

	// Act
	Init(environment)

	// Assert
	assert.Equal(t, zerolog.InfoLevel, zerolog.GlobalLevel(), "Production should use Info level")
}

func TestInitWithLevel(t *testing.T) {
	tests := []struct {
		name          string
		environment   string
		level         string
		expectedLevel zerolog.Level
	}{
		{
			name:          "Debug level",
			environment:   "production",
			level:         LevelDebug,
			expectedLevel: zerolog.DebugLevel,
		},
		{
			name:          "Info level",
			environment:   "production",
			level:         LevelInfo,
			expectedLevel: zerolog.InfoLevel,
		},
		{
			name:          "Warn level",
			environment:   "production",
			level:         LevelWarn,
			expectedLevel: zerolog.WarnLevel,
		},
		{
			name:          "Error level",
			environment:   "production",
			level:         LevelError,
			expectedLevel: zerolog.ErrorLevel,
		},
		{
			name:          "Invalid level defaults to Info",
			environment:   "production",
			level:         "invalid",
			expectedLevel: zerolog.InfoLevel,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			// Act
			InitWithLevel(test.environment, test.level)

			// Assert
			assert.Equal(t, test.expectedLevel, zerolog.GlobalLevel())
		})
	}
}

// TestGetLogger tests getting logger instance
func TestGetLogger(t *testing.T) {
	// Arrage
	Init("development")
	// Act
	logger := GetLogger()

	// Assert
	assert.NotNil(t, logger, "GetLogger should return non-nil logger")
}

// TestWithContext tests logging with additional context
func TestWithContext(t *testing.T) {
	// Arrange
	var buff bytes.Buffer
	log.Logger = zerolog.New(&buff)

	fields := map[string]interface{}{
		"request_id": "test-123",
		"user_id":    "user-456",
	}

	// Act
	logger := WithContext(fields)
	logger.Info().Msg("Test message")

	// Assert
	output := buff.String()
	assert.Contains(t, output, "test-123", "should include the request_id")
	assert.Contains(t, output, "user-456", "should include the user_id")
	assert.Contains(t, output, "Test message", "should include message")
}

// TestLogLevels tests that log levels fitler correctly
func TestLogLevels(t *testing.T) {
	tests := []struct {
		name         string
		setLevel     zerolog.Level
		logLevel     zerolog.Level
		shouldAppear bool
	}{
		{
			name:         "Debug message appears when level is Debug",
			setLevel:     zerolog.DebugLevel,
			logLevel:     zerolog.DebugLevel,
			shouldAppear: true,
		},
		{
			name:         "Debug message hidden when level is Info",
			setLevel:     zerolog.InfoLevel,
			logLevel:     zerolog.DebugLevel,
			shouldAppear: false,
		},
		{
			name:         "Error message appears when level is Info",
			setLevel:     zerolog.InfoLevel,
			logLevel:     zerolog.ErrorLevel,
			shouldAppear: true,
		},
	}
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			// Arrange
			var buff bytes.Buffer
			zerolog.SetGlobalLevel(test.setLevel)
			log.Logger = zerolog.New(&buff)

			// Act
			switch test.logLevel {
			case zerolog.DebugLevel:
				log.Debug().Msg("test message")
			case zerolog.InfoLevel:
				log.Info().Msg("test message")
			case zerolog.ErrorLevel:
				log.Error().Msg("test message")
			}

			// Assert
			output := buff.String()
			if test.shouldAppear {
				assert.Contains(t, output, "test message")
			} else {
				assert.Empty(t, output)
			}
		})
	}

}

// BenchmarkLogger benchmarks logger performance
func BenchmarkLogger(b *testing.B) {
	// Setup
	var buff bytes.Buffer
	log.Logger = zerolog.New(&buff)

	b.ResetTimer()

	// Run Benchmark

	for i := 0; i < b.N; i++ {
		log.Info().
			Str("key", "value").
			Int("number", 42).
			Msg("Benchmark message")
	}
}

// Benchmark Logger with multiple fields
func BenchmarkLoggerWithFields(b *testing.B) {
	// Setup
	var buff bytes.Buffer
	log.Logger = zerolog.New(&buff)

	b.ResetTimer()

	// Run Benchmark
	for i := 0; i < b.N; i++ {
		log.Info().
			Str("request_id", "abc-123").
			Str("user_id", "user-456").
			Str("method", "POST").
			Str("path", "/api/v1/users").
			Int("status", 200).
			Dur("duration", 150).
			Msg("Request completed")
	}
}