Files
mtusi2026lab4/internal/logger/logger_test.go
T
2026-10-01 12:44:59 +03:00

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)
})
}
}