slogx_test.go

package slogx_test

import (
	"context"
	"log/slog"
	"os"
	"testing"

	"github.com/stretchr/testify/require"
	"github.com/yylego/slogx"
)

// setupTestLogger creates a JSON log instance in testing
// setupTestLogger 创建测试用 JSON 日志实例
func setupTestLogger() *slog.Logger {
	return slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
		AddSource: true,
		Level:     slog.LevelDebug,
	}))
}

// =============== Basic structure and constructor tests ===============
// =============== 基础结构和构造函数测试 ===============

// TestNew tests the New function
// TestNew 测试 New 函数
func TestNew(t *testing.T) {
	l := setupTestLogger()
	g := slogx.New(l)
	require.NotNil(t, g)

	require.Panics(t, func() {
		slogx.New(nil)
	})
}

// TestWithCallerSkip tests the WithCallerSkip function
// TestWithCallerSkip 测试 WithCallerSkip 功能
func TestWithCallerSkip(t *testing.T) {
	l := setupTestLogger()
	g := slogx.New(l)

	help := func(msg string) {
		g.Info(msg + " (no skip)")
		g.WithCallerSkip(1).Info(msg + " (with skip)")
	}

	help("caller skip test")

	a := func(msg string) {
		g.WithCallerSkip(2).Info(msg + " (nested skip)")
	}
	b := func(msg string) {
		a(msg)
	}
	b("multi-level skip test")
}

// TestSkip tests the Skip method in detail
// TestSkip 详细测试 Skip 方法
func TestSkip(t *testing.T) {
	l := setupTestLogger()
	g := slogx.New(l)

	help := func(msg string) {
		g.Info(msg + " (no skip)")
		g.Skip(1).Info(msg + " (Skip method)")
		g.WithCallerSkip(1).Info(msg + " (WithCallerSkip method)")
	}

	help("skip method test")

	a := g.Skip(2)
	b := g.WithCallerSkip(2)

	// Both should have same skip value inside
	// 两者内部的 skip 值应该相同
	require.Equal(t, a.Handler(), b.Handler())
}

// =============== slog-compatible no-context version tests ===============
// =============== slog 兼容的无上下文版本测试 ===============

// TestBasicLoggingMethods tests Debug, Info, Warn, Error methods
// TestBasicLoggingMethods 测试 Debug, Info, Warn, Error 方法
func TestBasicLoggingMethods(t *testing.T) {
	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		l.Debug("debug message", "key", "debug_value")
		l.Info("info message", "key", "info_value")
		l.Warn("warn message", "key", "warn_value")
		l.Error("error message", "key", "error_value")
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		g.Debug("debug message", "key", "debug_value")
		g.Info("info message", "key", "info_value")
		g.Warn("warn message", "key", "warn_value")
		g.Error("error message", "key", "error_value")
	})
}

// =============== slog-compatible context version tests ===============
// =============== slog 兼容的带上下文版本测试 ===============

// TestContextMethods tests DebugContext, InfoContext, WarnContext, ErrorContext methods
// TestContextMethods 测试 DebugContext, InfoContext, WarnContext, ErrorContext 方法
func TestContextMethods(t *testing.T) {
	ctx := context.Background()

	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		l.DebugContext(ctx, "debug context", "context", true)
		l.InfoContext(ctx, "info context", "context", true)
		l.WarnContext(ctx, "warn context", "context", true)
		l.ErrorContext(ctx, "error context", "context", true)
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		g.DebugContext(ctx, "debug context", "context", true)
		g.InfoContext(ctx, "info context", "context", true)
		g.WarnContext(ctx, "warn context", "context", true)
		g.ErrorContext(ctx, "error context", "context", true)
	})
}

// =============== slog-compatible structured attribute version tests ===============
// =============== slog 兼容的结构化属性版本测试 ===============

// TestLogAndLogAttrs tests Log and LogAttrs methods
// TestLogAndLogAttrs 测试 Log 和 LogAttrs 方法
func TestLogAndLogAttrs(t *testing.T) {
	ctx := context.Background()

	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		l.Log(ctx, slog.LevelInfo, "generic log", "method", "Log")
		l.LogAttrs(ctx, slog.LevelInfo, "structured log",
			slog.String("method", "LogAttrs"),
			slog.Int("number", 42))
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		g.Log(ctx, slog.LevelInfo, "generic log", "method", "Log")
		g.LogAttrs(ctx, slog.LevelInfo, "structured log",
			slog.String("method", "LogAttrs"),
			slog.Int("number", 42))
	})
}

// =============== slog-compatible With and support function tests ===============
// =============== slog 兼容的 With 和工具函数测试 ===============

// TestWith tests the With method
// TestWith 测试 With 方法
func TestWith(t *testing.T) {
	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		a := l.With("service", "test", "version", "1.0")
		a.Info("with fields test")
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		a := g.With("service", "test", "version", "1.0")
		a.Info("with fields test")

		b := g.With()
		require.Equal(t, g.Handler(), b.Handler())

		c := g.WithCallerSkip(1).With("preserved", true)
		c.Info("skip preserved test")
	})
}

// TestWithGroup tests the WithGroup method
// TestWithGroup 测试 WithGroup 方法
func TestWithGroup(t *testing.T) {
	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		a := l.WithGroup("app")
		a.Info("group test", "component", "auth")

		b := l.With("request_id", "123").WithGroup("api")
		b.Info("chained logger test")
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		a := g.WithGroup("app")
		a.Info("group test", "component", "auth")

		b := g.WithCallerSkip(0).With("request_id", "123").WithGroup("api")
		b.Info("chained logger test")
	})
}

// TestEnabled tests the Enabled method
// TestEnabled 测试 Enabled 方法
func TestEnabled(t *testing.T) {
	ctx := context.Background()

	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		require.True(t, l.Enabled(ctx, slog.LevelInfo))
		require.False(t, l.Enabled(ctx, slog.LevelDebug-1))
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		require.True(t, g.Enabled(ctx, slog.LevelInfo))
		require.False(t, g.Enabled(ctx, slog.LevelDebug-1))
	})
}

// TestHandler tests the Handler method
// TestHandler 测试 Handler 方法
func TestHandler(t *testing.T) {
	t.Run("StandardSlog", func(t *testing.T) {
		x := setupTestLogger()

		// Test Handler method with standard slog
		// 使用标准 slog 测试 Handler 方法
		h := x.Handler()
		require.NotNil(t, h)
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		x := setupTestLogger()
		g := slogx.New(x)

		// Test Handler method with slogx
		// 使用 slogx 测试 Handler 方法
		h := g.Handler()
		require.NotNil(t, h)

		// Check handle component matches the base (slogx should not change the handle component)
		// 验证 handle 组件与原始的相同（slogx 不应修改 handle 组件）
		o := x.Handler()
		require.Equal(t, o, h)
	})
}

// =============== Comprehensive function tests ===============
// =============== 综合功能测试 ===============

// TestSkipWithAllMethods tests Skip method with all logging methods
// TestSkipWithAllMethods 测试 Skip 方法与所有日志方法的配合
func TestSkipWithAllMethods(t *testing.T) {
	l := setupTestLogger()
	g := slogx.New(l)
	ctx := context.Background()

	// Test Skip method with different log levels
	// 测试 Skip 方法与不同日志级别
	s := g.Skip(1)
	s.Debug("debug with skip")
	s.Info("info with skip")
	s.Warn("warn with skip")
	s.Error("error with skip")

	s.DebugContext(ctx, "debug context with skip")
	s.InfoContext(ctx, "info context with skip")
	s.WarnContext(ctx, "warn context with skip")
	s.ErrorContext(ctx, "error context with skip")

	s.Log(ctx, slog.LevelInfo, "generic log with skip", "method", "Log")
	s.LogAttrs(ctx, slog.LevelInfo, "structured log with skip",
		slog.String("method", "LogAttrs"),
		slog.Int("skip", 1))

	a := g.Skip(1).With("test", "value")
	a.Info("skip with chaining test")

	b := g.Skip(1).WithGroup("test")
	b.Info("skip group chaining test")

	g.Skip(1).Skip(1).Info("double skip test", "total", 2)
}

// TestErrorHandling tests edge cases and error conditions
// TestErrorHandling 测试边缘情况和错误条件
func TestErrorHandling(t *testing.T) {
	l := setupTestLogger()
	g := slogx.New(l)

	g.Info("odd args test", "key1", "value1", "key2", "value2", "orphan")

	g.Info("non-string keys test", 123, "numeric", true, "boolean", 3.14, "float")
}

// TestSkipEdgeCases tests edge cases with skip values
// TestSkipEdgeCases 测试 skip 值的边缘情况
func TestSkipEdgeCases(t *testing.T) {
	l := setupTestLogger()
	g := slogx.New(l)

	g.Skip(-1).Info("negative skip test")

	g.Skip(0).Info("zero skip test")

	g.Skip(100).Info("large skip test")

	g.Skip(1).Skip(1).Info("chained skip test", "total", 2)

	g.Skip(1).WithCallerSkip(1).Info("mixed skip methods test", "total", 2)
}

// TestSlogCompatibility ensures 1:1 API mapping with slog.Logger
// TestSlogCompatibility 确保与 slog.Logger 的 1:1 API 兼容性
func TestSlogCompatibility(t *testing.T) {
	ctx := context.Background()

	t.Run("StandardSlog", func(t *testing.T) {
		l := setupTestLogger()

		l.Debug("test", "key", "value")
		l.Info("test", "key", "value")
		l.Warn("test", "key", "value")
		l.Error("test", "key", "value")

		l.DebugContext(ctx, "test", "key", "value")
		l.InfoContext(ctx, "test", "key", "value")
		l.WarnContext(ctx, "test", "key", "value")
		l.ErrorContext(ctx, "test", "key", "value")

		l.Log(ctx, slog.LevelInfo, "test", "key", "value")
		l.LogAttrs(ctx, slog.LevelInfo, "test", slog.String("key", "value"))

		e := l.Enabled(ctx, slog.LevelInfo)
		h := l.Handler()

		require.True(t, e)
		require.NotNil(t, h)

		a := l.With("key", "value")
		b := l.WithGroup("group")

		require.NotEqual(t, l.Handler(), a.Handler())
		require.NotEqual(t, l.Handler(), b.Handler())
	})

	t.Run("SlogxWrapper", func(t *testing.T) {
		l := setupTestLogger()
		g := slogx.New(l)

		g.Debug("test", "key", "value")
		g.Info("test", "key", "value")
		g.Warn("test", "key", "value")
		g.Error("test", "key", "value")

		g.DebugContext(ctx, "test", "key", "value")
		g.InfoContext(ctx, "test", "key", "value")
		g.WarnContext(ctx, "test", "key", "value")
		g.ErrorContext(ctx, "test", "key", "value")

		g.Log(ctx, slog.LevelInfo, "test", "key", "value")
		g.LogAttrs(ctx, slog.LevelInfo, "test", slog.String("key", "value"))

		e := g.Enabled(ctx, slog.LevelInfo)
		h := g.Handler()

		require.True(t, e)
		require.NotNil(t, h)

		a := g.With("key", "value")
		b := g.WithGroup("group")

		require.NotEqual(t, g.Handler(), a.Handler())
		require.NotEqual(t, g.Handler(), b.Handler())

		c := g.WithCallerSkip(1)
		c.Info("caller skip test")

		s := g.Skip(1)
		s.Info("skip method test")
	})
}

// TestSugar tests Logger.Sugar() method
// TestSugar 测试 Logger.Sugar() 方法
func TestSugar(t *testing.T) {
	logger := setupTestLogger()
	g := slogx.New(logger)

	sugar := g.Sugar()
	require.NotNil(t, sugar)

	// Test basic SugaredLogger function
	// 测试基本 SugaredLogger 功能
	sugar.Info("test", "message", 123)
	sugar.Debug("1", 2, 3, 4, "5", 6)   // Should be "12 3 456"
	sugar.Debugln("1", 2, 3, 4, "5", 6) // Should be "1 2 3 4 5 6"

	// Test chaining with other Logger methods
	// 测试与其他 Logger 方法的链式调用
	g.Skip(1).Sugar().Warn("chained", "skip", "sugar")
	g.WithGroup("test").Sugar().Error("grouped", "sugar", "logging")
}