99 lines
2.2 KiB
Go
99 lines
2.2 KiB
Go
// FILE: lixenwraith/log/state_test.go
|
|
package log
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestLoggerShutdown(t *testing.T) {
|
|
t.Run("normal shutdown", func(t *testing.T) {
|
|
logger, _ := createTestLogger(t)
|
|
|
|
// Write some logs
|
|
logger.Info("shutdown test")
|
|
|
|
// Shutdown
|
|
err := logger.Shutdown(2 * time.Second)
|
|
assert.NoError(t, err)
|
|
|
|
// Verify state
|
|
assert.True(t, logger.state.ShutdownCalled.Load())
|
|
assert.True(t, logger.state.LoggerDisabled.Load())
|
|
assert.False(t, logger.state.IsInitialized.Load())
|
|
})
|
|
|
|
t.Run("shutdown timeout", func(t *testing.T) {
|
|
logger, _ := createTestLogger(t)
|
|
|
|
// Fill buffer to potentially block processor
|
|
for i := 0; i < 200; i++ {
|
|
logger.Info("flood", i)
|
|
}
|
|
|
|
// Short timeout
|
|
err := logger.Shutdown(1 * time.Millisecond)
|
|
// May or may not timeout depending on system speed
|
|
_ = err
|
|
})
|
|
|
|
t.Run("shutdown before init", func(t *testing.T) {
|
|
logger := NewLogger()
|
|
err := logger.Shutdown()
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
t.Run("double shutdown", func(t *testing.T) {
|
|
logger, _ := createTestLogger(t)
|
|
|
|
err1 := logger.Shutdown()
|
|
err2 := logger.Shutdown()
|
|
|
|
assert.NoError(t, err1)
|
|
assert.NoError(t, err2)
|
|
})
|
|
}
|
|
|
|
func TestLoggerFlush(t *testing.T) {
|
|
t.Run("successful flush", func(t *testing.T) {
|
|
logger, tmpDir := createTestLogger(t)
|
|
defer logger.Shutdown()
|
|
|
|
logger.Info("flush test")
|
|
|
|
// Small delay to process log
|
|
time.Sleep(100 * time.Millisecond)
|
|
|
|
err := logger.Flush(time.Second)
|
|
assert.NoError(t, err)
|
|
|
|
// Verify data written
|
|
content, err := os.ReadFile(filepath.Join(tmpDir, "log.log"))
|
|
require.NoError(t, err)
|
|
assert.Contains(t, string(content), "flush test")
|
|
})
|
|
|
|
t.Run("flush timeout", func(t *testing.T) {
|
|
logger, _ := createTestLogger(t)
|
|
defer logger.Shutdown()
|
|
|
|
// Very short timeout
|
|
err := logger.Flush(1 * time.Nanosecond)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "timeout")
|
|
})
|
|
|
|
t.Run("flush after shutdown", func(t *testing.T) {
|
|
logger, _ := createTestLogger(t)
|
|
logger.Shutdown()
|
|
|
|
err := logger.Flush(time.Second)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "not initialized")
|
|
})
|
|
} |