go-trustlog/api/logger/adapter_test.go

package logger_test

import (
	"context"
	"errors"
	"testing"

	"github.com/go-logr/logr"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	"go.yandata.net/wangsiyuan/go-trustlog/api/logger"
)

func TestNewLogger(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	result := logger.NewLogger(l)
	assert.NotNil(t, result)
}

func TestNewDefaultLogger(t *testing.T) {
	t.Parallel()

	result := logger.NewDefaultLogger()
	assert.NotNil(t, result)
}

func TestNewNopLogger(t *testing.T) {
	t.Parallel()

	result := logger.NewNopLogger()
	assert.NotNil(t, result)
}

func TestNopLogger_Methods(t *testing.T) {
	t.Parallel()

	nop := logger.NewNopLogger()
	ctx := context.Background()

	// All methods should not panic
	assert.NotPanics(t, func() {
		nop.DebugContext(ctx, "test")
		nop.InfoContext(ctx, "test")
		nop.WarnContext(ctx, "test")
		nop.ErrorContext(ctx, "test")
		nop.Debug("test")
		nop.Info("test")
		nop.Warn("test")
		nop.Error("test")
	})
}

func TestLogrAdapter_DebugContext(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)
	ctx := context.Background()

	assert.NotPanics(t, func() {
		adapter.DebugContext(ctx, "debug message", "key", "value")
	})
}

func TestLogrAdapter_InfoContext(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)
	ctx := context.Background()

	assert.NotPanics(t, func() {
		adapter.InfoContext(ctx, "info message", "key", "value")
	})
}

func TestLogrAdapter_WarnContext(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)
	ctx := context.Background()

	assert.NotPanics(t, func() {
		adapter.WarnContext(ctx, "warn message", "key", "value")
	})
}

func TestLogrAdapter_ErrorContext(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)
	ctx := context.Background()

	tests := []struct {
		name string
		args []any
	}{
		{
			name: "with error",
			args: []any{"error", errors.New("test error"), "key", "value"},
		},
		{
			name: "without error",
			args: []any{"key", "value"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.NotPanics(t, func() {
				adapter.ErrorContext(ctx, "error message", tt.args...)
			})
		})
	}
}

func TestLogrAdapter_Debug(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)

	assert.NotPanics(t, func() {
		adapter.Debug("debug message", "key", "value")
	})
}

func TestLogrAdapter_Info(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)

	assert.NotPanics(t, func() {
		adapter.Info("info message", "key", "value")
	})
}

func TestLogrAdapter_Warn(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)

	assert.NotPanics(t, func() {
		adapter.Warn("warn message", "key", "value")
	})
}

func TestLogrAdapter_Error(t *testing.T) {
	t.Parallel()

	l := logr.Discard()
	adapter := logger.NewLogger(l)

	tests := []struct {
		name string
		args []any
	}{
		{
			name: "with error",
			args: []any{"error", errors.New("test error"), "key", "value"},
		},
		{
			name: "without error",
			args: []any{"key", "value"},
		},
		{
			name: "odd number of args",
			args: []any{"key", "value", "extra"},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			assert.NotPanics(t, func() {
				adapter.Error("error message", tt.args...)
			})
		})
	}
}

func TestSetGlobalLogger(t *testing.T) {
	t.Parallel()

	original := logger.GetGlobalLogger()
	defer logger.SetGlobalLogger(original)

	newLogger := logger.NewNopLogger()
	logger.SetGlobalLogger(newLogger)

	result := logger.GetGlobalLogger()
	assert.Equal(t, newLogger, result)
}

func TestSetGlobalLogger_Nil(t *testing.T) {
	t.Parallel()

	original := logger.GetGlobalLogger()
	defer logger.SetGlobalLogger(original)

	logger.SetGlobalLogger(nil)
	result := logger.GetGlobalLogger()
	assert.NotNil(t, result) // Should be NopLogger
}

func TestGetGlobalLogger(t *testing.T) {
	t.Parallel()

	result := logger.GetGlobalLogger()
	assert.NotNil(t, result)
}

func TestGlobalLogger_ConcurrentAccess(t *testing.T) {
	t.Parallel()

	original := logger.GetGlobalLogger()
	defer logger.SetGlobalLogger(original)

	// Test concurrent reads
	done := make(chan bool, 10)
	for range 10 {
		go func() {
			_ = logger.GetGlobalLogger()
			done <- true
		}()
	}

	for range 10 {
		<-done
	}

	// Test concurrent writes
	newLogger := logger.NewNopLogger()
	for range 5 {
		go func() {
			logger.SetGlobalLogger(newLogger)
			done <- true
		}()
	}

	for range 5 {
		<-done
	}

	result := logger.GetGlobalLogger()
	require.NotNil(t, result)
}