194 lines
4.3 KiB
Go
194 lines
4.3 KiB
Go
package logger_test
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"log/slog"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
"mtusi-messenger/internal/logger"
|
|
)
|
|
|
|
type LoggerSuite struct {
|
|
suite.Suite
|
|
|
|
bb *bytes.Buffer
|
|
}
|
|
|
|
func TestLoggerSuite(t *testing.T) {
|
|
t.Parallel()
|
|
suite.Run(t, new(LoggerSuite))
|
|
}
|
|
|
|
func (s *LoggerSuite) SetupTest() {
|
|
s.bb = &bytes.Buffer{}
|
|
}
|
|
|
|
func (s *LoggerSuite) records() []map[string]any {
|
|
var out []map[string]any
|
|
|
|
for line := range strings.SplitSeq(strings.TrimSpace(s.bb.String()), "\n") {
|
|
if line == "" {
|
|
continue
|
|
}
|
|
|
|
var record map[string]any
|
|
s.Require().NoError(json.Unmarshal([]byte(line), &record))
|
|
|
|
out = append(out, record)
|
|
}
|
|
|
|
return out
|
|
}
|
|
|
|
func (s *LoggerSuite) TestJSONOutputCarriesAttributes() {
|
|
log := logger.New(logger.WithWriter(s.bb))
|
|
|
|
log.Info("сервер запущен", slog.String("addr", "0.0.0.0:8080"))
|
|
|
|
records := s.records()
|
|
s.Require().Len(records, 1)
|
|
|
|
s.Equal("info", records[0]["level"])
|
|
s.Equal("сервер запущен", records[0]["msg"])
|
|
s.Equal("0.0.0.0:8080", records[0]["addr"])
|
|
s.Contains(records[0], "time")
|
|
}
|
|
|
|
func (s *LoggerSuite) TestDefaultLevelDropsDebug() {
|
|
log := logger.New(logger.WithWriter(s.bb))
|
|
|
|
log.Debug("не должно попасть в вывод")
|
|
log.Info("должно попасть")
|
|
|
|
records := s.records()
|
|
s.Require().Len(records, 1)
|
|
s.Equal("должно попасть", records[0]["msg"])
|
|
}
|
|
|
|
func (s *LoggerSuite) TestWithLevelEnablesDebug() {
|
|
log := logger.New(logger.WithWriter(s.bb), logger.WithLevel(slog.LevelDebug))
|
|
|
|
log.Debug("подробность")
|
|
|
|
records := s.records()
|
|
s.Require().Len(records, 1)
|
|
s.Equal("debug", records[0]["level"])
|
|
}
|
|
|
|
func (s *LoggerSuite) TestGroupsAreNested() {
|
|
log := logger.New(logger.WithWriter(s.bb))
|
|
|
|
log.Info("запрос", slog.Group("payload", slog.Int("size", 12)))
|
|
|
|
records := s.records()
|
|
s.Require().Len(records, 1)
|
|
|
|
payload, ok := records[0]["payload"].(map[string]any)
|
|
s.Require().True(ok, "группа должна кодироваться вложенным объектом")
|
|
s.InDelta(12, payload["size"], 0)
|
|
}
|
|
|
|
func (s *LoggerSuite) TestWithNameSetsLoggerField() {
|
|
log := logger.New(logger.WithWriter(s.bb), logger.WithName("messenger"))
|
|
|
|
log.Info("старт")
|
|
|
|
records := s.records()
|
|
s.Require().Len(records, 1)
|
|
s.Equal("messenger", records[0]["logger"])
|
|
}
|
|
|
|
func (s *LoggerSuite) TestConsoleFormatIsNotJSON() {
|
|
log := logger.New(s.consoleOptions()...)
|
|
|
|
log.Info("человекочитаемо")
|
|
|
|
line := strings.TrimSpace(s.bb.String())
|
|
s.Require().NotEmpty(line)
|
|
|
|
var record map[string]any
|
|
s.Require().Error(json.Unmarshal([]byte(line), &record), "console-формат не должен быть JSON")
|
|
s.Contains(line, "человекочитаемо")
|
|
}
|
|
|
|
func (s *LoggerSuite) consoleOptions() []logger.Option {
|
|
return []logger.Option{
|
|
logger.WithWriter(s.bb),
|
|
logger.WithFormat(logger.FormatConsole),
|
|
}
|
|
}
|
|
|
|
func (s *LoggerSuite) TestNilWriterKeepsDefault() {
|
|
s.Require().NotPanics(func() {
|
|
logger.New(logger.WithWriter(nil)).Info("пишем в stdout по умолчанию")
|
|
})
|
|
}
|
|
|
|
func TestParseLevel(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := map[string]struct {
|
|
want slog.Level
|
|
wantErr bool
|
|
}{
|
|
"debug": {want: slog.LevelDebug},
|
|
"info": {want: slog.LevelInfo},
|
|
"WARN": {want: slog.LevelWarn},
|
|
"error": {want: slog.LevelError},
|
|
"trace": {wantErr: true},
|
|
"": {wantErr: true},
|
|
}
|
|
|
|
for raw, tt := range tests {
|
|
t.Run(raw, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, err := logger.ParseLevel(raw)
|
|
if tt.wantErr {
|
|
require.ErrorIs(t, err, logger.ErrUnknownLevel)
|
|
|
|
return
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
require.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseFormat(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := map[string]struct {
|
|
want logger.Format
|
|
wantErr bool
|
|
}{
|
|
"json": {want: logger.FormatJSON},
|
|
"JSON": {want: logger.FormatJSON},
|
|
"console": {want: logger.FormatConsole},
|
|
"xml": {wantErr: true},
|
|
"": {wantErr: true},
|
|
}
|
|
|
|
for raw, tt := range tests {
|
|
t.Run(raw, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, err := logger.ParseFormat(raw)
|
|
if tt.wantErr {
|
|
require.ErrorIs(t, err, logger.ErrUnknownFormat)
|
|
|
|
return
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
require.Equal(t, tt.want, got)
|
|
})
|
|
}
|
|
}
|